[linux.git] / net / atm / mpoa_caches.c

#include <linux/types.h>
#include <linux/atmmpc.h>
#include <linux/slab.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(format, args...)					\
	printk(KERN_DEBUG "mpoa:%s: " format, __FILE__, ##args)  /* debug */
#else
#define dprintk(format, args...)					\
	do { if (0)							\
		printk(KERN_DEBUG "mpoa:%s: " format, __FILE__, ##args);\
	} while (0)
#endif

#if 0
#define ddprintk(format, args...)					\
	printk(KERN_DEBUG "mpoa:%s: " format, __FILE__, ##args)  /* debug */
#else
#define ddprintk(format, args...)					\
	do { if (0)							\
		printk(KERN_DEBUG "mpoa:%s: " format, __FILE__, ##args);\
	} while (0)
#endif

static in_cache_entry *in_cache_get(__be32 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(__be32 dst_ip,
					      struct mpoa_client *client,
					      __be32 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(__be32 dst_ip,
					  struct mpoa_client *client)
{
	in_cache_entry *entry = kzalloc(sizeof(in_cache_entry), GFP_KERNEL);

	if (entry == NULL) {
		pr_info("mpoa: mpoa_caches.c: new_in_cache_entry: out of memory\n");
		return NULL;
	}

	dprintk("adding an ingress entry, ip = %pI4\n", &dst_ip);

	atomic_set(&entry->use, 1);
	dprintk("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("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) {
		dprintk("(%s) threshold exceeded for ip %pI4, sending MPOA res req\n",
			mpc->dev->name, &entry->ctrl_info.in_dst_ip);
		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);
	}
}

/*
 * 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;

	vcc = entry->shortcut;
	dprintk("removing an ingress entry, ip = %pI4\n",
		&entry->ctrl_info.in_dst_ip);

	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);
	}
}

/* Call this every MPC-p2 seconds... Not exactly correct solution,
   but an easy one... */
static void clear_count_and_expired(struct mpoa_client *client)
{
	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) {
			dprintk("holding time expired, ip = %pI4\n",
				&entry->ctrl_info.in_dst_ip);
			client->in_ops->remove_entry(entry, client);
		}
		entry = next_entry;
	}
	write_unlock_bh(&client->ingress_lock);
}

/* 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);
				/*
				 * Retry time maximum exceeded,
				 * put entry in hold down.
				 */
				if (entry->retry_time > client->parameters.mpc_p5) {
					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("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("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);
}

static eg_cache_entry *eg_cache_get_by_cache_id(__be32 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(__be32 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(__be32 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);
	}
}

/*
 * 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("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);
	}
}

static eg_cache_entry *eg_cache_add_entry(struct k_message *msg,
					  struct mpoa_client *client)
{
	eg_cache_entry *entry = kzalloc(sizeof(eg_cache_entry), GFP_KERNEL);

	if (entry == NULL) {
		pr_info("out of memory\n");
		return NULL;
	}

	dprintk("adding an egress entry, ip = %pI4, this should be our IP\n",
		&msg->content.eg_info.eg_dst_ip);

	atomic_set(&entry->use, 1);
	dprintk("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("new_eg_cache_entry cache_id %u\n",
		ntohl(entry->ctrl_info.cache_id));
	dprintk("mps_ip = %pI4\n", &entry->ctrl_info.mps_ip);
	atomic_inc(&entry->use);

	write_unlock_irq(&client->egress_lock);
	dprintk("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;
}

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("egress_cache: holding time expired, cache_id = %u.\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);
}

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);
}


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