[GitHub/mt8127/android_kernel_alcatel_ttab.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);
	}

	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;

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

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

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

	return;
}

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

	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("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)
{
	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;

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

	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;
}
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	}
	185
	186	return;
	187	}
	188
	189	/*
	190	* This should be called with write lock on
	191	*/
	192	static void in_cache_remove_entry(in_cache_entry *entry,
	193	struct mpoa_client *client)
	194	{
	195	struct atm_vcc *vcc;
	196	struct k_message msg;
1da177e4 LT	197
1da177e4 LT	198	vcc = entry->shortcut;
b50c2ea7	199	dprintk("removing an ingress entry, ip = %pI4\n",
21454aaa	200	&entry->ctrl_info.in_dst_ip);
1da177e4 LT	201
	202	if (entry->prev != NULL)
	203	entry->prev->next = entry->next;
	204	else
	205	client->in_cache = entry->next;
	206	if (entry->next != NULL)
	207	entry->next->prev = entry->prev;
	208	client->in_ops->put(entry);
bee67d34	209	if (client->in_cache == NULL && client->eg_cache == NULL) {
1da177e4	210	msg.type = STOP_KEEP_ALIVE_SM;
bee67d34	211	msg_to_mpoad(&msg, client);
1da177e4 LT	212	}
	213
	214	/* Check if the egress side still uses this VCC */
	215	if (vcc != NULL) {
bee67d34 JP	216	eg_cache_entry *eg_entry = client->eg_ops->get_by_vcc(vcc,
bee67d34 JP	217	client);
1da177e4 LT	218	if (eg_entry != NULL) {
	219	client->eg_ops->put(eg_entry);
	220	return;
	221	}
	222	vcc_release_async(vcc, -EPIPE);
	223	}
	224
	225	return;
	226	}
	227
1da177e4 LT	228	/* Call this every MPC-p2 seconds... Not exactly correct solution,
	229	but an easy one... */
	230	static void clear_count_and_expired(struct mpoa_client *client)
	231	{
1da177e4 LT	232	in_cache_entry entry, next_entry;
	233	struct timeval now;
	234
	235	do_gettimeofday(&now);
	236
	237	write_lock_bh(&client->ingress_lock);
	238	entry = client->in_cache;
bee67d34 JP	239	while (entry != NULL) {
bee67d34 JP	240	entry->count = 0;
1da177e4	241	next_entry = entry->next;
bee67d34 JP	242	if ((now.tv_sec - entry->tv.tv_sec)
bee67d34 JP	243	> entry->ctrl_info.holding_time) {
b50c2ea7	244	dprintk("holding time expired, ip = %pI4\n",
21454aaa	245	&entry->ctrl_info.in_dst_ip);
1da177e4 LT	246	client->in_ops->remove_entry(entry, client);
	247	}
	248	entry = next_entry;
	249	}
	250	write_unlock_bh(&client->ingress_lock);
	251
	252	return;
	253	}
	254
	255	/* Call this every MPC-p4 seconds. */
	256	static void check_resolving_entries(struct mpoa_client *client)
	257	{
	258
	259	struct atm_mpoa_qos *qos;
	260	in_cache_entry *entry;
	261	struct timeval now;
	262	struct k_message msg;
	263
bee67d34	264	do_gettimeofday(&now);
1da177e4 LT	265
	266	read_lock_bh(&client->ingress_lock);
	267	entry = client->in_cache;
bee67d34 JP	268	while (entry != NULL) {
	269	if (entry->entry_state == INGRESS_RESOLVING) {
	270	if ((now.tv_sec - entry->hold_down.tv_sec) <
	271	client->parameters.mpc_p6) {
	272	entry = entry->next; /* Entry in hold down */
1da177e4 LT	273	continue;
1da177e4 LT	274	}
bee67d34 JP	275	if ((now.tv_sec - entry->reply_wait.tv_sec) >
	276	entry->retry_time) {
	277	entry->retry_time = MPC_C1 * (entry->retry_time);
	278	/*
	279	* Retry time maximum exceeded,
	280	* put entry in hold down.
	281	*/
	282	if (entry->retry_time > client->parameters.mpc_p5) {
1da177e4 LT	283	do_gettimeofday(&(entry->hold_down));
	284	entry->retry_time = client->parameters.mpc_p4;
	285	entry = entry->next;
	286	continue;
	287	}
	288	/* Ask daemon to send a resolution request. */
bee67d34	289	memset(&(entry->hold_down), 0, sizeof(struct timeval));
1da177e4 LT	290	msg.type = SND_MPOA_RES_RTRY;
	291	memcpy(msg.MPS_ctrl, client->mps_ctrl_addr, ATM_ESA_LEN);
	292	msg.content.in_info = entry->ctrl_info;
	293	qos = atm_mpoa_search_qos(entry->ctrl_info.in_dst_ip);
bee67d34 JP	294	if (qos != NULL)
bee67d34 JP	295	msg.qos = qos->qos;
1da177e4 LT	296	msg_to_mpoad(&msg, client);
	297	do_gettimeofday(&(entry->reply_wait));
	298	}
	299	}
	300	entry = entry->next;
	301	}
	302	read_unlock_bh(&client->ingress_lock);
	303	}
	304
	305	/* Call this every MPC-p5 seconds. */
	306	static void refresh_entries(struct mpoa_client *client)
	307	{
	308	struct timeval now;
	309	struct in_cache_entry *entry = client->in_cache;
	310
b50c2ea7	311	ddprintk("refresh_entries\n");
1da177e4 LT	312	do_gettimeofday(&now);
	313
	314	read_lock_bh(&client->ingress_lock);
bee67d34 JP	315	while (entry != NULL) {
	316	if (entry->entry_state == INGRESS_RESOLVED) {
	317	if (!(entry->refresh_time))
	318	entry->refresh_time = (2 * (entry->ctrl_info.holding_time))/3;
	319	if ((now.tv_sec - entry->reply_wait.tv_sec) >
	320	entry->refresh_time) {
b50c2ea7	321	dprintk("refreshing an entry.\n");
1da177e4 LT	322	entry->entry_state = INGRESS_REFRESHING;
	323
	324	}
	325	}
	326	entry = entry->next;
	327	}
	328	read_unlock_bh(&client->ingress_lock);
	329	}
	330
	331	static void in_destroy_cache(struct mpoa_client *mpc)
	332	{
	333	write_lock_irq(&mpc->ingress_lock);
bee67d34	334	while (mpc->in_cache != NULL)
1da177e4 LT	335	mpc->in_ops->remove_entry(mpc->in_cache, mpc);
	336	write_unlock_irq(&mpc->ingress_lock);
	337
	338	return;
	339	}
	340
bee67d34 JP	341	static eg_cache_entry *eg_cache_get_by_cache_id(__be32 cache_id,
bee67d34 JP	342	struct mpoa_client *mpc)
1da177e4 LT	343	{
	344	eg_cache_entry *entry;
	345
	346	read_lock_irq(&mpc->egress_lock);
	347	entry = mpc->eg_cache;
bee67d34 JP	348	while (entry != NULL) {
bee67d34 JP	349	if (entry->ctrl_info.cache_id == cache_id) {
1da177e4 LT	350	atomic_inc(&entry->use);
	351	read_unlock_irq(&mpc->egress_lock);
	352	return entry;
	353	}
	354	entry = entry->next;
	355	}
	356	read_unlock_irq(&mpc->egress_lock);
	357
	358	return NULL;
	359	}
	360
	361	/* This can be called from any context since it saves CPU flags */
30d492da	362	static eg_cache_entry eg_cache_get_by_tag(__be32 tag, struct mpoa_client mpc)
1da177e4 LT	363	{
	364	unsigned long flags;
	365	eg_cache_entry *entry;
	366
	367	read_lock_irqsave(&mpc->egress_lock, flags);
	368	entry = mpc->eg_cache;
bee67d34	369	while (entry != NULL) {
1da177e4 LT	370	if (entry->ctrl_info.tag == tag) {
	371	atomic_inc(&entry->use);
	372	read_unlock_irqrestore(&mpc->egress_lock, flags);
	373	return entry;
	374	}
	375	entry = entry->next;
	376	}
	377	read_unlock_irqrestore(&mpc->egress_lock, flags);
	378
	379	return NULL;
	380	}
	381
	382	/* This can be called from any context since it saves CPU flags */
bee67d34 JP	383	static eg_cache_entry eg_cache_get_by_vcc(struct atm_vcc vcc,
bee67d34 JP	384	struct mpoa_client *mpc)
1da177e4 LT	385	{
	386	unsigned long flags;
	387	eg_cache_entry *entry;
	388
	389	read_lock_irqsave(&mpc->egress_lock, flags);
	390	entry = mpc->eg_cache;
bee67d34	391	while (entry != NULL) {
1da177e4 LT	392	if (entry->shortcut == vcc) {
1da177e4 LT	393	atomic_inc(&entry->use);
f7d57453	394	read_unlock_irqrestore(&mpc->egress_lock, flags);
1da177e4 LT	395	return entry;
	396	}
	397	entry = entry->next;
	398	}
	399	read_unlock_irqrestore(&mpc->egress_lock, flags);
	400
	401	return NULL;
	402	}
	403
bee67d34 JP	404	static eg_cache_entry *eg_cache_get_by_src_ip(__be32 ipaddr,
bee67d34 JP	405	struct mpoa_client *mpc)
1da177e4 LT	406	{
	407	eg_cache_entry *entry;
	408
	409	read_lock_irq(&mpc->egress_lock);
	410	entry = mpc->eg_cache;
bee67d34 JP	411	while (entry != NULL) {
bee67d34 JP	412	if (entry->latest_ip_addr == ipaddr) {
1da177e4	413	atomic_inc(&entry->use);
f7d57453	414	read_unlock_irq(&mpc->egress_lock);
1da177e4 LT	415	return entry;
	416	}
	417	entry = entry->next;
	418	}
	419	read_unlock_irq(&mpc->egress_lock);
	420
	421	return NULL;
	422	}
	423
	424	static void eg_cache_put(eg_cache_entry *entry)
	425	{
	426	if (atomic_dec_and_test(&entry->use)) {
	427	memset(entry, 0, sizeof(eg_cache_entry));
	428	kfree(entry);
	429	}
	430
	431	return;
	432	}
	433
	434	/*
	435	* This should be called with write lock on
	436	*/
	437	static void eg_cache_remove_entry(eg_cache_entry *entry,
	438	struct mpoa_client *client)
	439	{
	440	struct atm_vcc *vcc;
	441	struct k_message msg;
	442
	443	vcc = entry->shortcut;
b50c2ea7	444	dprintk("removing an egress entry.\n");
1da177e4 LT	445	if (entry->prev != NULL)
	446	entry->prev->next = entry->next;
	447	else
	448	client->eg_cache = entry->next;
	449	if (entry->next != NULL)
	450	entry->next->prev = entry->prev;
	451	client->eg_ops->put(entry);
bee67d34	452	if (client->in_cache == NULL && client->eg_cache == NULL) {
1da177e4	453	msg.type = STOP_KEEP_ALIVE_SM;
bee67d34	454	msg_to_mpoad(&msg, client);
1da177e4 LT	455	}
	456
	457	/* Check if the ingress side still uses this VCC */
	458	if (vcc != NULL) {
	459	in_cache_entry *in_entry = client->in_ops->get_by_vcc(vcc, client);
	460	if (in_entry != NULL) {
	461	client->in_ops->put(in_entry);
	462	return;
	463	}
	464	vcc_release_async(vcc, -EPIPE);
	465	}
	466
	467	return;
	468	}
	469
bee67d34 JP	470	static eg_cache_entry eg_cache_add_entry(struct k_message msg,
bee67d34 JP	471	struct mpoa_client *client)
1da177e4	472	{
2afe37cd	473	eg_cache_entry *entry = kzalloc(sizeof(eg_cache_entry), GFP_KERNEL);
1da177e4 LT	474
1da177e4 LT	475	if (entry == NULL) {
bee67d34	476	pr_info("out of memory\n");
1da177e4 LT	477	return NULL;
	478	}
	479
b50c2ea7	480	dprintk("adding an egress entry, ip = %pI4, this should be our IP\n",
21454aaa	481	&msg->content.eg_info.eg_dst_ip);
1da177e4 LT	482
1da177e4 LT	483	atomic_set(&entry->use, 1);
b50c2ea7	484	dprintk("new_eg_cache_entry: about to lock\n");
1da177e4 LT	485	write_lock_irq(&client->egress_lock);
	486	entry->next = client->eg_cache;
	487	entry->prev = NULL;
	488	if (client->eg_cache != NULL)
	489	client->eg_cache->prev = entry;
	490	client->eg_cache = entry;
	491
	492	memcpy(entry->MPS_ctrl_ATM_addr, client->mps_ctrl_addr, ATM_ESA_LEN);
	493	entry->ctrl_info = msg->content.eg_info;
	494	do_gettimeofday(&(entry->tv));
	495	entry->entry_state = EGRESS_RESOLVED;
b50c2ea7	496	dprintk("new_eg_cache_entry cache_id %u\n",
bee67d34	497	ntohl(entry->ctrl_info.cache_id));
b50c2ea7	498	dprintk("mps_ip = %pI4\n", &entry->ctrl_info.mps_ip);
1da177e4 LT	499	atomic_inc(&entry->use);
	500
	501	write_unlock_irq(&client->egress_lock);
b50c2ea7	502	dprintk("new_eg_cache_entry: unlocked\n");
1da177e4 LT	503
	504	return entry;
	505	}
	506
bee67d34	507	static void update_eg_cache_entry(eg_cache_entry *entry, uint16_t holding_time)
1da177e4 LT	508	{
	509	do_gettimeofday(&(entry->tv));
	510	entry->entry_state = EGRESS_RESOLVED;
	511	entry->ctrl_info.holding_time = holding_time;
	512
	513	return;
	514	}
	515
	516	static void clear_expired(struct mpoa_client *client)
	517	{
	518	eg_cache_entry entry, next_entry;
	519	struct timeval now;
	520	struct k_message msg;
	521
	522	do_gettimeofday(&now);
	523
	524	write_lock_irq(&client->egress_lock);
	525	entry = client->eg_cache;
bee67d34	526	while (entry != NULL) {
1da177e4	527	next_entry = entry->next;
bee67d34 JP	528	if ((now.tv_sec - entry->tv.tv_sec)
bee67d34 JP	529	> entry->ctrl_info.holding_time) {
1da177e4 LT	530	msg.type = SND_EGRESS_PURGE;
1da177e4 LT	531	msg.content.eg_info = entry->ctrl_info;
b50c2ea7	532	dprintk("egress_cache: holding time expired, cache_id = %u.\n",
bee67d34	533	ntohl(entry->ctrl_info.cache_id));
1da177e4 LT	534	msg_to_mpoad(&msg, client);
	535	client->eg_ops->remove_entry(entry, client);
	536	}
	537	entry = next_entry;
	538	}
	539	write_unlock_irq(&client->egress_lock);
	540
	541	return;
	542	}
	543
	544	static void eg_destroy_cache(struct mpoa_client *mpc)
	545	{
	546	write_lock_irq(&mpc->egress_lock);
bee67d34	547	while (mpc->eg_cache != NULL)
1da177e4 LT	548	mpc->eg_ops->remove_entry(mpc->eg_cache, mpc);
	549	write_unlock_irq(&mpc->egress_lock);
	550
	551	return;
	552	}
	553
	554
1da177e4 LT	555	static struct in_cache_ops ingress_ops = {
	556	in_cache_add_entry, /* add_entry */
	557	in_cache_get, /* get */
	558	in_cache_get_with_mask, /* get_with_mask */
	559	in_cache_get_by_vcc, /* get_by_vcc */
	560	in_cache_put, /* put */
	561	in_cache_remove_entry, /* remove_entry */
	562	cache_hit, /* cache_hit */
	563	clear_count_and_expired, /* clear_count */
	564	check_resolving_entries, /* check_resolving */
	565	refresh_entries, /* refresh */
	566	in_destroy_cache /* destroy_cache */
	567	};
	568
	569	static struct eg_cache_ops egress_ops = {
	570	eg_cache_add_entry, /* add_entry */
	571	eg_cache_get_by_cache_id, /* get_by_cache_id */
	572	eg_cache_get_by_tag, /* get_by_tag */
	573	eg_cache_get_by_vcc, /* get_by_vcc */
	574	eg_cache_get_by_src_ip, /* get_by_src_ip */
	575	eg_cache_put, /* put */
	576	eg_cache_remove_entry, /* remove_entry */
	577	update_eg_cache_entry, /* update */
	578	clear_expired, /* clear_expired */
	579	eg_destroy_cache /* destroy_cache */
	580	};
	581
	582
	583	void atm_mpoa_init_cache(struct mpoa_client *mpc)
	584	{
	585	mpc->in_ops = &ingress_ops;
	586	mpc->eg_ops = &egress_ops;
	587
	588	return;
	589	}