OpenE2K
/
linux
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

net_sched: act: hide struct tcf_common from API 

Now we can totally hide it from modules. tcf_hash_*() API's
will operate on struct tc_action, modules don't need to care about
the details.

Cc: Jamal Hadi Salim <jhs@mojatatu.com>
Cc: David S. Miller <davem@davemloft.net>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: Jamal Hadi Salim <jhs@mojatatu.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
WANG Cong 2014-02-11 17:07:31 -08:00 committed by David S. Miller
parent 7282ec8cb4
commit 86062033fe
19 changed files with 135 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
include/net/act_api.h
View File

@ -98,16 +98,14 @@ struct tc_action_ops {
}; };
int tcf_hash_search(struct tc_action *a, u32 index); int tcf_hash_search(struct tc_action *a, u32 index);
void tcf_hash_destroy(struct tcf_common *p, struct tcf_hashinfo *hinfo); void tcf_hash_destroy(struct tc_action *a);
int tcf_hash_release(struct tcf_common *p, int bind, int tcf_hash_release(struct tc_action *a, int bind);
struct tcf_hashinfo *hinfo);
u32 tcf_hash_new_index(struct tcf_hashinfo *hinfo); u32 tcf_hash_new_index(struct tcf_hashinfo *hinfo);
struct tcf_common *tcf_hash_check(u32 index, struct tc_action *a, int tcf_hash_check(u32 index, struct tc_action *a, int bind);
int bind); int tcf_hash_create(u32 index, struct nlattr *est, struct tc_action *a,
struct tcf_common *tcf_hash_create(u32 index, struct nlattr *est, int size, int bind);
struct tc_action *a, int size, void tcf_hash_cleanup(struct tc_action *a, struct nlattr *est);
int bind); void tcf_hash_insert(struct tc_action *a);
void tcf_hash_insert(struct tcf_common *p, struct tcf_hashinfo *hinfo);
int tcf_register_action(struct tc_action_ops *a); int tcf_register_action(struct tc_action_ops *a);
int tcf_unregister_action(struct tc_action_ops *a); int tcf_unregister_action(struct tc_action_ops *a);

4
include/net/tc_act/tc_csum.h
View File

@ -9,7 +9,7 @@ struct tcf_csum {
u32 update_flags; u32 update_flags;
}; };
#define to_tcf_csum(pc) \ #define to_tcf_csum(a) \
container_of(pc,struct tcf_csum,common) container_of(a->priv,struct tcf_csum,common)
#endif /* __NET_TC_CSUM_H */ #endif /* __NET_TC_CSUM_H */

4
include/net/tc_act/tc_defact.h
View File

@ -8,7 +8,7 @@ struct tcf_defact {
u32 tcfd_datalen; u32 tcfd_datalen;
void *tcfd_defdata; void *tcfd_defdata;
}; };
#define to_defact(pc) \ #define to_defact(a) \
container_of(pc, struct tcf_defact, common) container_of(a->priv, struct tcf_defact, common)
#endif /* __NET_TC_DEF_H */ #endif /* __NET_TC_DEF_H */

4
include/net/tc_act/tc_gact.h
View File

@ -11,7 +11,7 @@ struct tcf_gact {
int tcfg_paction; int tcfg_paction;
#endif #endif
}; };
#define to_gact(pc) \ #define to_gact(a) \
container_of(pc, struct tcf_gact, common) container_of(a->priv, struct tcf_gact, common)
#endif /* __NET_TC_GACT_H */ #endif /* __NET_TC_GACT_H */

4
include/net/tc_act/tc_ipt.h
View File

@ -11,7 +11,7 @@ struct tcf_ipt {
char *tcfi_tname; char *tcfi_tname;
struct xt_entry_target *tcfi_t; struct xt_entry_target *tcfi_t;
}; };
#define to_ipt(pc) \ #define to_ipt(a) \
container_of(pc, struct tcf_ipt, common) container_of(a->priv, struct tcf_ipt, common)
#endif /* __NET_TC_IPT_H */ #endif /* __NET_TC_IPT_H */

4
include/net/tc_act/tc_mirred.h
View File

@ -11,7 +11,7 @@ struct tcf_mirred {
struct net_device *tcfm_dev; struct net_device *tcfm_dev;
struct list_head tcfm_list; struct list_head tcfm_list;
}; };
#define to_mirred(pc) \ #define to_mirred(a) \
container_of(pc, struct tcf_mirred, common) container_of(a->priv, struct tcf_mirred, common)
#endif /* __NET_TC_MIR_H */ #endif /* __NET_TC_MIR_H */

4
include/net/tc_act/tc_nat.h
View File

@ -13,9 +13,9 @@ struct tcf_nat {
u32 flags; u32 flags;
}; };
static inline struct tcf_nat *to_tcf_nat(struct tcf_common *pc) static inline struct tcf_nat *to_tcf_nat(struct tc_action *a)
{ {
return container_of(pc, struct tcf_nat, common); return container_of(a->priv, struct tcf_nat, common);
} }
#endif /* __NET_TC_NAT_H */ #endif /* __NET_TC_NAT_H */

4
include/net/tc_act/tc_pedit.h
View File

@ -9,7 +9,7 @@ struct tcf_pedit {
unsigned char tcfp_flags; unsigned char tcfp_flags;
struct tc_pedit_key *tcfp_keys; struct tc_pedit_key *tcfp_keys;
}; };
#define to_pedit(pc) \ #define to_pedit(a) \
container_of(pc, struct tcf_pedit, common) container_of(a->priv, struct tcf_pedit, common)
#endif /* __NET_TC_PED_H */ #endif /* __NET_TC_PED_H */

4
include/net/tc_act/tc_skbedit.h
View File

@ -29,7 +29,7 @@ struct tcf_skbedit {
u16 queue_mapping; u16 queue_mapping;
/* XXX: 16-bit pad here? */ /* XXX: 16-bit pad here? */
}; };
#define to_skbedit(pc) \ #define to_skbedit(a) \
container_of(pc, struct tcf_skbedit, common) container_of(a->priv, struct tcf_skbedit, common)
#endif /* __NET_TC_SKBEDIT_H */ #endif /* __NET_TC_SKBEDIT_H */

43
net/sched/act_api.c
View File

@ -27,8 +27,11 @@
#include <net/act_api.h> #include <net/act_api.h>
#include <net/netlink.h> #include <net/netlink.h>
void tcf_hash_destroy(struct tcf_common *p, struct tcf_hashinfo *hinfo) void tcf_hash_destroy(struct tc_action *a)
{ {
struct tcf_common *p = a->priv;
struct tcf_hashinfo *hinfo = a->ops->hinfo;
spin_lock_bh(&hinfo->lock); spin_lock_bh(&hinfo->lock);
hlist_del(&p->tcfc_head); hlist_del(&p->tcfc_head);
spin_unlock_bh(&hinfo->lock); spin_unlock_bh(&hinfo->lock);
@ -42,9 +45,9 @@ void tcf_hash_destroy(struct tcf_common *p, struct tcf_hashinfo *hinfo)
} }
EXPORT_SYMBOL(tcf_hash_destroy); EXPORT_SYMBOL(tcf_hash_destroy);
int tcf_hash_release(struct tcf_common *p, int bind, int tcf_hash_release(struct tc_action *a, int bind)
struct tcf_hashinfo *hinfo)
{ {
struct tcf_common *p = a->priv;
int ret = 0; int ret = 0;
if (p) { if (p) {
@ -53,7 +56,7 @@ int tcf_hash_release(struct tcf_common *p, int bind,
p->tcfc_refcnt--; p->tcfc_refcnt--;
if (p->tcfc_bindcnt <= 0 && p->tcfc_refcnt <= 0) { if (p->tcfc_bindcnt <= 0 && p->tcfc_refcnt <= 0) {
tcf_hash_destroy(p, hinfo); tcf_hash_destroy(a);
ret = 1; ret = 1;
} }
} }
@ -127,7 +130,8 @@ static int tcf_del_walker(struct sk_buff *skb, struct tc_action *a)
for (i = 0; i < (hinfo->hmask + 1); i++) { for (i = 0; i < (hinfo->hmask + 1); i++) {
head = &hinfo->htab[tcf_hash(i, hinfo->hmask)]; head = &hinfo->htab[tcf_hash(i, hinfo->hmask)];
hlist_for_each_entry_safe(p, n, head, tcfc_head) { hlist_for_each_entry_safe(p, n, head, tcfc_head) {
if (ACT_P_DELETED == tcf_hash_release(p, 0, hinfo)) { a->priv = p;
if (ACT_P_DELETED == tcf_hash_release(a, 0)) {
module_put(a->ops->owner); module_put(a->ops->owner);
n_i++; n_i++;
} }
@ -198,7 +202,7 @@ int tcf_hash_search(struct tc_action *a, u32 index)
} }
EXPORT_SYMBOL(tcf_hash_search); EXPORT_SYMBOL(tcf_hash_search);
struct tcf_common *tcf_hash_check(u32 index, struct tc_action *a, int bind) int tcf_hash_check(u32 index, struct tc_action *a, int bind)
{ {
struct tcf_hashinfo *hinfo = a->ops->hinfo; struct tcf_hashinfo *hinfo = a->ops->hinfo;
struct tcf_common *p = NULL; struct tcf_common *p = NULL;
@ -207,19 +211,30 @@ struct tcf_common *tcf_hash_check(u32 index, struct tc_action *a, int bind)
p->tcfc_bindcnt++; p->tcfc_bindcnt++;
p->tcfc_refcnt++; p->tcfc_refcnt++;
a->priv = p; a->priv = p;
return 1;
} }
return p; return 0;
} }
EXPORT_SYMBOL(tcf_hash_check); EXPORT_SYMBOL(tcf_hash_check);
struct tcf_common *tcf_hash_create(u32 index, struct nlattr *est, void tcf_hash_cleanup(struct tc_action *a, struct nlattr *est)
struct tc_action *a, int size, int bind) {
struct tcf_common *pc = a->priv;
if (est)
gen_kill_estimator(&pc->tcfc_bstats,
&pc->tcfc_rate_est);
kfree_rcu(pc, tcfc_rcu);
}
EXPORT_SYMBOL(tcf_hash_cleanup);
int tcf_hash_create(u32 index, struct nlattr *est, struct tc_action *a,
int size, int bind)
{ {
struct tcf_hashinfo *hinfo = a->ops->hinfo; struct tcf_hashinfo *hinfo = a->ops->hinfo;
struct tcf_common *p = kzalloc(size, GFP_KERNEL); struct tcf_common *p = kzalloc(size, GFP_KERNEL);
if (unlikely(!p)) if (unlikely(!p))
return ERR_PTR(-ENOMEM); return -ENOMEM;
p->tcfc_refcnt = 1; p->tcfc_refcnt = 1;
if (bind) if (bind)
p->tcfc_bindcnt = 1; p->tcfc_bindcnt = 1;
@ -234,17 +249,19 @@ struct tcf_common *tcf_hash_create(u32 index, struct nlattr *est,
&p->tcfc_lock, est); &p->tcfc_lock, est);
if (err) { if (err) {
kfree(p); kfree(p);
return ERR_PTR(err); return err;
} }
} }
a->priv = (void *) p; a->priv = (void *) p;
return p; return 0;
} }
EXPORT_SYMBOL(tcf_hash_create); EXPORT_SYMBOL(tcf_hash_create);
void tcf_hash_insert(struct tcf_common *p, struct tcf_hashinfo *hinfo) void tcf_hash_insert(struct tc_action *a)
{ {
struct tcf_common *p = a->priv;
struct tcf_hashinfo *hinfo = a->ops->hinfo;
unsigned int h = tcf_hash(p->tcfc_index, hinfo->hmask); unsigned int h = tcf_hash(p->tcfc_index, hinfo->hmask);
spin_lock_bh(&hinfo->lock); spin_lock_bh(&hinfo->lock);

24
net/sched/act_csum.c
View File

@ -48,7 +48,6 @@ static int tcf_csum_init(struct net *n, struct nlattr *nla, struct nlattr *est,
{ {
struct nlattr *tb[TCA_CSUM_MAX + 1]; struct nlattr *tb[TCA_CSUM_MAX + 1];
struct tc_csum *parm; struct tc_csum *parm;
struct tcf_common *pc;
struct tcf_csum *p; struct tcf_csum *p;
int ret = 0, err; int ret = 0, err;
@ -63,38 +62,31 @@ static int tcf_csum_init(struct net *n, struct nlattr *nla, struct nlattr *est,
return -EINVAL; return -EINVAL;
parm = nla_data(tb[TCA_CSUM_PARMS]); parm = nla_data(tb[TCA_CSUM_PARMS]);
pc = tcf_hash_check(parm->index, a, bind); if (!tcf_hash_check(parm->index, a, bind)) {
if (!pc) { ret = tcf_hash_create(parm->index, est, a, sizeof(*p), bind);
pc = tcf_hash_create(parm->index, est, a, sizeof(*p), bind); if (ret)
if (IS_ERR(pc)) return ret;
return PTR_ERR(pc);
ret = ACT_P_CREATED; ret = ACT_P_CREATED;
} else { } else {
if (bind)/* dont override defaults */ if (bind)/* dont override defaults */
return 0; return 0;
tcf_hash_release(pc, bind, a->ops->hinfo); tcf_hash_release(a, bind);
if (!ovr) if (!ovr)
return -EEXIST; return -EEXIST;
} }
p = to_tcf_csum(pc); p = to_tcf_csum(a);
spin_lock_bh(&p->tcf_lock); spin_lock_bh(&p->tcf_lock);
p->tcf_action = parm->action; p->tcf_action = parm->action;
p->update_flags = parm->update_flags; p->update_flags = parm->update_flags;
spin_unlock_bh(&p->tcf_lock); spin_unlock_bh(&p->tcf_lock);
if (ret == ACT_P_CREATED) if (ret == ACT_P_CREATED)
tcf_hash_insert(pc, a->ops->hinfo); tcf_hash_insert(a);
return ret; return ret;
} }
static int tcf_csum_cleanup(struct tc_action *a, int bind)
{
struct tcf_csum *p = a->priv;
return tcf_hash_release(&p->common, bind, &csum_hash_info);
}
/** /**
* tcf_csum_skb_nextlayer - Get next layer pointer * tcf_csum_skb_nextlayer - Get next layer pointer
* @skb: sk_buff to use * @skb: sk_buff to use
@ -574,7 +566,7 @@ static struct tc_action_ops act_csum_ops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.act = tcf_csum, .act = tcf_csum,
.dump = tcf_csum_dump, .dump = tcf_csum_dump,
.cleanup = tcf_csum_cleanup, .cleanup = tcf_hash_release,
.init = tcf_csum_init, .init = tcf_csum_init,
}; };

27
net/sched/act_gact.c
View File

@ -57,7 +57,6 @@ static int tcf_gact_init(struct net *net, struct nlattr *nla,
struct nlattr *tb[TCA_GACT_MAX + 1]; struct nlattr *tb[TCA_GACT_MAX + 1];
struct tc_gact *parm; struct tc_gact *parm;
struct tcf_gact *gact; struct tcf_gact *gact;
struct tcf_common *pc;
int ret = 0; int ret = 0;
int err; int err;
#ifdef CONFIG_GACT_PROB #ifdef CONFIG_GACT_PROB
@ -86,21 +85,20 @@ static int tcf_gact_init(struct net *net, struct nlattr *nla,
} }
#endif #endif
pc = tcf_hash_check(parm->index, a, bind); if (!tcf_hash_check(parm->index, a, bind)) {
if (!pc) { ret = tcf_hash_create(parm->index, est, a, sizeof(*gact), bind);
pc = tcf_hash_create(parm->index, est, a, sizeof(*gact), bind); if (ret)
if (IS_ERR(pc)) return ret;
return PTR_ERR(pc);
ret = ACT_P_CREATED; ret = ACT_P_CREATED;
} else { } else {
if (bind)/* dont override defaults */ if (bind)/* dont override defaults */
return 0; return 0;
tcf_hash_release(pc, bind, a->ops->hinfo); tcf_hash_release(a, bind);
if (!ovr) if (!ovr)
return -EEXIST; return -EEXIST;
} }
gact = to_gact(pc); gact = to_gact(a);
spin_lock_bh(&gact->tcf_lock); spin_lock_bh(&gact->tcf_lock);
gact->tcf_action = parm->action; gact->tcf_action = parm->action;
@ -113,19 +111,10 @@ static int tcf_gact_init(struct net *net, struct nlattr *nla,
#endif #endif
spin_unlock_bh(&gact->tcf_lock); spin_unlock_bh(&gact->tcf_lock);
if (ret == ACT_P_CREATED) if (ret == ACT_P_CREATED)
tcf_hash_insert(pc, a->ops->hinfo); tcf_hash_insert(a);
return ret; return ret;
} }
static int tcf_gact_cleanup(struct tc_action *a, int bind)
{
struct tcf_gact *gact = a->priv;
if (gact)
return tcf_hash_release(&gact->common, bind, a->ops->hinfo);
return 0;
}
static int tcf_gact(struct sk_buff *skb, const struct tc_action *a, static int tcf_gact(struct sk_buff *skb, const struct tc_action *a,
struct tcf_result *res) struct tcf_result *res)
{ {
@ -196,7 +185,7 @@ static struct tc_action_ops act_gact_ops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.act = tcf_gact, .act = tcf_gact,
.dump = tcf_gact_dump, .dump = tcf_gact_dump,
.cleanup = tcf_gact_cleanup, .cleanup = tcf_hash_release,
.init = tcf_gact_init, .init = tcf_gact_init,
}; };

39
net/sched/act_ipt.c
View File

@ -69,8 +69,9 @@ static void ipt_destroy_target(struct xt_entry_target *t)
module_put(par.target->me); module_put(par.target->me);
} }
static int tcf_ipt_release(struct tcf_ipt *ipt, int bind) static int tcf_ipt_release(struct tc_action *a, int bind)
{ {
struct tcf_ipt *ipt = to_ipt(a);
int ret = 0; int ret = 0;
if (ipt) { if (ipt) {
if (bind) if (bind)
@ -80,7 +81,7 @@ static int tcf_ipt_release(struct tcf_ipt *ipt, int bind)
ipt_destroy_target(ipt->tcfi_t); ipt_destroy_target(ipt->tcfi_t);
kfree(ipt->tcfi_tname); kfree(ipt->tcfi_tname);
kfree(ipt->tcfi_t); kfree(ipt->tcfi_t);
tcf_hash_destroy(&ipt->common, &ipt_hash_info); tcf_hash_destroy(a);
ret = ACT_P_DELETED; ret = ACT_P_DELETED;
} }
} }
@ -99,7 +100,6 @@ static int tcf_ipt_init(struct net *net, struct nlattr *nla, struct nlattr *est,
{ {
struct nlattr *tb[TCA_IPT_MAX + 1]; struct nlattr *tb[TCA_IPT_MAX + 1];
struct tcf_ipt *ipt; struct tcf_ipt *ipt;
struct tcf_common *pc;
struct xt_entry_target *td, *t; struct xt_entry_target *td, *t;
char *tname; char *tname;
int ret = 0, err; int ret = 0, err;
@ -125,21 +125,20 @@ static int tcf_ipt_init(struct net *net, struct nlattr *nla, struct nlattr *est,
if (tb[TCA_IPT_INDEX] != NULL) if (tb[TCA_IPT_INDEX] != NULL)
index = nla_get_u32(tb[TCA_IPT_INDEX]); index = nla_get_u32(tb[TCA_IPT_INDEX]);
pc = tcf_hash_check(index, a, bind); if (!tcf_hash_check(index, a, bind) ) {
if (!pc) { ret = tcf_hash_create(index, est, a, sizeof(*ipt), bind);
pc = tcf_hash_create(index, est, a, sizeof(*ipt), bind); if (ret)
if (IS_ERR(pc)) return ret;
return PTR_ERR(pc);
ret = ACT_P_CREATED; ret = ACT_P_CREATED;
} else { } else {
if (bind)/* dont override defaults */ if (bind)/* dont override defaults */
return 0; return 0;
tcf_ipt_release(to_ipt(pc), bind); tcf_ipt_release(a, bind);
if (!ovr) if (!ovr)
return -EEXIST; return -EEXIST;
} }
ipt = to_ipt(pc); ipt = to_ipt(a);
hook = nla_get_u32(tb[TCA_IPT_HOOK]); hook = nla_get_u32(tb[TCA_IPT_HOOK]);
@ -170,7 +169,7 @@ static int tcf_ipt_init(struct net *net, struct nlattr *nla, struct nlattr *est,
ipt->tcfi_hook = hook; ipt->tcfi_hook = hook;
spin_unlock_bh(&ipt->tcf_lock); spin_unlock_bh(&ipt->tcf_lock);
if (ret == ACT_P_CREATED) if (ret == ACT_P_CREATED)
tcf_hash_insert(pc, a->ops->hinfo); tcf_hash_insert(a);
return ret; return ret;
err3: err3:
@ -178,21 +177,11 @@ err3:
err2: err2:
kfree(tname); kfree(tname);
err1: err1:
if (ret == ACT_P_CREATED) { if (ret == ACT_P_CREATED)
if (est) tcf_hash_cleanup(a, est);
gen_kill_estimator(&pc->tcfc_bstats,
&pc->tcfc_rate_est);
kfree_rcu(pc, tcfc_rcu);
}
return err; return err;
} }
static int tcf_ipt_cleanup(struct tc_action *a, int bind)
{
struct tcf_ipt *ipt = a->priv;
return tcf_ipt_release(ipt, bind);
}
static int tcf_ipt(struct sk_buff *skb, const struct tc_action *a, static int tcf_ipt(struct sk_buff *skb, const struct tc_action *a,
struct tcf_result *res) struct tcf_result *res)
{ {
@ -289,7 +278,7 @@ static struct tc_action_ops act_ipt_ops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.act = tcf_ipt, .act = tcf_ipt,
.dump = tcf_ipt_dump, .dump = tcf_ipt_dump,
.cleanup = tcf_ipt_cleanup, .cleanup = tcf_ipt_release,
.init = tcf_ipt_init, .init = tcf_ipt_init,
}; };
@ -300,7 +289,7 @@ static struct tc_action_ops act_xt_ops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.act = tcf_ipt, .act = tcf_ipt,
.dump = tcf_ipt_dump, .dump = tcf_ipt_dump,
.cleanup = tcf_ipt_cleanup, .cleanup = tcf_ipt_release,
.init = tcf_ipt_init, .init = tcf_ipt_init,
}; };

32
net/sched/act_mirred.c
View File

@ -33,8 +33,9 @@
static LIST_HEAD(mirred_list); static LIST_HEAD(mirred_list);
static struct tcf_hashinfo mirred_hash_info; static struct tcf_hashinfo mirred_hash_info;
static int tcf_mirred_release(struct tcf_mirred *m, int bind) static int tcf_mirred_release(struct tc_action *a, int bind)
{ {
struct tcf_mirred *m = to_mirred(a);
if (m) { if (m) {
if (bind) if (bind)
m->tcf_bindcnt--; m->tcf_bindcnt--;
@ -43,7 +44,7 @@ static int tcf_mirred_release(struct tcf_mirred *m, int bind)
list_del(&m->tcfm_list); list_del(&m->tcfm_list);
if (m->tcfm_dev) if (m->tcfm_dev)
dev_put(m->tcfm_dev); dev_put(m->tcfm_dev);
tcf_hash_destroy(&m->common, &mirred_hash_info); tcf_hash_destroy(a);
return 1; return 1;
} }
} }
@ -61,7 +62,6 @@ static int tcf_mirred_init(struct net *net, struct nlattr *nla,
struct nlattr *tb[TCA_MIRRED_MAX + 1]; struct nlattr *tb[TCA_MIRRED_MAX + 1];
struct tc_mirred *parm; struct tc_mirred *parm;
struct tcf_mirred *m; struct tcf_mirred *m;
struct tcf_common *pc;
struct net_device *dev; struct net_device *dev;
int ret, ok_push = 0; int ret, ok_push = 0;
@ -101,21 +101,20 @@ static int tcf_mirred_init(struct net *net, struct nlattr *nla,
dev = NULL; dev = NULL;
} }
pc = tcf_hash_check(parm->index, a, bind); if (!tcf_hash_check(parm->index, a, bind)) {
if (!pc) {
if (dev == NULL) if (dev == NULL)
return -EINVAL; return -EINVAL;
pc = tcf_hash_create(parm->index, est, a, sizeof(*m), bind); ret = tcf_hash_create(parm->index, est, a, sizeof(*m), bind);
if (IS_ERR(pc)) if (ret)
return PTR_ERR(pc); return ret;
ret = ACT_P_CREATED; ret = ACT_P_CREATED;
} else { } else {
if (!ovr) { if (!ovr) {
tcf_mirred_release(to_mirred(pc), bind); tcf_mirred_release(a, bind);
return -EEXIST; return -EEXIST;
} }
} }
m = to_mirred(pc); m = to_mirred(a);
spin_lock_bh(&m->tcf_lock); spin_lock_bh(&m->tcf_lock);
m->tcf_action = parm->action; m->tcf_action = parm->action;
@ -131,21 +130,12 @@ static int tcf_mirred_init(struct net *net, struct nlattr *nla,
spin_unlock_bh(&m->tcf_lock); spin_unlock_bh(&m->tcf_lock);
if (ret == ACT_P_CREATED) { if (ret == ACT_P_CREATED) {
list_add(&m->tcfm_list, &mirred_list); list_add(&m->tcfm_list, &mirred_list);
tcf_hash_insert(pc, a->ops->hinfo); tcf_hash_insert(a);
} }
return ret; return ret;
} }
static int tcf_mirred_cleanup(struct tc_action *a, int bind)
{
struct tcf_mirred *m = a->priv;
if (m)
return tcf_mirred_release(m, bind);
return 0;
}
static int tcf_mirred(struct sk_buff *skb, const struct tc_action *a, static int tcf_mirred(struct sk_buff *skb, const struct tc_action *a,
struct tcf_result *res) struct tcf_result *res)
{ {
@ -259,7 +249,7 @@ static struct tc_action_ops act_mirred_ops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.act = tcf_mirred, .act = tcf_mirred,
.dump = tcf_mirred_dump, .dump = tcf_mirred_dump,
.cleanup = tcf_mirred_cleanup, .cleanup = tcf_mirred_release,
.init = tcf_mirred_init, .init = tcf_mirred_init,
}; };

25
net/sched/act_nat.c
View File

@ -44,7 +44,6 @@ static int tcf_nat_init(struct net *net, struct nlattr *nla, struct nlattr *est,
struct tc_nat *parm; struct tc_nat *parm;
int ret = 0, err; int ret = 0, err;
struct tcf_nat *p; struct tcf_nat *p;
struct tcf_common *pc;
if (nla == NULL) if (nla == NULL)
return -EINVAL; return -EINVAL;
@ -57,20 +56,19 @@ static int tcf_nat_init(struct net *net, struct nlattr *nla, struct nlattr *est,
return -EINVAL; return -EINVAL;
parm = nla_data(tb[TCA_NAT_PARMS]); parm = nla_data(tb[TCA_NAT_PARMS]);
pc = tcf_hash_check(parm->index, a, bind); if (!tcf_hash_check(parm->index, a, bind)) {
if (!pc) { ret = tcf_hash_create(parm->index, est, a, sizeof(*p), bind);
pc = tcf_hash_create(parm->index, est, a, sizeof(*p), bind); if (ret)
if (IS_ERR(pc)) return ret;
return PTR_ERR(pc);
ret = ACT_P_CREATED; ret = ACT_P_CREATED;
} else { } else {
if (bind) if (bind)
return 0; return 0;
tcf_hash_release(pc, bind, a->ops->hinfo); tcf_hash_release(a, bind);
if (!ovr) if (!ovr)
return -EEXIST; return -EEXIST;
} }
p = to_tcf_nat(pc); p = to_tcf_nat(a);
spin_lock_bh(&p->tcf_lock); spin_lock_bh(&p->tcf_lock);
p->old_addr = parm->old_addr; p->old_addr = parm->old_addr;
@ -82,18 +80,11 @@ static int tcf_nat_init(struct net *net, struct nlattr *nla, struct nlattr *est,
spin_unlock_bh(&p->tcf_lock); spin_unlock_bh(&p->tcf_lock);
if (ret == ACT_P_CREATED) if (ret == ACT_P_CREATED)
tcf_hash_insert(pc, a->ops->hinfo); tcf_hash_insert(a);
return ret; return ret;
} }
static int tcf_nat_cleanup(struct tc_action *a, int bind)
{
struct tcf_nat *p = a->priv;
return tcf_hash_release(&p->common, bind, &nat_hash_info);
}
static int tcf_nat(struct sk_buff *skb, const struct tc_action *a, static int tcf_nat(struct sk_buff *skb, const struct tc_action *a,
struct tcf_result *res) struct tcf_result *res)
{ {
@ -298,7 +289,7 @@ static struct tc_action_ops act_nat_ops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.act = tcf_nat, .act = tcf_nat,
.dump = tcf_nat_dump, .dump = tcf_nat_dump,
.cleanup = tcf_nat_cleanup, .cleanup = tcf_hash_release,
.init = tcf_nat_init, .init = tcf_nat_init,
}; };

25
net/sched/act_pedit.c
View File

@ -39,7 +39,6 @@ static int tcf_pedit_init(struct net *net, struct nlattr *nla,
struct tc_pedit *parm; struct tc_pedit *parm;
int ret = 0, err; int ret = 0, err;
struct tcf_pedit *p; struct tcf_pedit *p;
struct tcf_common *pc;
struct tc_pedit_key *keys = NULL; struct tc_pedit_key *keys = NULL;
int ksize; int ksize;
@ -57,26 +56,22 @@ static int tcf_pedit_init(struct net *net, struct nlattr *nla,
if (nla_len(tb[TCA_PEDIT_PARMS]) < sizeof(*parm) + ksize) if (nla_len(tb[TCA_PEDIT_PARMS]) < sizeof(*parm) + ksize)
return -EINVAL; return -EINVAL;
pc = tcf_hash_check(parm->index, a, bind); if (!tcf_hash_check(parm->index, a, bind)) {
if (!pc) {
if (!parm->nkeys) if (!parm->nkeys)
return -EINVAL; return -EINVAL;
pc = tcf_hash_create(parm->index, est, a, sizeof(*p), bind); ret = tcf_hash_create(parm->index, est, a, sizeof(*p), bind);
if (IS_ERR(pc)) if (ret)
return PTR_ERR(pc); return ret;
p = to_pedit(pc); p = to_pedit(a);
keys = kmalloc(ksize, GFP_KERNEL); keys = kmalloc(ksize, GFP_KERNEL);
if (keys == NULL) { if (keys == NULL) {
if (est) tcf_hash_cleanup(a, est);
gen_kill_estimator(&pc->tcfc_bstats,
&pc->tcfc_rate_est);
kfree_rcu(pc, tcfc_rcu);
return -ENOMEM; return -ENOMEM;
} }
ret = ACT_P_CREATED; ret = ACT_P_CREATED;
} else { } else {
p = to_pedit(pc); p = to_pedit(a);
tcf_hash_release(pc, bind, a->ops->hinfo); tcf_hash_release(a, bind);
if (bind) if (bind)
return 0; return 0;
if (!ovr) if (!ovr)
@ -100,7 +95,7 @@ static int tcf_pedit_init(struct net *net, struct nlattr *nla,
memcpy(p->tcfp_keys, parm->keys, ksize); memcpy(p->tcfp_keys, parm->keys, ksize);
spin_unlock_bh(&p->tcf_lock); spin_unlock_bh(&p->tcf_lock);
if (ret == ACT_P_CREATED) if (ret == ACT_P_CREATED)
tcf_hash_insert(pc, a->ops->hinfo); tcf_hash_insert(a);
return ret; return ret;
} }
@ -110,7 +105,7 @@ static int tcf_pedit_cleanup(struct tc_action *a, int bind)
if (p) { if (p) {
struct tc_pedit_key *keys = p->tcfp_keys; struct tc_pedit_key *keys = p->tcfp_keys;
if (tcf_hash_release(&p->common, bind, &pedit_hash_info)) { if (tcf_hash_release(a, bind)) {
kfree(keys); kfree(keys);
return 1; return 1;
} }

10
net/sched/act_police.c
View File

@ -253,14 +253,6 @@ failure:
return err; return err;
} }
static int tcf_act_police_cleanup(struct tc_action *a, int bind)
{
struct tcf_police *p = a->priv;
if (p)
return tcf_hash_release(&p->common, bind, &police_hash_info);
return 0;
}
static int tcf_act_police(struct sk_buff *skb, const struct tc_action *a, static int tcf_act_police(struct sk_buff *skb, const struct tc_action *a,
struct tcf_result *res) struct tcf_result *res)
{ {
@ -362,7 +354,7 @@ static struct tc_action_ops act_police_ops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.act = tcf_act_police, .act = tcf_act_police,
.dump = tcf_act_police_dump, .dump = tcf_act_police_dump,
.cleanup = tcf_act_police_cleanup, .cleanup = tcf_hash_release,
.init = tcf_act_police_locate, .init = tcf_act_police_locate,
.walk = tcf_act_police_walker .walk = tcf_act_police_walker
}; };

39
net/sched/act_simple.c
View File

@ -47,8 +47,9 @@ static int tcf_simp(struct sk_buff *skb, const struct tc_action *a,
return d->tcf_action; return d->tcf_action;
} }
static int tcf_simp_release(struct tcf_defact *d, int bind) static int tcf_simp_release(struct tc_action *a, int bind)
{ {
struct tcf_defact *d = to_defact(a);
int ret = 0; int ret = 0;
if (d) { if (d) {
if (bind) if (bind)
@ -56,7 +57,7 @@ static int tcf_simp_release(struct tcf_defact *d, int bind)
d->tcf_refcnt--; d->tcf_refcnt--;
if (d->tcf_bindcnt <= 0 && d->tcf_refcnt <= 0) { if (d->tcf_bindcnt <= 0 && d->tcf_refcnt <= 0) {
kfree(d->tcfd_defdata); kfree(d->tcfd_defdata);
tcf_hash_destroy(&d->common, &simp_hash_info); tcf_hash_destroy(a);
ret = 1; ret = 1;
} }
} }
@ -94,7 +95,6 @@ static int tcf_simp_init(struct net *net, struct nlattr *nla,
struct nlattr *tb[TCA_DEF_MAX + 1]; struct nlattr *tb[TCA_DEF_MAX + 1];
struct tc_defact *parm; struct tc_defact *parm;
struct tcf_defact *d; struct tcf_defact *d;
struct tcf_common *pc;
char *defdata; char *defdata;
int ret = 0, err; int ret = 0, err;
@ -114,29 +114,25 @@ static int tcf_simp_init(struct net *net, struct nlattr *nla,
parm = nla_data(tb[TCA_DEF_PARMS]); parm = nla_data(tb[TCA_DEF_PARMS]);
defdata = nla_data(tb[TCA_DEF_DATA]); defdata = nla_data(tb[TCA_DEF_DATA]);
pc = tcf_hash_check(parm->index, a, bind); if (!tcf_hash_check(parm->index, a, bind)) {
if (!pc) { ret = tcf_hash_create(parm->index, est, a, sizeof(*d), bind);
pc = tcf_hash_create(parm->index, est, a, sizeof(*d), bind); if (ret)
if (IS_ERR(pc)) return ret;
return PTR_ERR(pc);
d = to_defact(pc); d = to_defact(a);
ret = alloc_defdata(d, defdata); ret = alloc_defdata(d, defdata);
if (ret < 0) { if (ret < 0) {
if (est) tcf_hash_cleanup(a, est);
gen_kill_estimator(&pc->tcfc_bstats,
&pc->tcfc_rate_est);
kfree_rcu(pc, tcfc_rcu);
return ret; return ret;
} }
d->tcf_action = parm->action; d->tcf_action = parm->action;
ret = ACT_P_CREATED; ret = ACT_P_CREATED;
} else { } else {
d = to_defact(pc); d = to_defact(a);
if (bind) if (bind)
return 0; return 0;
tcf_simp_release(d, bind); tcf_simp_release(a, bind);
if (!ovr) if (!ovr)
return -EEXIST; return -EEXIST;
@ -144,19 +140,10 @@ static int tcf_simp_init(struct net *net, struct nlattr *nla,
} }
if (ret == ACT_P_CREATED) if (ret == ACT_P_CREATED)
tcf_hash_insert(pc, a->ops->hinfo); tcf_hash_insert(a);
return ret; return ret;
} }
static int tcf_simp_cleanup(struct tc_action *a, int bind)
{
struct tcf_defact *d = a->priv;
if (d)
return tcf_simp_release(d, bind);
return 0;
}
static int tcf_simp_dump(struct sk_buff *skb, struct tc_action *a, static int tcf_simp_dump(struct sk_buff *skb, struct tc_action *a,
int bind, int ref) int bind, int ref)
{ {
@ -192,7 +179,7 @@ static struct tc_action_ops act_simp_ops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.act = tcf_simp, .act = tcf_simp,
.dump = tcf_simp_dump, .dump = tcf_simp_dump,
.cleanup = tcf_simp_cleanup, .cleanup = tcf_simp_release,
.init = tcf_simp_init, .init = tcf_simp_init,
}; };

29
net/sched/act_skbedit.c
View File

@ -65,7 +65,6 @@ static int tcf_skbedit_init(struct net *net, struct nlattr *nla,
struct nlattr *tb[TCA_SKBEDIT_MAX + 1]; struct nlattr *tb[TCA_SKBEDIT_MAX + 1];
struct tc_skbedit *parm; struct tc_skbedit *parm;
struct tcf_skbedit *d; struct tcf_skbedit *d;
struct tcf_common *pc;
u32 flags = 0, *priority = NULL, *mark = NULL; u32 flags = 0, *priority = NULL, *mark = NULL;
u16 *queue_mapping = NULL; u16 *queue_mapping = NULL;
int ret = 0, err; int ret = 0, err;
@ -100,19 +99,18 @@ static int tcf_skbedit_init(struct net *net, struct nlattr *nla,
parm = nla_data(tb[TCA_SKBEDIT_PARMS]); parm = nla_data(tb[TCA_SKBEDIT_PARMS]);
pc = tcf_hash_check(parm->index, a, bind); if (!tcf_hash_check(parm->index, a, bind)) {
if (!pc) { ret = tcf_hash_create(parm->index, est, a, sizeof(*d), bind);
pc = tcf_hash_create(parm->index, est, a, sizeof(*d), bind); if (ret)
if (IS_ERR(pc)) return ret;
return PTR_ERR(pc);
d = to_skbedit(pc); d = to_skbedit(a);
ret = ACT_P_CREATED; ret = ACT_P_CREATED;
} else { } else {
d = to_skbedit(pc); d = to_skbedit(a);
if (bind) if (bind)
return 0; return 0;
tcf_hash_release(pc, bind, a->ops->hinfo); tcf_hash_release(a, bind);
if (!ovr) if (!ovr)
return -EEXIST; return -EEXIST;
} }
@ -132,19 +130,10 @@ static int tcf_skbedit_init(struct net *net, struct nlattr *nla,
spin_unlock_bh(&d->tcf_lock); spin_unlock_bh(&d->tcf_lock);
if (ret == ACT_P_CREATED) if (ret == ACT_P_CREATED)
tcf_hash_insert(pc, a->ops->hinfo); tcf_hash_insert(a);
return ret; return ret;
} }
static int tcf_skbedit_cleanup(struct tc_action *a, int bind)
{
struct tcf_skbedit *d = a->priv;
if (d)
return tcf_hash_release(&d->common, bind, &skbedit_hash_info);
return 0;
}
static int tcf_skbedit_dump(struct sk_buff *skb, struct tc_action *a, static int tcf_skbedit_dump(struct sk_buff *skb, struct tc_action *a,
int bind, int ref) int bind, int ref)
{ {
@ -191,7 +180,7 @@ static struct tc_action_ops act_skbedit_ops = {
.owner = THIS_MODULE, .owner = THIS_MODULE,
.act = tcf_skbedit, .act = tcf_skbedit,
.dump = tcf_skbedit_dump, .dump = tcf_skbedit_dump,
.cleanup = tcf_skbedit_cleanup, .cleanup = tcf_hash_release,
.init = tcf_skbedit_init, .init = tcf_skbedit_init,
}; };