original_kernel/include/net/act_generic.h

/*
 * include/net/act_generic.h
 *
*/
#ifndef _NET_ACT_GENERIC_H
#define _NET_ACT_GENERIC_H
static inline int tcf_defact_release(struct tcf_defact *p, int bind)
{
	int ret = 0;
	if (p) {
		if (bind) {
			p->bindcnt--;
		}
		p->refcnt--;
		if (p->bindcnt <= 0 && p->refcnt <= 0) {
			kfree(p->defdata);
			tcf_hash_destroy(p);
			ret = 1;
		}
	}
	return ret;
}

static inline int
alloc_defdata(struct tcf_defact *p, u32 datalen, void *defdata)
{
	p->defdata = kmalloc(datalen, GFP_KERNEL);
	if (p->defdata == NULL)
		return -ENOMEM;
	p->datalen = datalen;
	memcpy(p->defdata, defdata, datalen);
	return 0;
}

static inline int
realloc_defdata(struct tcf_defact *p, u32 datalen, void *defdata)
{
	/* safer to be just brute force for now */
	kfree(p->defdata);
	return alloc_defdata(p, datalen, defdata);
}

static inline int
tcf_defact_init(struct rtattr *rta, struct rtattr *est,
		struct tc_action *a, int ovr, int bind)
{
	struct rtattr *tb[TCA_DEF_MAX];
	struct tc_defact *parm;
	struct tcf_defact *p;
	void *defdata;
	u32 datalen = 0;
	int ret = 0;

	if (rta == NULL || rtattr_parse_nested(tb, TCA_DEF_MAX, rta) < 0)
		return -EINVAL;

	if (tb[TCA_DEF_PARMS - 1] == NULL || 
	    RTA_PAYLOAD(tb[TCA_DEF_PARMS - 1]) < sizeof(*parm))
		return -EINVAL;

	parm = RTA_DATA(tb[TCA_DEF_PARMS - 1]);
	defdata = RTA_DATA(tb[TCA_DEF_DATA - 1]);
	if (defdata == NULL)
		return -EINVAL;

	datalen = RTA_PAYLOAD(tb[TCA_DEF_DATA - 1]);
	if (datalen <= 0)
		return -EINVAL;

	p = tcf_hash_check(parm->index, a, ovr, bind);
	if (p == NULL) {
		p = tcf_hash_create(parm->index, est, a, sizeof(*p), ovr, bind);
		if (p == NULL)
			return -ENOMEM;

		ret = alloc_defdata(p, datalen, defdata);
		if (ret < 0) {
			kfree(p);
			return ret;
		}
		ret = ACT_P_CREATED;
	} else {
		if (!ovr) {
			tcf_defact_release(p, bind);
			return -EEXIST;
		}
		realloc_defdata(p, datalen, defdata);
	}

	spin_lock_bh(&p->lock);
	p->action = parm->action;
	spin_unlock_bh(&p->lock);
	if (ret == ACT_P_CREATED)
		tcf_hash_insert(p);
	return ret;
}

static inline int tcf_defact_cleanup(struct tc_action *a, int bind)
{
	struct tcf_defact *p = PRIV(a, defact);

	if (p != NULL)
		return tcf_defact_release(p, bind);
	return 0;
}

static inline int
tcf_defact_dump(struct sk_buff *skb, struct tc_action *a, int bind, int ref)
{
	unsigned char *b = skb->tail;
	struct tc_defact opt;
	struct tcf_defact *p = PRIV(a, defact);
	struct tcf_t t;

	opt.index = p->index;
	opt.refcnt = p->refcnt - ref;
	opt.bindcnt = p->bindcnt - bind;
	opt.action = p->action;
	RTA_PUT(skb, TCA_DEF_PARMS, sizeof(opt), &opt);
	RTA_PUT(skb, TCA_DEF_DATA, p->datalen, p->defdata);
	t.install = jiffies_to_clock_t(jiffies - p->tm.install);
	t.lastuse = jiffies_to_clock_t(jiffies - p->tm.lastuse);
	t.expires = jiffies_to_clock_t(p->tm.expires);
	RTA_PUT(skb, TCA_DEF_TM, sizeof(t), &t);
	return skb->len;

rtattr_failure:
	skb_trim(skb, b - skb->data);
	return -1;
}

#define tca_use_default_ops \
	.dump           =       tcf_defact_dump, \
	.cleanup        =       tcf_defact_cleanup, \
	.init           =       tcf_defact_init, \
	.walk           =       tcf_generic_walker, \

#define tca_use_default_defines(name) \
	static u32 idx_gen; \
	static struct tcf_defact *tcf_##name_ht[MY_TAB_SIZE]; \
	static DEFINE_RWLOCK(##name_lock);
#endif /* _NET_ACT_GENERIC_H */