URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [net/] [atm/] [mpoa_caches.c] - Blame information for rev 1765

Details | Compare with Previous | View Log


#include <linux/types.h>
#include <linux/atmmpc.h>
#include <linux/time.h>
 
#include "mpoa_caches.h"
#include "mpc.h"
 
/*
 * mpoa_caches.c: Implementation of ingress and egress cache
 * handling functions
 */
 
#if 0
#define dprintk printk    /* debug */
#else
#define dprintk(format,args...)
#endif
 
#if 0
#define ddprintk printk  /* more debug */
#else
#define ddprintk(format,args...)
#endif
 
static in_cache_entry *in_cache_get(uint32_t dst_ip,
                                    struct mpoa_client *client)
{
        in_cache_entry *entry;
 
        read_lock_bh(&client->ingress_lock);
        entry = client->in_cache;
        while(entry != NULL){
                if( entry->ctrl_info.in_dst_ip == dst_ip ){
                        atomic_inc(&entry->use);
                        read_unlock_bh(&client->ingress_lock);
                        return entry;
                }
                entry = entry->next;
        }
        read_unlock_bh(&client->ingress_lock);
 
        return NULL;
}
 
static in_cache_entry *in_cache_get_with_mask(uint32_t dst_ip,
                                              struct mpoa_client *client,
                                              uint32_t mask)
{
        in_cache_entry *entry;
 
        read_lock_bh(&client->ingress_lock);
        entry = client->in_cache;
        while(entry != NULL){
                if((entry->ctrl_info.in_dst_ip & mask)  == (dst_ip & mask )){
                        atomic_inc(&entry->use);
                        read_unlock_bh(&client->ingress_lock);
                        return entry;
                }
                entry = entry->next;
        }
        read_unlock_bh(&client->ingress_lock);
 
        return NULL;
 
}
 
static in_cache_entry *in_cache_get_by_vcc(struct atm_vcc *vcc,
                                           struct mpoa_client *client )
{
        in_cache_entry *entry;
 
        read_lock_bh(&client->ingress_lock);
        entry = client->in_cache;
        while(entry != NULL){
                if(entry->shortcut == vcc) {
                        atomic_inc(&entry->use);
                        read_unlock_bh(&client->ingress_lock);
                        return entry;
                }
                entry = entry->next;
        }
        read_unlock_bh(&client->ingress_lock);
 
        return NULL;
}
 
static in_cache_entry *in_cache_add_entry(uint32_t dst_ip,
                                          struct mpoa_client *client)
{
        unsigned char *ip __attribute__ ((unused)) = (unsigned char *)&dst_ip;
        in_cache_entry* entry = kmalloc(sizeof(in_cache_entry), GFP_KERNEL);
 
        if (entry == NULL) {
                printk("mpoa: mpoa_caches.c: new_in_cache_entry: out of memory\n");
                return NULL;
        }
 
        dprintk("mpoa: mpoa_caches.c: adding an ingress entry, ip = %u.%u.%u.%u\n", ip[0], ip[1], ip[2], ip[3]);
        memset(entry,0,sizeof(in_cache_entry));
 
        atomic_set(&entry->use, 1);
        dprintk("mpoa: mpoa_caches.c: new_in_cache_entry: about to lock\n");
        write_lock_bh(&client->ingress_lock);
        entry->next = client->in_cache;
        entry->prev = NULL;
        if (client->in_cache != NULL)
                client->in_cache->prev = entry;
        client->in_cache = entry;
 
        memcpy(entry->MPS_ctrl_ATM_addr, client->mps_ctrl_addr, ATM_ESA_LEN);
        entry->ctrl_info.in_dst_ip = dst_ip;
        do_gettimeofday(&(entry->tv));
        entry->retry_time = client->parameters.mpc_p4;
        entry->count = 1;
        entry->entry_state = INGRESS_INVALID;
        entry->ctrl_info.holding_time = HOLDING_TIME_DEFAULT;
        atomic_inc(&entry->use);
 
        write_unlock_bh(&client->ingress_lock);
        dprintk("mpoa: mpoa_caches.c: new_in_cache_entry: unlocked\n");
 
        return entry;
}
 
static int cache_hit(in_cache_entry *entry, struct mpoa_client *mpc)
{
        struct atm_mpoa_qos *qos;
        struct k_message msg;
 
        entry->count++;
        if(entry->entry_state == INGRESS_RESOLVED && entry->shortcut != NULL)
                return OPEN;
 
        if(entry->entry_state == INGRESS_REFRESHING){
                if(entry->count > mpc->parameters.mpc_p1){
                        msg.type = SND_MPOA_RES_RQST;
                        msg.content.in_info = entry->ctrl_info;
                        memcpy(msg.MPS_ctrl, mpc->mps_ctrl_addr, ATM_ESA_LEN);
                        qos = atm_mpoa_search_qos(entry->ctrl_info.in_dst_ip);
                        if (qos != NULL) msg.qos = qos->qos;
                        msg_to_mpoad(&msg, mpc);
                        do_gettimeofday(&(entry->reply_wait));
                        entry->entry_state = INGRESS_RESOLVING;
                }
                if(entry->shortcut != NULL)
                        return OPEN;
                return CLOSED;
        }
 
        if(entry->entry_state == INGRESS_RESOLVING && entry->shortcut != NULL)
                return OPEN;
 
        if( entry->count > mpc->parameters.mpc_p1 &&
            entry->entry_state == INGRESS_INVALID){
                unsigned char *ip __attribute__ ((unused)) =
                    (unsigned char *)&entry->ctrl_info.in_dst_ip;
 
                dprintk("mpoa: (%s) mpoa_caches.c: threshold exceeded for ip %u.%u.%u.%u, sending MPOA res req\n", mpc->dev->name, ip[0], ip[1], ip[2], ip[3]);
                entry->entry_state = INGRESS_RESOLVING;
                msg.type =  SND_MPOA_RES_RQST;
                memcpy(msg.MPS_ctrl, mpc->mps_ctrl_addr, ATM_ESA_LEN );
                msg.content.in_info = entry->ctrl_info;
                qos = atm_mpoa_search_qos(entry->ctrl_info.in_dst_ip);
                if (qos != NULL) msg.qos = qos->qos;
                msg_to_mpoad( &msg, mpc);
                do_gettimeofday(&(entry->reply_wait));
        }
 
        return CLOSED;
}
 
static void in_cache_put(in_cache_entry *entry)
{
        if (atomic_dec_and_test(&entry->use)) {
                memset(entry, 0, sizeof(in_cache_entry));
                kfree(entry);
        }
 
        return;
}
 
/*
 * This should be called with write lock on
 */
static void in_cache_remove_entry(in_cache_entry *entry,
                                  struct mpoa_client *client)
{
        struct atm_vcc *vcc;
        struct k_message msg;
        unsigned char *ip;
 
        vcc = entry->shortcut;
        ip = (unsigned char *)&entry->ctrl_info.in_dst_ip;
        dprintk("mpoa: mpoa_caches.c: removing an ingress entry, ip = %u.%u.%u.%u\n",ip[0], ip[1], ip[2], ip[3]);
 
        if (entry->prev != NULL)
                entry->prev->next = entry->next;
        else
                client->in_cache = entry->next;
        if (entry->next != NULL)
                entry->next->prev = entry->prev;
        client->in_ops->put(entry);
        if(client->in_cache == NULL && client->eg_cache == NULL){
                msg.type = STOP_KEEP_ALIVE_SM;
                msg_to_mpoad(&msg,client);
        }
 
        /* Check if the egress side still uses this VCC */
        if (vcc != NULL) {
                eg_cache_entry *eg_entry = client->eg_ops->get_by_vcc(vcc, client);
                if (eg_entry != NULL) {
                        client->eg_ops->put(eg_entry);
                        return;
                }
                vcc_release_async(vcc, -EPIPE);
        }
 
        return;
}
 
 
/* Call this every MPC-p2 seconds... Not exactly correct solution,
   but an easy one... */
static void clear_count_and_expired(struct mpoa_client *client)
{
        unsigned char *ip;
        in_cache_entry *entry, *next_entry;
        struct timeval now;
 
        do_gettimeofday(&now);
 
        write_lock_bh(&client->ingress_lock);
        entry = client->in_cache;
        while(entry != NULL){
                entry->count=0;
                next_entry = entry->next;
                if((now.tv_sec - entry->tv.tv_sec)
                   > entry->ctrl_info.holding_time){
                        ip = (unsigned char*)&entry->ctrl_info.in_dst_ip;
                        dprintk("mpoa: mpoa_caches.c: holding time expired, ip = %u.%u.%u.%u\n", NIPQUAD(ip));
                        client->in_ops->remove_entry(entry, client);
                }
                entry = next_entry;
        }
        write_unlock_bh(&client->ingress_lock);
 
        return;
}
 
/* Call this every MPC-p4 seconds. */
static void check_resolving_entries(struct mpoa_client *client)
{
 
        struct atm_mpoa_qos *qos;
        in_cache_entry *entry;
        struct timeval now;
        struct k_message msg;
 
        do_gettimeofday( &now );
 
        read_lock_bh(&client->ingress_lock);
        entry = client->in_cache;
        while( entry != NULL ){
                if(entry->entry_state == INGRESS_RESOLVING){
                        if(now.tv_sec - entry->hold_down.tv_sec < client->parameters.mpc_p6){
                                entry = entry->next;                      /* Entry in hold down */
                                continue;
                        }
                        if( (now.tv_sec - entry->reply_wait.tv_sec) >
                            entry->retry_time ){
                                entry->retry_time = MPC_C1*( entry->retry_time );
                                if(entry->retry_time > client->parameters.mpc_p5){
                                        /* Retry time maximum exceeded, put entry in hold down. */
                                        do_gettimeofday(&(entry->hold_down));
                                        entry->retry_time = client->parameters.mpc_p4;
                                        entry = entry->next;
                                        continue;
                                }
                                /* Ask daemon to send a resolution request. */
                                memset(&(entry->hold_down),0,sizeof(struct timeval));
                                msg.type = SND_MPOA_RES_RTRY;
                                memcpy(msg.MPS_ctrl, client->mps_ctrl_addr, ATM_ESA_LEN);
                                msg.content.in_info = entry->ctrl_info;
                                qos = atm_mpoa_search_qos(entry->ctrl_info.in_dst_ip);
                                if (qos != NULL) msg.qos = qos->qos;
                                msg_to_mpoad(&msg, client);
                                do_gettimeofday(&(entry->reply_wait));
                        }
                }
                entry = entry->next;
        }
        read_unlock_bh(&client->ingress_lock);
}
 
/* Call this every MPC-p5 seconds. */
static void refresh_entries(struct mpoa_client *client)
{
        struct timeval now;
        struct in_cache_entry *entry = client->in_cache;
 
        ddprintk("mpoa: mpoa_caches.c: refresh_entries\n");
        do_gettimeofday(&now);
 
        read_lock_bh(&client->ingress_lock);
        while( entry != NULL ){
                if( entry->entry_state == INGRESS_RESOLVED ){
                        if(!(entry->refresh_time))
                                entry->refresh_time = (2*(entry->ctrl_info.holding_time))/3;
                        if( (now.tv_sec - entry->reply_wait.tv_sec) > entry->refresh_time ){
                                dprintk("mpoa: mpoa_caches.c: refreshing an entry.\n");
                                entry->entry_state = INGRESS_REFRESHING;
 
                        }
                }
                entry = entry->next;
        }
        read_unlock_bh(&client->ingress_lock);
}
 
static void in_destroy_cache(struct mpoa_client *mpc)
{
        write_lock_irq(&mpc->ingress_lock);
        while(mpc->in_cache != NULL)
                mpc->in_ops->remove_entry(mpc->in_cache, mpc);
        write_unlock_irq(&mpc->ingress_lock);
 
        return;
}
 
static eg_cache_entry *eg_cache_get_by_cache_id(uint32_t cache_id, struct mpoa_client *mpc)
{
        eg_cache_entry *entry;
 
        read_lock_irq(&mpc->egress_lock);
        entry = mpc->eg_cache;
        while(entry != NULL){
                if(entry->ctrl_info.cache_id == cache_id){
                        atomic_inc(&entry->use);
                        read_unlock_irq(&mpc->egress_lock);
                        return entry;
                }
                entry = entry->next;
        }
        read_unlock_irq(&mpc->egress_lock);
 
        return NULL;
}
 
/* This can be called from any context since it saves CPU flags */
static eg_cache_entry *eg_cache_get_by_tag(uint32_t tag, struct mpoa_client *mpc)
{
        unsigned long flags;
        eg_cache_entry *entry;
 
        read_lock_irqsave(&mpc->egress_lock, flags);
        entry = mpc->eg_cache;
        while (entry != NULL){
                if (entry->ctrl_info.tag == tag) {
                        atomic_inc(&entry->use);
                        read_unlock_irqrestore(&mpc->egress_lock, flags);
                        return entry;
                }
                entry = entry->next;
        }
        read_unlock_irqrestore(&mpc->egress_lock, flags);
 
        return NULL;
}
 
/* This can be called from any context since it saves CPU flags */
static eg_cache_entry *eg_cache_get_by_vcc(struct atm_vcc *vcc, struct mpoa_client *mpc)
{
        unsigned long flags;
        eg_cache_entry *entry;
 
        read_lock_irqsave(&mpc->egress_lock, flags);
        entry = mpc->eg_cache;
        while (entry != NULL){
                if (entry->shortcut == vcc) {
                        atomic_inc(&entry->use);
                        read_unlock_irqrestore(&mpc->egress_lock, flags);
                        return entry;
                }
                entry = entry->next;
        }
        read_unlock_irqrestore(&mpc->egress_lock, flags);
 
        return NULL;
}
 
static eg_cache_entry *eg_cache_get_by_src_ip(uint32_t ipaddr, struct mpoa_client *mpc)
{
        eg_cache_entry *entry;
 
        read_lock_irq(&mpc->egress_lock);
        entry = mpc->eg_cache;
        while(entry != NULL){
                if(entry->latest_ip_addr == ipaddr) {
                        atomic_inc(&entry->use);
                        read_unlock_irq(&mpc->egress_lock);
                        return entry;
                }
                entry = entry->next;
        }
        read_unlock_irq(&mpc->egress_lock);
 
        return NULL;
}
 
static void eg_cache_put(eg_cache_entry *entry)
{
        if (atomic_dec_and_test(&entry->use)) {
                memset(entry, 0, sizeof(eg_cache_entry));
                kfree(entry);
        }
 
        return;
}
 
/*
 * This should be called with write lock on
 */
static void eg_cache_remove_entry(eg_cache_entry *entry,
                                  struct mpoa_client *client)
{
        struct atm_vcc *vcc;
        struct k_message msg;
 
        vcc = entry->shortcut;
        dprintk("mpoa: mpoa_caches.c: removing an egress entry.\n");
        if (entry->prev != NULL)
                entry->prev->next = entry->next;
        else
                client->eg_cache = entry->next;
        if (entry->next != NULL)
                entry->next->prev = entry->prev;
        client->eg_ops->put(entry);
        if(client->in_cache == NULL && client->eg_cache == NULL){
                msg.type = STOP_KEEP_ALIVE_SM;
                msg_to_mpoad(&msg,client);
        }
 
        /* Check if the ingress side still uses this VCC */
        if (vcc != NULL) {
                in_cache_entry *in_entry = client->in_ops->get_by_vcc(vcc, client);
                if (in_entry != NULL) {
                        client->in_ops->put(in_entry);
                        return;
                }
                vcc_release_async(vcc, -EPIPE);
        }
 
        return;
}
 
static eg_cache_entry *eg_cache_add_entry(struct k_message *msg, struct mpoa_client *client)
{
        unsigned char *ip;
        eg_cache_entry *entry = kmalloc(sizeof(eg_cache_entry), GFP_KERNEL);
 
        if (entry == NULL) {
                printk("mpoa: mpoa_caches.c: new_eg_cache_entry: out of memory\n");
                return NULL;
        }
 
        ip = (unsigned char *)&msg->content.eg_info.eg_dst_ip;
        dprintk("mpoa: mpoa_caches.c: adding an egress entry, ip = %u.%u.%u.%u, this should be our IP\n", NIPQUAD(ip));
        memset(entry, 0, sizeof(eg_cache_entry));
 
        atomic_set(&entry->use, 1);
        dprintk("mpoa: mpoa_caches.c: new_eg_cache_entry: about to lock\n");
        write_lock_irq(&client->egress_lock);
        entry->next = client->eg_cache;
        entry->prev = NULL;
        if (client->eg_cache != NULL)
                client->eg_cache->prev = entry;
        client->eg_cache = entry;
 
        memcpy(entry->MPS_ctrl_ATM_addr, client->mps_ctrl_addr, ATM_ESA_LEN);
        entry->ctrl_info = msg->content.eg_info;
        do_gettimeofday(&(entry->tv));
        entry->entry_state = EGRESS_RESOLVED;
        dprintk("mpoa: mpoa_caches.c: new_eg_cache_entry cache_id %lu\n", ntohl(entry->ctrl_info.cache_id));
        ip = (unsigned char *)&entry->ctrl_info.mps_ip;
        dprintk("mpoa: mpoa_caches.c: mps_ip = %u.%u.%u.%u\n", NIPQUAD(ip));
        atomic_inc(&entry->use);
 
        write_unlock_irq(&client->egress_lock);
        dprintk("mpoa: mpoa_caches.c: new_eg_cache_entry: unlocked\n");
 
        return entry;
}
 
static void update_eg_cache_entry(eg_cache_entry * entry, uint16_t holding_time)
{
        do_gettimeofday(&(entry->tv));
        entry->entry_state = EGRESS_RESOLVED;
        entry->ctrl_info.holding_time = holding_time;
 
        return;
}
 
static void clear_expired(struct mpoa_client *client)
{
        eg_cache_entry *entry, *next_entry;
        struct timeval now;
        struct k_message msg;
 
        do_gettimeofday(&now);
 
        write_lock_irq(&client->egress_lock);
        entry = client->eg_cache;
        while(entry != NULL){
                next_entry = entry->next;
                if((now.tv_sec - entry->tv.tv_sec)
                   > entry->ctrl_info.holding_time){
                        msg.type = SND_EGRESS_PURGE;
                        msg.content.eg_info = entry->ctrl_info;
                        dprintk("mpoa: mpoa_caches.c: egress_cache: holding time expired, cache_id = %lu.\n",ntohl(entry->ctrl_info.cache_id));
                        msg_to_mpoad(&msg, client);
                        client->eg_ops->remove_entry(entry, client);
                }
                entry = next_entry;
        }
        write_unlock_irq(&client->egress_lock);
 
        return;
}
 
static void eg_destroy_cache(struct mpoa_client *mpc)
{
        write_lock_irq(&mpc->egress_lock);
        while(mpc->eg_cache != NULL)
                mpc->eg_ops->remove_entry(mpc->eg_cache, mpc);
        write_unlock_irq(&mpc->egress_lock);
 
        return;
}
 
 
 
static struct in_cache_ops ingress_ops = {
        in_cache_add_entry,               /* add_entry       */
        in_cache_get,                     /* get             */
        in_cache_get_with_mask,           /* get_with_mask   */
        in_cache_get_by_vcc,              /* get_by_vcc      */
        in_cache_put,                     /* put             */
        in_cache_remove_entry,            /* remove_entry    */
        cache_hit,                        /* cache_hit       */
        clear_count_and_expired,          /* clear_count     */
        check_resolving_entries,          /* check_resolving */
        refresh_entries,                  /* refresh         */
        in_destroy_cache                  /* destroy_cache   */
};
 
static struct eg_cache_ops egress_ops = {
        eg_cache_add_entry,               /* add_entry        */
        eg_cache_get_by_cache_id,         /* get_by_cache_id  */
        eg_cache_get_by_tag,              /* get_by_tag       */
        eg_cache_get_by_vcc,              /* get_by_vcc       */
        eg_cache_get_by_src_ip,           /* get_by_src_ip    */
        eg_cache_put,                     /* put              */
        eg_cache_remove_entry,            /* remove_entry     */
        update_eg_cache_entry,            /* update           */
        clear_expired,                    /* clear_expired    */
        eg_destroy_cache                  /* destroy_cache    */
};
 
 
void atm_mpoa_init_cache(struct mpoa_client *mpc)
{
        mpc->in_ops = &ingress_ops;
        mpc->eg_ops = &egress_ops;
 
        return;
}

Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [net/] [atm/] [mpoa_caches.c] - Blame information for rev 1765

Line No.	Rev	Author	Line
1	1275	phoenix	`#include <linux/types.h>`
2			`#include <linux/atmmpc.h>`
3			`#include <linux/time.h>`
4
5			`#include "mpoa_caches.h"`
6			`#include "mpc.h"`
7
8			`/*`
9			`* mpoa_caches.c: Implementation of ingress and egress cache`
10			`* handling functions`
11			`*/`
12
13			`#if 0`
14			`#define dprintk printk /* debug */`
15			`#else`
16			`#define dprintk(format,args...)`
17			`#endif`
18
19			`#if 0`
20			`#define ddprintk printk /* more debug */`
21			`#else`
22			`#define ddprintk(format,args...)`
23			`#endif`
24
25			`static in_cache_entry *in_cache_get(uint32_t dst_ip,`
26			`struct mpoa_client *client)`
27			`{`
28			`in_cache_entry *entry;`
29
30			`read_lock_bh(&client->ingress_lock);`
31			`entry = client->in_cache;`
32			`while(entry != NULL){`
33			`if( entry->ctrl_info.in_dst_ip == dst_ip ){`
34			`atomic_inc(&entry->use);`
35			`read_unlock_bh(&client->ingress_lock);`
36			`return entry;`
37			`}`
38			`entry = entry->next;`
39			`}`
40			`read_unlock_bh(&client->ingress_lock);`
41
42			`return NULL;`
43			`}`
44
45			`static in_cache_entry *in_cache_get_with_mask(uint32_t dst_ip,`
46			`struct mpoa_client *client,`
47			`uint32_t mask)`
48			`{`
49			`in_cache_entry *entry;`
50
51			`read_lock_bh(&client->ingress_lock);`
52			`entry = client->in_cache;`
53			`while(entry != NULL){`
54			`if((entry->ctrl_info.in_dst_ip & mask) == (dst_ip & mask )){`
55			`atomic_inc(&entry->use);`
56			`read_unlock_bh(&client->ingress_lock);`
57			`return entry;`
58			`}`
59			`entry = entry->next;`
60			`}`
61			`read_unlock_bh(&client->ingress_lock);`
62
63			`return NULL;`
64
65			`}`
66
67			`static in_cache_entry in_cache_get_by_vcc(struct atm_vcc vcc,`
68			`struct mpoa_client *client )`
69			`{`
70			`in_cache_entry *entry;`
71
72			`read_lock_bh(&client->ingress_lock);`
73			`entry = client->in_cache;`
74			`while(entry != NULL){`
75			`if(entry->shortcut == vcc) {`
76			`atomic_inc(&entry->use);`
77			`read_unlock_bh(&client->ingress_lock);`
78			`return entry;`
79			`}`
80			`entry = entry->next;`
81			`}`
82			`read_unlock_bh(&client->ingress_lock);`
83
84			`return NULL;`
85			`}`
86
87			`static in_cache_entry *in_cache_add_entry(uint32_t dst_ip,`
88			`struct mpoa_client *client)`
89			`{`
90			`unsigned char ip __attribute__ ((unused)) = (unsigned char )&dst_ip;`
91			`in_cache_entry* entry = kmalloc(sizeof(in_cache_entry), GFP_KERNEL);`
92
93			`if (entry == NULL) {`
94			`printk("mpoa: mpoa_caches.c: new_in_cache_entry: out of memory\n");`
95			`return NULL;`
96			`}`
97
98			`dprintk("mpoa: mpoa_caches.c: adding an ingress entry, ip = %u.%u.%u.%u\n", ip[0], ip[1], ip[2], ip[3]);`
99			`memset(entry,0,sizeof(in_cache_entry));`
100
101			`atomic_set(&entry->use, 1);`
102			`dprintk("mpoa: mpoa_caches.c: new_in_cache_entry: about to lock\n");`
103			`write_lock_bh(&client->ingress_lock);`
104			`entry->next = client->in_cache;`
105			`entry->prev = NULL;`
106			`if (client->in_cache != NULL)`
107			`client->in_cache->prev = entry;`
108			`client->in_cache = entry;`
109
110			`memcpy(entry->MPS_ctrl_ATM_addr, client->mps_ctrl_addr, ATM_ESA_LEN);`
111			`entry->ctrl_info.in_dst_ip = dst_ip;`
112			`do_gettimeofday(&(entry->tv));`
113			`entry->retry_time = client->parameters.mpc_p4;`
114			`entry->count = 1;`
115			`entry->entry_state = INGRESS_INVALID;`
116			`entry->ctrl_info.holding_time = HOLDING_TIME_DEFAULT;`
117			`atomic_inc(&entry->use);`
118
119			`write_unlock_bh(&client->ingress_lock);`
120			`dprintk("mpoa: mpoa_caches.c: new_in_cache_entry: unlocked\n");`
121
122			`return entry;`
123			`}`
124
125			`static int cache_hit(in_cache_entry entry, struct mpoa_client mpc)`
126			`{`
127			`struct atm_mpoa_qos *qos;`
128			`struct k_message msg;`
129
130			`entry->count++;`
131			`if(entry->entry_state == INGRESS_RESOLVED && entry->shortcut != NULL)`
132			`return OPEN;`
133
134			`if(entry->entry_state == INGRESS_REFRESHING){`
135			`if(entry->count > mpc->parameters.mpc_p1){`
136			`msg.type = SND_MPOA_RES_RQST;`
137			`msg.content.in_info = entry->ctrl_info;`
138			`memcpy(msg.MPS_ctrl, mpc->mps_ctrl_addr, ATM_ESA_LEN);`
139			`qos = atm_mpoa_search_qos(entry->ctrl_info.in_dst_ip);`
140			`if (qos != NULL) msg.qos = qos->qos;`
141			`msg_to_mpoad(&msg, mpc);`
142			`do_gettimeofday(&(entry->reply_wait));`
143			`entry->entry_state = INGRESS_RESOLVING;`
144			`}`
145			`if(entry->shortcut != NULL)`
146			`return OPEN;`
147			`return CLOSED;`
148			`}`
149
150			`if(entry->entry_state == INGRESS_RESOLVING && entry->shortcut != NULL)`
151			`return OPEN;`
152
153			`if( entry->count > mpc->parameters.mpc_p1 &&`
154			`entry->entry_state == INGRESS_INVALID){`
155			`unsigned char *ip __attribute__ ((unused)) =`
156			`(unsigned char *)&entry->ctrl_info.in_dst_ip;`
157
158			`dprintk("mpoa: (%s) mpoa_caches.c: threshold exceeded for ip %u.%u.%u.%u, sending MPOA res req\n", mpc->dev->name, ip[0], ip[1], ip[2], ip[3]);`
159			`entry->entry_state = INGRESS_RESOLVING;`
160			`msg.type = SND_MPOA_RES_RQST;`
161			`memcpy(msg.MPS_ctrl, mpc->mps_ctrl_addr, ATM_ESA_LEN );`
162			`msg.content.in_info = entry->ctrl_info;`
163			`qos = atm_mpoa_search_qos(entry->ctrl_info.in_dst_ip);`
164			`if (qos != NULL) msg.qos = qos->qos;`
165			`msg_to_mpoad( &msg, mpc);`
166			`do_gettimeofday(&(entry->reply_wait));`
167			`}`
168
169			`return CLOSED;`
170			`}`
171
172			`static void in_cache_put(in_cache_entry *entry)`
173			`{`
174			`if (atomic_dec_and_test(&entry->use)) {`
175			`memset(entry, 0, sizeof(in_cache_entry));`
176			`kfree(entry);`
177			`}`
178
179			`return;`
180			`}`
181
182			`/*`
183			`* This should be called with write lock on`
184			`*/`
185			`static void in_cache_remove_entry(in_cache_entry *entry,`
186			`struct mpoa_client *client)`
187			`{`
188			`struct atm_vcc *vcc;`
189			`struct k_message msg;`
190			`unsigned char *ip;`
191
192			`vcc = entry->shortcut;`
193			`ip = (unsigned char *)&entry->ctrl_info.in_dst_ip;`
194			`dprintk("mpoa: mpoa_caches.c: removing an ingress entry, ip = %u.%u.%u.%u\n",ip[0], ip[1], ip[2], ip[3]);`
195
196			`if (entry->prev != NULL)`
197			`entry->prev->next = entry->next;`
198			`else`
199			`client->in_cache = entry->next;`
200			`if (entry->next != NULL)`
201			`entry->next->prev = entry->prev;`
202			`client->in_ops->put(entry);`
203			`if(client->in_cache == NULL && client->eg_cache == NULL){`
204			`msg.type = STOP_KEEP_ALIVE_SM;`
205			`msg_to_mpoad(&msg,client);`
206			`}`
207
208			`/* Check if the egress side still uses this VCC */`
209			`if (vcc != NULL) {`
210			`eg_cache_entry *eg_entry = client->eg_ops->get_by_vcc(vcc, client);`
211			`if (eg_entry != NULL) {`
212			`client->eg_ops->put(eg_entry);`
213			`return;`
214			`}`
215			`vcc_release_async(vcc, -EPIPE);`
216			`}`
217
218			`return;`
219			`}`
220
221
222			`/* Call this every MPC-p2 seconds... Not exactly correct solution,`
223			`but an easy one... */`
224			`static void clear_count_and_expired(struct mpoa_client *client)`
225			`{`
226			`unsigned char *ip;`
227			`in_cache_entry entry, next_entry;`
228			`struct timeval now;`
229
230			`do_gettimeofday(&now);`
231
232			`write_lock_bh(&client->ingress_lock);`
233			`entry = client->in_cache;`
234			`while(entry != NULL){`
235			`entry->count=0;`
236			`next_entry = entry->next;`
237			`if((now.tv_sec - entry->tv.tv_sec)`
238			`> entry->ctrl_info.holding_time){`
239			`ip = (unsigned char*)&entry->ctrl_info.in_dst_ip;`
240			`dprintk("mpoa: mpoa_caches.c: holding time expired, ip = %u.%u.%u.%u\n", NIPQUAD(ip));`
241			`client->in_ops->remove_entry(entry, client);`
242			`}`
243			`entry = next_entry;`
244			`}`
245			`write_unlock_bh(&client->ingress_lock);`
246
247			`return;`
248			`}`
249
250			`/* Call this every MPC-p4 seconds. */`
251			`static void check_resolving_entries(struct mpoa_client *client)`
252			`{`
253
254			`struct atm_mpoa_qos *qos;`
255			`in_cache_entry *entry;`
256			`struct timeval now;`
257			`struct k_message msg;`
258
259			`do_gettimeofday( &now );`
260
261			`read_lock_bh(&client->ingress_lock);`
262			`entry = client->in_cache;`
263			`while( entry != NULL ){`
264			`if(entry->entry_state == INGRESS_RESOLVING){`
265			`if(now.tv_sec - entry->hold_down.tv_sec < client->parameters.mpc_p6){`
266			`entry = entry->next; /* Entry in hold down */`
267			`continue;`
268			`}`
269			`if( (now.tv_sec - entry->reply_wait.tv_sec) >`
270			`entry->retry_time ){`
271			`entry->retry_time = MPC_C1*( entry->retry_time );`
272			`if(entry->retry_time > client->parameters.mpc_p5){`
273			`/* Retry time maximum exceeded, put entry in hold down. */`
274			`do_gettimeofday(&(entry->hold_down));`
275			`entry->retry_time = client->parameters.mpc_p4;`
276			`entry = entry->next;`
277			`continue;`
278			`}`
279			`/* Ask daemon to send a resolution request. */`
280			`memset(&(entry->hold_down),0,sizeof(struct timeval));`
281			`msg.type = SND_MPOA_RES_RTRY;`
282			`memcpy(msg.MPS_ctrl, client->mps_ctrl_addr, ATM_ESA_LEN);`
283			`msg.content.in_info = entry->ctrl_info;`
284			`qos = atm_mpoa_search_qos(entry->ctrl_info.in_dst_ip);`
285			`if (qos != NULL) msg.qos = qos->qos;`
286			`msg_to_mpoad(&msg, client);`
287			`do_gettimeofday(&(entry->reply_wait));`
288			`}`
289			`}`
290			`entry = entry->next;`
291			`}`
292			`read_unlock_bh(&client->ingress_lock);`
293			`}`
294
295			`/* Call this every MPC-p5 seconds. */`
296			`static void refresh_entries(struct mpoa_client *client)`
297			`{`
298			`struct timeval now;`
299			`struct in_cache_entry *entry = client->in_cache;`
300
301			`ddprintk("mpoa: mpoa_caches.c: refresh_entries\n");`
302			`do_gettimeofday(&now);`
303
304			`read_lock_bh(&client->ingress_lock);`
305			`while( entry != NULL ){`
306			`if( entry->entry_state == INGRESS_RESOLVED ){`
307			`if(!(entry->refresh_time))`
308			`entry->refresh_time = (2*(entry->ctrl_info.holding_time))/3;`
309			`if( (now.tv_sec - entry->reply_wait.tv_sec) > entry->refresh_time ){`
310			`dprintk("mpoa: mpoa_caches.c: refreshing an entry.\n");`
311			`entry->entry_state = INGRESS_REFRESHING;`
312
313			`}`
314			`}`
315			`entry = entry->next;`
316			`}`
317			`read_unlock_bh(&client->ingress_lock);`
318			`}`
319
320			`static void in_destroy_cache(struct mpoa_client *mpc)`
321			`{`
322			`write_lock_irq(&mpc->ingress_lock);`
323			`while(mpc->in_cache != NULL)`
324			`mpc->in_ops->remove_entry(mpc->in_cache, mpc);`
325			`write_unlock_irq(&mpc->ingress_lock);`
326
327			`return;`
328			`}`
329
330			`static eg_cache_entry eg_cache_get_by_cache_id(uint32_t cache_id, struct mpoa_client mpc)`
331			`{`
332			`eg_cache_entry *entry;`
333
334			`read_lock_irq(&mpc->egress_lock);`
335			`entry = mpc->eg_cache;`
336			`while(entry != NULL){`
337			`if(entry->ctrl_info.cache_id == cache_id){`
338			`atomic_inc(&entry->use);`
339			`read_unlock_irq(&mpc->egress_lock);`
340			`return entry;`
341			`}`
342			`entry = entry->next;`
343			`}`
344			`read_unlock_irq(&mpc->egress_lock);`
345
346			`return NULL;`
347			`}`
348
349			`/* This can be called from any context since it saves CPU flags */`
350			`static eg_cache_entry eg_cache_get_by_tag(uint32_t tag, struct mpoa_client mpc)`
351			`{`
352			`unsigned long flags;`
353			`eg_cache_entry *entry;`
354
355			`read_lock_irqsave(&mpc->egress_lock, flags);`
356			`entry = mpc->eg_cache;`
357			`while (entry != NULL){`
358			`if (entry->ctrl_info.tag == tag) {`
359			`atomic_inc(&entry->use);`
360			`read_unlock_irqrestore(&mpc->egress_lock, flags);`
361			`return entry;`
362			`}`
363			`entry = entry->next;`
364			`}`
365			`read_unlock_irqrestore(&mpc->egress_lock, flags);`
366
367			`return NULL;`
368			`}`
369
370			`/* This can be called from any context since it saves CPU flags */`
371			`static eg_cache_entry eg_cache_get_by_vcc(struct atm_vcc vcc, struct mpoa_client *mpc)`
372			`{`
373			`unsigned long flags;`
374			`eg_cache_entry *entry;`
375
376			`read_lock_irqsave(&mpc->egress_lock, flags);`
377			`entry = mpc->eg_cache;`
378			`while (entry != NULL){`
379			`if (entry->shortcut == vcc) {`
380			`atomic_inc(&entry->use);`
381			`read_unlock_irqrestore(&mpc->egress_lock, flags);`
382			`return entry;`
383			`}`
384			`entry = entry->next;`
385			`}`
386			`read_unlock_irqrestore(&mpc->egress_lock, flags);`
387
388			`return NULL;`
389			`}`
390
391			`static eg_cache_entry eg_cache_get_by_src_ip(uint32_t ipaddr, struct mpoa_client mpc)`
392			`{`
393			`eg_cache_entry *entry;`
394
395			`read_lock_irq(&mpc->egress_lock);`
396			`entry = mpc->eg_cache;`
397			`while(entry != NULL){`
398			`if(entry->latest_ip_addr == ipaddr) {`
399			`atomic_inc(&entry->use);`
400			`read_unlock_irq(&mpc->egress_lock);`
401			`return entry;`
402			`}`
403			`entry = entry->next;`
404			`}`
405			`read_unlock_irq(&mpc->egress_lock);`
406
407			`return NULL;`
408			`}`
409
410			`static void eg_cache_put(eg_cache_entry *entry)`
411			`{`
412			`if (atomic_dec_and_test(&entry->use)) {`
413			`memset(entry, 0, sizeof(eg_cache_entry));`
414			`kfree(entry);`
415			`}`
416
417			`return;`
418			`}`
419
420			`/*`
421			`* This should be called with write lock on`
422			`*/`
423			`static void eg_cache_remove_entry(eg_cache_entry *entry,`
424			`struct mpoa_client *client)`
425			`{`
426			`struct atm_vcc *vcc;`
427			`struct k_message msg;`
428
429			`vcc = entry->shortcut;`
430			`dprintk("mpoa: mpoa_caches.c: removing an egress entry.\n");`
431			`if (entry->prev != NULL)`
432			`entry->prev->next = entry->next;`
433			`else`
434			`client->eg_cache = entry->next;`
435			`if (entry->next != NULL)`
436			`entry->next->prev = entry->prev;`
437			`client->eg_ops->put(entry);`
438			`if(client->in_cache == NULL && client->eg_cache == NULL){`
439			`msg.type = STOP_KEEP_ALIVE_SM;`
440			`msg_to_mpoad(&msg,client);`
441			`}`
442
443			`/* Check if the ingress side still uses this VCC */`
444			`if (vcc != NULL) {`
445			`in_cache_entry *in_entry = client->in_ops->get_by_vcc(vcc, client);`
446			`if (in_entry != NULL) {`
447			`client->in_ops->put(in_entry);`
448			`return;`
449			`}`
450			`vcc_release_async(vcc, -EPIPE);`
451			`}`
452
453			`return;`
454			`}`
455
456			`static eg_cache_entry eg_cache_add_entry(struct k_message msg, struct mpoa_client *client)`
457			`{`
458			`unsigned char *ip;`
459			`eg_cache_entry *entry = kmalloc(sizeof(eg_cache_entry), GFP_KERNEL);`
460
461			`if (entry == NULL) {`
462			`printk("mpoa: mpoa_caches.c: new_eg_cache_entry: out of memory\n");`
463			`return NULL;`
464			`}`
465
466			`ip = (unsigned char *)&msg->content.eg_info.eg_dst_ip;`
467			`dprintk("mpoa: mpoa_caches.c: adding an egress entry, ip = %u.%u.%u.%u, this should be our IP\n", NIPQUAD(ip));`
468			`memset(entry, 0, sizeof(eg_cache_entry));`
469
470			`atomic_set(&entry->use, 1);`
471			`dprintk("mpoa: mpoa_caches.c: new_eg_cache_entry: about to lock\n");`
472			`write_lock_irq(&client->egress_lock);`
473			`entry->next = client->eg_cache;`
474			`entry->prev = NULL;`
475			`if (client->eg_cache != NULL)`
476			`client->eg_cache->prev = entry;`
477			`client->eg_cache = entry;`
478
479			`memcpy(entry->MPS_ctrl_ATM_addr, client->mps_ctrl_addr, ATM_ESA_LEN);`
480			`entry->ctrl_info = msg->content.eg_info;`
481			`do_gettimeofday(&(entry->tv));`
482			`entry->entry_state = EGRESS_RESOLVED;`
483			`dprintk("mpoa: mpoa_caches.c: new_eg_cache_entry cache_id %lu\n", ntohl(entry->ctrl_info.cache_id));`
484			`ip = (unsigned char *)&entry->ctrl_info.mps_ip;`
485			`dprintk("mpoa: mpoa_caches.c: mps_ip = %u.%u.%u.%u\n", NIPQUAD(ip));`
486			`atomic_inc(&entry->use);`
487
488			`write_unlock_irq(&client->egress_lock);`
489			`dprintk("mpoa: mpoa_caches.c: new_eg_cache_entry: unlocked\n");`
490
491			`return entry;`
492			`}`
493
494			`static void update_eg_cache_entry(eg_cache_entry * entry, uint16_t holding_time)`
495			`{`
496			`do_gettimeofday(&(entry->tv));`
497			`entry->entry_state = EGRESS_RESOLVED;`
498			`entry->ctrl_info.holding_time = holding_time;`
499
500			`return;`
501			`}`
502
503			`static void clear_expired(struct mpoa_client *client)`
504			`{`
505			`eg_cache_entry entry, next_entry;`
506			`struct timeval now;`
507			`struct k_message msg;`
508
509			`do_gettimeofday(&now);`
510
511			`write_lock_irq(&client->egress_lock);`
512			`entry = client->eg_cache;`
513			`while(entry != NULL){`
514			`next_entry = entry->next;`
515			`if((now.tv_sec - entry->tv.tv_sec)`
516			`> entry->ctrl_info.holding_time){`
517			`msg.type = SND_EGRESS_PURGE;`
518			`msg.content.eg_info = entry->ctrl_info;`
519			`dprintk("mpoa: mpoa_caches.c: egress_cache: holding time expired, cache_id = %lu.\n",ntohl(entry->ctrl_info.cache_id));`
520			`msg_to_mpoad(&msg, client);`
521			`client->eg_ops->remove_entry(entry, client);`
522			`}`
523			`entry = next_entry;`
524			`}`
525			`write_unlock_irq(&client->egress_lock);`
526
527			`return;`
528			`}`
529
530			`static void eg_destroy_cache(struct mpoa_client *mpc)`
531			`{`
532			`write_lock_irq(&mpc->egress_lock);`
533			`while(mpc->eg_cache != NULL)`
534			`mpc->eg_ops->remove_entry(mpc->eg_cache, mpc);`
535			`write_unlock_irq(&mpc->egress_lock);`
536
537			`return;`
538			`}`
539
540
541
542			`static struct in_cache_ops ingress_ops = {`
543			`in_cache_add_entry, /* add_entry */`
544			`in_cache_get, /* get */`
545			`in_cache_get_with_mask, /* get_with_mask */`
546			`in_cache_get_by_vcc, /* get_by_vcc */`
547			`in_cache_put, /* put */`
548			`in_cache_remove_entry, /* remove_entry */`
549			`cache_hit, /* cache_hit */`
550			`clear_count_and_expired, /* clear_count */`
551			`check_resolving_entries, /* check_resolving */`
552			`refresh_entries, /* refresh */`
553			`in_destroy_cache /* destroy_cache */`
554			`};`
555
556			`static struct eg_cache_ops egress_ops = {`
557			`eg_cache_add_entry, /* add_entry */`
558			`eg_cache_get_by_cache_id, /* get_by_cache_id */`
559			`eg_cache_get_by_tag, /* get_by_tag */`
560			`eg_cache_get_by_vcc, /* get_by_vcc */`
561			`eg_cache_get_by_src_ip, /* get_by_src_ip */`
562			`eg_cache_put, /* put */`
563			`eg_cache_remove_entry, /* remove_entry */`
564			`update_eg_cache_entry, /* update */`
565			`clear_expired, /* clear_expired */`
566			`eg_destroy_cache /* destroy_cache */`
567			`};`
568
569
570			`void atm_mpoa_init_cache(struct mpoa_client *mpc)`
571			`{`
572			`mpc->in_ops = &ingress_ops;`
573			`mpc->eg_ops = &egress_ops;`
574
575			`return;`
576			`}`