143 строки
3.2 KiB
C
143 строки
3.2 KiB
C
/*
|
|
* 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 */
|