]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * net/sched/act_api.c Packet action API. | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or | |
5 | * modify it under the terms of the GNU General Public License | |
6 | * as published by the Free Software Foundation; either version | |
7 | * 2 of the License, or (at your option) any later version. | |
8 | * | |
9 | * Author: Jamal Hadi Salim | |
10 | * | |
11 | * | |
12 | */ | |
13 | ||
1da177e4 LT |
14 | #include <linux/types.h> |
15 | #include <linux/kernel.h> | |
1da177e4 | 16 | #include <linux/string.h> |
1da177e4 | 17 | #include <linux/errno.h> |
5a0e3ad6 | 18 | #include <linux/slab.h> |
1da177e4 | 19 | #include <linux/skbuff.h> |
1da177e4 LT |
20 | #include <linux/init.h> |
21 | #include <linux/kmod.h> | |
ab27cfb8 | 22 | #include <linux/err.h> |
3a9a231d | 23 | #include <linux/module.h> |
b3f55bdd JP |
24 | #include <linux/rhashtable.h> |
25 | #include <linux/list.h> | |
b854272b DL |
26 | #include <net/net_namespace.h> |
27 | #include <net/sock.h> | |
1da177e4 | 28 | #include <net/sch_generic.h> |
1045ba77 | 29 | #include <net/pkt_cls.h> |
1da177e4 | 30 | #include <net/act_api.h> |
dc5fc579 | 31 | #include <net/netlink.h> |
1da177e4 | 32 | |
db50514f JP |
33 | static int tcf_action_goto_chain_init(struct tc_action *a, struct tcf_proto *tp) |
34 | { | |
35 | u32 chain_index = a->tcfa_action & TC_ACT_EXT_VAL_MASK; | |
36 | ||
37 | if (!tp) | |
38 | return -EINVAL; | |
367a8ce8 | 39 | a->goto_chain = tcf_chain_get(tp->chain->block, chain_index, true); |
db50514f JP |
40 | if (!a->goto_chain) |
41 | return -ENOMEM; | |
42 | return 0; | |
43 | } | |
44 | ||
45 | static void tcf_action_goto_chain_fini(struct tc_action *a) | |
46 | { | |
47 | tcf_chain_put(a->goto_chain); | |
48 | } | |
49 | ||
50 | static void tcf_action_goto_chain_exec(const struct tc_action *a, | |
51 | struct tcf_result *res) | |
52 | { | |
53 | const struct tcf_chain *chain = a->goto_chain; | |
54 | ||
55 | res->goto_tp = rcu_dereference_bh(chain->filter_chain); | |
56 | } | |
57 | ||
d7fb60b9 CW |
58 | /* XXX: For standalone actions, we don't need a RCU grace period either, because |
59 | * actions are always connected to filters and filters are already destroyed in | |
60 | * RCU callbacks, so after a RCU grace period actions are already disconnected | |
61 | * from filters. Readers later can not find us. | |
62 | */ | |
63 | static void free_tcf(struct tc_action *p) | |
519c818e | 64 | { |
519c818e ED |
65 | free_percpu(p->cpu_bstats); |
66 | free_percpu(p->cpu_qstats); | |
1045ba77 JHS |
67 | |
68 | if (p->act_cookie) { | |
69 | kfree(p->act_cookie->data); | |
70 | kfree(p->act_cookie); | |
71 | } | |
db50514f JP |
72 | if (p->goto_chain) |
73 | tcf_action_goto_chain_fini(p); | |
1045ba77 | 74 | |
519c818e ED |
75 | kfree(p); |
76 | } | |
77 | ||
65a206c0 | 78 | static void tcf_idr_remove(struct tcf_idrinfo *idrinfo, struct tc_action *p) |
e9ce1cd3 | 79 | { |
65a206c0 CM |
80 | spin_lock_bh(&idrinfo->lock); |
81 | idr_remove_ext(&idrinfo->action_idr, p->tcfa_index); | |
82 | spin_unlock_bh(&idrinfo->lock); | |
1c0d32fd | 83 | gen_kill_estimator(&p->tcfa_rate_est); |
d7fb60b9 | 84 | free_tcf(p); |
e9ce1cd3 | 85 | } |
e9ce1cd3 | 86 | |
65a206c0 | 87 | int __tcf_idr_release(struct tc_action *p, bool bind, bool strict) |
e9ce1cd3 DM |
88 | { |
89 | int ret = 0; | |
90 | ||
a159d3c4 CW |
91 | ASSERT_RTNL(); |
92 | ||
e9ce1cd3 DM |
93 | if (p) { |
94 | if (bind) | |
ec0595cc WC |
95 | p->tcfa_bindcnt--; |
96 | else if (strict && p->tcfa_bindcnt > 0) | |
55334a5d | 97 | return -EPERM; |
e9ce1cd3 | 98 | |
ec0595cc WC |
99 | p->tcfa_refcnt--; |
100 | if (p->tcfa_bindcnt <= 0 && p->tcfa_refcnt <= 0) { | |
101 | if (p->ops->cleanup) | |
102 | p->ops->cleanup(p, bind); | |
65a206c0 | 103 | tcf_idr_remove(p->idrinfo, p); |
1d4150c0 | 104 | ret = ACT_P_DELETED; |
e9ce1cd3 DM |
105 | } |
106 | } | |
28e6b67f | 107 | |
e9ce1cd3 DM |
108 | return ret; |
109 | } | |
65a206c0 | 110 | EXPORT_SYMBOL(__tcf_idr_release); |
e9ce1cd3 | 111 | |
65a206c0 | 112 | static int tcf_dump_walker(struct tcf_idrinfo *idrinfo, struct sk_buff *skb, |
a85a970a | 113 | struct netlink_callback *cb) |
e9ce1cd3 | 114 | { |
65a206c0 | 115 | int err = 0, index = -1, s_i = 0, n_i = 0; |
90825b23 | 116 | u32 act_flags = cb->args[2]; |
e62e484d | 117 | unsigned long jiffy_since = cb->args[3]; |
4b3550ef | 118 | struct nlattr *nest; |
65a206c0 CM |
119 | struct idr *idr = &idrinfo->action_idr; |
120 | struct tc_action *p; | |
121 | unsigned long id = 1; | |
e9ce1cd3 | 122 | |
65a206c0 | 123 | spin_lock_bh(&idrinfo->lock); |
e9ce1cd3 DM |
124 | |
125 | s_i = cb->args[0]; | |
126 | ||
65a206c0 CM |
127 | idr_for_each_entry_ext(idr, p, id) { |
128 | index++; | |
129 | if (index < s_i) | |
130 | continue; | |
131 | ||
132 | if (jiffy_since && | |
133 | time_after(jiffy_since, | |
134 | (unsigned long)p->tcfa_tm.lastuse)) | |
135 | continue; | |
136 | ||
137 | nest = nla_nest_start(skb, n_i); | |
138 | if (!nest) | |
139 | goto nla_put_failure; | |
140 | err = tcf_action_dump_1(skb, p, 0, 0); | |
141 | if (err < 0) { | |
142 | index--; | |
143 | nlmsg_trim(skb, nest); | |
144 | goto done; | |
e9ce1cd3 | 145 | } |
65a206c0 CM |
146 | nla_nest_end(skb, nest); |
147 | n_i++; | |
148 | if (!(act_flags & TCA_FLAG_LARGE_DUMP_ON) && | |
149 | n_i >= TCA_ACT_MAX_PRIO) | |
150 | goto done; | |
e9ce1cd3 DM |
151 | } |
152 | done: | |
e62e484d JHS |
153 | if (index >= 0) |
154 | cb->args[0] = index + 1; | |
155 | ||
65a206c0 | 156 | spin_unlock_bh(&idrinfo->lock); |
90825b23 | 157 | if (n_i) { |
90825b23 JHS |
158 | if (act_flags & TCA_FLAG_LARGE_DUMP_ON) |
159 | cb->args[1] = n_i; | |
160 | } | |
e9ce1cd3 DM |
161 | return n_i; |
162 | ||
7ba699c6 | 163 | nla_put_failure: |
4b3550ef | 164 | nla_nest_cancel(skb, nest); |
e9ce1cd3 DM |
165 | goto done; |
166 | } | |
167 | ||
65a206c0 | 168 | static int tcf_del_walker(struct tcf_idrinfo *idrinfo, struct sk_buff *skb, |
a85a970a | 169 | const struct tc_action_ops *ops) |
e9ce1cd3 | 170 | { |
4b3550ef | 171 | struct nlattr *nest; |
65a206c0 | 172 | int n_i = 0; |
55334a5d | 173 | int ret = -EINVAL; |
65a206c0 CM |
174 | struct idr *idr = &idrinfo->action_idr; |
175 | struct tc_action *p; | |
176 | unsigned long id = 1; | |
e9ce1cd3 | 177 | |
a85a970a | 178 | nest = nla_nest_start(skb, 0); |
4b3550ef PM |
179 | if (nest == NULL) |
180 | goto nla_put_failure; | |
a85a970a | 181 | if (nla_put_string(skb, TCA_KIND, ops->kind)) |
1b34ec43 | 182 | goto nla_put_failure; |
65a206c0 CM |
183 | |
184 | idr_for_each_entry_ext(idr, p, id) { | |
185 | ret = __tcf_idr_release(p, false, true); | |
186 | if (ret == ACT_P_DELETED) { | |
255cd50f | 187 | module_put(ops->owner); |
65a206c0 CM |
188 | n_i++; |
189 | } else if (ret < 0) { | |
190 | goto nla_put_failure; | |
e9ce1cd3 DM |
191 | } |
192 | } | |
1b34ec43 DM |
193 | if (nla_put_u32(skb, TCA_FCNT, n_i)) |
194 | goto nla_put_failure; | |
4b3550ef | 195 | nla_nest_end(skb, nest); |
e9ce1cd3 DM |
196 | |
197 | return n_i; | |
7ba699c6 | 198 | nla_put_failure: |
4b3550ef | 199 | nla_nest_cancel(skb, nest); |
55334a5d | 200 | return ret; |
e9ce1cd3 DM |
201 | } |
202 | ||
ddf97ccd WC |
203 | int tcf_generic_walker(struct tc_action_net *tn, struct sk_buff *skb, |
204 | struct netlink_callback *cb, int type, | |
a85a970a | 205 | const struct tc_action_ops *ops) |
e9ce1cd3 | 206 | { |
65a206c0 | 207 | struct tcf_idrinfo *idrinfo = tn->idrinfo; |
ddf97ccd | 208 | |
e9ce1cd3 | 209 | if (type == RTM_DELACTION) { |
65a206c0 | 210 | return tcf_del_walker(idrinfo, skb, ops); |
e9ce1cd3 | 211 | } else if (type == RTM_GETACTION) { |
65a206c0 | 212 | return tcf_dump_walker(idrinfo, skb, cb); |
e9ce1cd3 | 213 | } else { |
6ff9c364 | 214 | WARN(1, "tcf_generic_walker: unknown action %d\n", type); |
e9ce1cd3 DM |
215 | return -EINVAL; |
216 | } | |
217 | } | |
ddf97ccd | 218 | EXPORT_SYMBOL(tcf_generic_walker); |
e9ce1cd3 | 219 | |
65a206c0 | 220 | static struct tc_action *tcf_idr_lookup(u32 index, struct tcf_idrinfo *idrinfo) |
e9ce1cd3 | 221 | { |
ec0595cc | 222 | struct tc_action *p = NULL; |
e9ce1cd3 | 223 | |
65a206c0 CM |
224 | spin_lock_bh(&idrinfo->lock); |
225 | p = idr_find_ext(&idrinfo->action_idr, index); | |
226 | spin_unlock_bh(&idrinfo->lock); | |
e9ce1cd3 DM |
227 | |
228 | return p; | |
229 | } | |
e9ce1cd3 | 230 | |
65a206c0 | 231 | int tcf_idr_search(struct tc_action_net *tn, struct tc_action **a, u32 index) |
e9ce1cd3 | 232 | { |
65a206c0 CM |
233 | struct tcf_idrinfo *idrinfo = tn->idrinfo; |
234 | struct tc_action *p = tcf_idr_lookup(index, idrinfo); | |
e9ce1cd3 DM |
235 | |
236 | if (p) { | |
ec0595cc | 237 | *a = p; |
e9ce1cd3 DM |
238 | return 1; |
239 | } | |
240 | return 0; | |
241 | } | |
65a206c0 | 242 | EXPORT_SYMBOL(tcf_idr_search); |
e9ce1cd3 | 243 | |
65a206c0 CM |
244 | bool tcf_idr_check(struct tc_action_net *tn, u32 index, struct tc_action **a, |
245 | int bind) | |
e9ce1cd3 | 246 | { |
65a206c0 CM |
247 | struct tcf_idrinfo *idrinfo = tn->idrinfo; |
248 | struct tc_action *p = tcf_idr_lookup(index, idrinfo); | |
ec0595cc | 249 | |
65a206c0 | 250 | if (index && p) { |
76aab2c1 | 251 | if (bind) |
ec0595cc WC |
252 | p->tcfa_bindcnt++; |
253 | p->tcfa_refcnt++; | |
254 | *a = p; | |
b2313077 | 255 | return true; |
e9ce1cd3 | 256 | } |
b2313077 | 257 | return false; |
e9ce1cd3 | 258 | } |
65a206c0 | 259 | EXPORT_SYMBOL(tcf_idr_check); |
e9ce1cd3 | 260 | |
65a206c0 | 261 | void tcf_idr_cleanup(struct tc_action *a, struct nlattr *est) |
86062033 | 262 | { |
86062033 | 263 | if (est) |
1c0d32fd | 264 | gen_kill_estimator(&a->tcfa_rate_est); |
d7fb60b9 | 265 | free_tcf(a); |
86062033 | 266 | } |
65a206c0 | 267 | EXPORT_SYMBOL(tcf_idr_cleanup); |
86062033 | 268 | |
65a206c0 CM |
269 | int tcf_idr_create(struct tc_action_net *tn, u32 index, struct nlattr *est, |
270 | struct tc_action **a, const struct tc_action_ops *ops, | |
271 | int bind, bool cpustats) | |
e9ce1cd3 | 272 | { |
ec0595cc | 273 | struct tc_action *p = kzalloc(ops->size, GFP_KERNEL); |
65a206c0 CM |
274 | struct tcf_idrinfo *idrinfo = tn->idrinfo; |
275 | struct idr *idr = &idrinfo->action_idr; | |
519c818e | 276 | int err = -ENOMEM; |
65a206c0 | 277 | unsigned long idr_index; |
e9ce1cd3 DM |
278 | |
279 | if (unlikely(!p)) | |
86062033 | 280 | return -ENOMEM; |
ec0595cc | 281 | p->tcfa_refcnt = 1; |
e9ce1cd3 | 282 | if (bind) |
ec0595cc | 283 | p->tcfa_bindcnt = 1; |
e9ce1cd3 | 284 | |
519c818e ED |
285 | if (cpustats) { |
286 | p->cpu_bstats = netdev_alloc_pcpu_stats(struct gnet_stats_basic_cpu); | |
287 | if (!p->cpu_bstats) { | |
288 | err1: | |
289 | kfree(p); | |
290 | return err; | |
291 | } | |
292 | p->cpu_qstats = alloc_percpu(struct gnet_stats_queue); | |
293 | if (!p->cpu_qstats) { | |
294 | err2: | |
295 | free_percpu(p->cpu_bstats); | |
296 | goto err1; | |
297 | } | |
298 | } | |
ec0595cc | 299 | spin_lock_init(&p->tcfa_lock); |
65a206c0 CM |
300 | /* user doesn't specify an index */ |
301 | if (!index) { | |
2c8468dc | 302 | idr_preload(GFP_KERNEL); |
65a206c0 CM |
303 | spin_lock_bh(&idrinfo->lock); |
304 | err = idr_alloc_ext(idr, NULL, &idr_index, 1, 0, | |
2c8468dc | 305 | GFP_ATOMIC); |
65a206c0 | 306 | spin_unlock_bh(&idrinfo->lock); |
2c8468dc | 307 | idr_preload_end(); |
65a206c0 CM |
308 | if (err) { |
309 | err3: | |
310 | free_percpu(p->cpu_qstats); | |
311 | goto err2; | |
312 | } | |
313 | p->tcfa_index = idr_index; | |
314 | } else { | |
2c8468dc | 315 | idr_preload(GFP_KERNEL); |
65a206c0 CM |
316 | spin_lock_bh(&idrinfo->lock); |
317 | err = idr_alloc_ext(idr, NULL, NULL, index, index + 1, | |
2c8468dc | 318 | GFP_ATOMIC); |
65a206c0 | 319 | spin_unlock_bh(&idrinfo->lock); |
2c8468dc | 320 | idr_preload_end(); |
65a206c0 CM |
321 | if (err) |
322 | goto err3; | |
323 | p->tcfa_index = index; | |
324 | } | |
325 | ||
ec0595cc WC |
326 | p->tcfa_tm.install = jiffies; |
327 | p->tcfa_tm.lastuse = jiffies; | |
328 | p->tcfa_tm.firstuse = 0; | |
0e991ec6 | 329 | if (est) { |
ec0595cc WC |
330 | err = gen_new_estimator(&p->tcfa_bstats, p->cpu_bstats, |
331 | &p->tcfa_rate_est, | |
332 | &p->tcfa_lock, NULL, est); | |
0e991ec6 | 333 | if (err) { |
65a206c0 | 334 | goto err3; |
0e991ec6 SH |
335 | } |
336 | } | |
337 | ||
65a206c0 | 338 | p->idrinfo = idrinfo; |
ec0595cc WC |
339 | p->ops = ops; |
340 | INIT_LIST_HEAD(&p->list); | |
341 | *a = p; | |
86062033 | 342 | return 0; |
e9ce1cd3 | 343 | } |
65a206c0 | 344 | EXPORT_SYMBOL(tcf_idr_create); |
e9ce1cd3 | 345 | |
65a206c0 | 346 | void tcf_idr_insert(struct tc_action_net *tn, struct tc_action *a) |
e9ce1cd3 | 347 | { |
65a206c0 | 348 | struct tcf_idrinfo *idrinfo = tn->idrinfo; |
e9ce1cd3 | 349 | |
65a206c0 CM |
350 | spin_lock_bh(&idrinfo->lock); |
351 | idr_replace_ext(&idrinfo->action_idr, a, a->tcfa_index); | |
352 | spin_unlock_bh(&idrinfo->lock); | |
e9ce1cd3 | 353 | } |
65a206c0 | 354 | EXPORT_SYMBOL(tcf_idr_insert); |
1da177e4 | 355 | |
65a206c0 CM |
356 | void tcf_idrinfo_destroy(const struct tc_action_ops *ops, |
357 | struct tcf_idrinfo *idrinfo) | |
1d4150c0 | 358 | { |
65a206c0 CM |
359 | struct idr *idr = &idrinfo->action_idr; |
360 | struct tc_action *p; | |
361 | int ret; | |
362 | unsigned long id = 1; | |
1d4150c0 | 363 | |
65a206c0 CM |
364 | idr_for_each_entry_ext(idr, p, id) { |
365 | ret = __tcf_idr_release(p, false, true); | |
366 | if (ret == ACT_P_DELETED) | |
367 | module_put(ops->owner); | |
368 | else if (ret < 0) | |
369 | return; | |
1d4150c0 | 370 | } |
65a206c0 | 371 | idr_destroy(&idrinfo->action_idr); |
1d4150c0 | 372 | } |
65a206c0 | 373 | EXPORT_SYMBOL(tcf_idrinfo_destroy); |
1d4150c0 | 374 | |
1f747c26 | 375 | static LIST_HEAD(act_base); |
1da177e4 LT |
376 | static DEFINE_RWLOCK(act_mod_lock); |
377 | ||
ddf97ccd WC |
378 | int tcf_register_action(struct tc_action_ops *act, |
379 | struct pernet_operations *ops) | |
1da177e4 | 380 | { |
1f747c26 | 381 | struct tc_action_ops *a; |
ddf97ccd | 382 | int ret; |
1da177e4 | 383 | |
ddf97ccd | 384 | if (!act->act || !act->dump || !act->init || !act->walk || !act->lookup) |
76c82d7a JHS |
385 | return -EINVAL; |
386 | ||
ab102b80 WC |
387 | /* We have to register pernet ops before making the action ops visible, |
388 | * otherwise tcf_action_init_1() could get a partially initialized | |
389 | * netns. | |
390 | */ | |
391 | ret = register_pernet_subsys(ops); | |
392 | if (ret) | |
393 | return ret; | |
394 | ||
1da177e4 | 395 | write_lock(&act_mod_lock); |
1f747c26 | 396 | list_for_each_entry(a, &act_base, head) { |
1da177e4 LT |
397 | if (act->type == a->type || (strcmp(act->kind, a->kind) == 0)) { |
398 | write_unlock(&act_mod_lock); | |
ab102b80 | 399 | unregister_pernet_subsys(ops); |
1da177e4 LT |
400 | return -EEXIST; |
401 | } | |
402 | } | |
1f747c26 | 403 | list_add_tail(&act->head, &act_base); |
1da177e4 | 404 | write_unlock(&act_mod_lock); |
ddf97ccd | 405 | |
1da177e4 LT |
406 | return 0; |
407 | } | |
62e3ba1b | 408 | EXPORT_SYMBOL(tcf_register_action); |
1da177e4 | 409 | |
ddf97ccd WC |
410 | int tcf_unregister_action(struct tc_action_ops *act, |
411 | struct pernet_operations *ops) | |
1da177e4 | 412 | { |
1f747c26 | 413 | struct tc_action_ops *a; |
1da177e4 LT |
414 | int err = -ENOENT; |
415 | ||
416 | write_lock(&act_mod_lock); | |
a792866a ED |
417 | list_for_each_entry(a, &act_base, head) { |
418 | if (a == act) { | |
419 | list_del(&act->head); | |
420 | err = 0; | |
1da177e4 | 421 | break; |
a792866a | 422 | } |
1da177e4 LT |
423 | } |
424 | write_unlock(&act_mod_lock); | |
ab102b80 WC |
425 | if (!err) |
426 | unregister_pernet_subsys(ops); | |
1da177e4 LT |
427 | return err; |
428 | } | |
62e3ba1b | 429 | EXPORT_SYMBOL(tcf_unregister_action); |
1da177e4 LT |
430 | |
431 | /* lookup by name */ | |
432 | static struct tc_action_ops *tc_lookup_action_n(char *kind) | |
433 | { | |
a792866a | 434 | struct tc_action_ops *a, *res = NULL; |
1da177e4 LT |
435 | |
436 | if (kind) { | |
437 | read_lock(&act_mod_lock); | |
1f747c26 | 438 | list_for_each_entry(a, &act_base, head) { |
1da177e4 | 439 | if (strcmp(kind, a->kind) == 0) { |
a792866a ED |
440 | if (try_module_get(a->owner)) |
441 | res = a; | |
1da177e4 LT |
442 | break; |
443 | } | |
444 | } | |
445 | read_unlock(&act_mod_lock); | |
446 | } | |
a792866a | 447 | return res; |
1da177e4 LT |
448 | } |
449 | ||
7ba699c6 PM |
450 | /* lookup by nlattr */ |
451 | static struct tc_action_ops *tc_lookup_action(struct nlattr *kind) | |
1da177e4 | 452 | { |
a792866a | 453 | struct tc_action_ops *a, *res = NULL; |
1da177e4 LT |
454 | |
455 | if (kind) { | |
456 | read_lock(&act_mod_lock); | |
1f747c26 | 457 | list_for_each_entry(a, &act_base, head) { |
7ba699c6 | 458 | if (nla_strcmp(kind, a->kind) == 0) { |
a792866a ED |
459 | if (try_module_get(a->owner)) |
460 | res = a; | |
1da177e4 LT |
461 | break; |
462 | } | |
463 | } | |
464 | read_unlock(&act_mod_lock); | |
465 | } | |
a792866a | 466 | return res; |
1da177e4 | 467 | } |
1da177e4 | 468 | |
e0ee84de JHS |
469 | /*TCA_ACT_MAX_PRIO is 32, there count upto 32 */ |
470 | #define TCA_ACT_MAX_PRIO_MASK 0x1FF | |
22dc13c8 WC |
471 | int tcf_action_exec(struct sk_buff *skb, struct tc_action **actions, |
472 | int nr_actions, struct tcf_result *res) | |
1da177e4 | 473 | { |
e0ee84de JHS |
474 | u32 jmp_prgcnt = 0; |
475 | u32 jmp_ttl = TCA_ACT_MAX_PRIO; /*matches actions per filter */ | |
ec1a9cca JP |
476 | int i; |
477 | int ret = TC_ACT_OK; | |
1da177e4 | 478 | |
e7246e12 WB |
479 | if (skb_skip_tc_classify(skb)) |
480 | return TC_ACT_OK; | |
481 | ||
e0ee84de | 482 | restart_act_graph: |
22dc13c8 WC |
483 | for (i = 0; i < nr_actions; i++) { |
484 | const struct tc_action *a = actions[i]; | |
485 | ||
e0ee84de JHS |
486 | if (jmp_prgcnt > 0) { |
487 | jmp_prgcnt -= 1; | |
488 | continue; | |
489 | } | |
1da177e4 | 490 | repeat: |
63acd680 | 491 | ret = a->ops->act(skb, a, res); |
63acd680 JHS |
492 | if (ret == TC_ACT_REPEAT) |
493 | goto repeat; /* we need a ttl - JHS */ | |
e0ee84de | 494 | |
9da3242e | 495 | if (TC_ACT_EXT_CMP(ret, TC_ACT_JUMP)) { |
e0ee84de JHS |
496 | jmp_prgcnt = ret & TCA_ACT_MAX_PRIO_MASK; |
497 | if (!jmp_prgcnt || (jmp_prgcnt > nr_actions)) { | |
498 | /* faulty opcode, stop pipeline */ | |
499 | return TC_ACT_OK; | |
500 | } else { | |
501 | jmp_ttl -= 1; | |
502 | if (jmp_ttl > 0) | |
503 | goto restart_act_graph; | |
504 | else /* faulty graph, stop pipeline */ | |
505 | return TC_ACT_OK; | |
506 | } | |
db50514f JP |
507 | } else if (TC_ACT_EXT_CMP(ret, TC_ACT_GOTO_CHAIN)) { |
508 | tcf_action_goto_chain_exec(a, res); | |
e0ee84de JHS |
509 | } |
510 | ||
63acd680 | 511 | if (ret != TC_ACT_PIPE) |
e7246e12 | 512 | break; |
1da177e4 | 513 | } |
e0ee84de | 514 | |
1da177e4 LT |
515 | return ret; |
516 | } | |
62e3ba1b | 517 | EXPORT_SYMBOL(tcf_action_exec); |
1da177e4 | 518 | |
55334a5d | 519 | int tcf_action_destroy(struct list_head *actions, int bind) |
1da177e4 | 520 | { |
255cd50f | 521 | const struct tc_action_ops *ops; |
33be6271 | 522 | struct tc_action *a, *tmp; |
55334a5d | 523 | int ret = 0; |
1da177e4 | 524 | |
33be6271 | 525 | list_for_each_entry_safe(a, tmp, actions, list) { |
255cd50f | 526 | ops = a->ops; |
65a206c0 | 527 | ret = __tcf_idr_release(a, bind, true); |
55334a5d | 528 | if (ret == ACT_P_DELETED) |
255cd50f | 529 | module_put(ops->owner); |
55334a5d WC |
530 | else if (ret < 0) |
531 | return ret; | |
1da177e4 | 532 | } |
55334a5d | 533 | return ret; |
1da177e4 LT |
534 | } |
535 | ||
536 | int | |
537 | tcf_action_dump_old(struct sk_buff *skb, struct tc_action *a, int bind, int ref) | |
538 | { | |
1da177e4 LT |
539 | return a->ops->dump(skb, a, bind, ref); |
540 | } | |
541 | ||
542 | int | |
543 | tcf_action_dump_1(struct sk_buff *skb, struct tc_action *a, int bind, int ref) | |
544 | { | |
545 | int err = -EINVAL; | |
27a884dc | 546 | unsigned char *b = skb_tail_pointer(skb); |
4b3550ef | 547 | struct nlattr *nest; |
1da177e4 | 548 | |
1b34ec43 DM |
549 | if (nla_put_string(skb, TCA_KIND, a->ops->kind)) |
550 | goto nla_put_failure; | |
1da177e4 | 551 | if (tcf_action_copy_stats(skb, a, 0)) |
7ba699c6 | 552 | goto nla_put_failure; |
1045ba77 JHS |
553 | if (a->act_cookie) { |
554 | if (nla_put(skb, TCA_ACT_COOKIE, a->act_cookie->len, | |
555 | a->act_cookie->data)) | |
556 | goto nla_put_failure; | |
557 | } | |
558 | ||
4b3550ef PM |
559 | nest = nla_nest_start(skb, TCA_OPTIONS); |
560 | if (nest == NULL) | |
561 | goto nla_put_failure; | |
cc7ec456 ED |
562 | err = tcf_action_dump_old(skb, a, bind, ref); |
563 | if (err > 0) { | |
4b3550ef | 564 | nla_nest_end(skb, nest); |
1da177e4 LT |
565 | return err; |
566 | } | |
567 | ||
7ba699c6 | 568 | nla_put_failure: |
dc5fc579 | 569 | nlmsg_trim(skb, b); |
1da177e4 LT |
570 | return -1; |
571 | } | |
62e3ba1b | 572 | EXPORT_SYMBOL(tcf_action_dump_1); |
1da177e4 | 573 | |
0b0f43fe JHS |
574 | int tcf_action_dump(struct sk_buff *skb, struct list_head *actions, |
575 | int bind, int ref) | |
1da177e4 LT |
576 | { |
577 | struct tc_action *a; | |
578 | int err = -EINVAL; | |
4b3550ef | 579 | struct nlattr *nest; |
1da177e4 | 580 | |
33be6271 | 581 | list_for_each_entry(a, actions, list) { |
4b3550ef PM |
582 | nest = nla_nest_start(skb, a->order); |
583 | if (nest == NULL) | |
584 | goto nla_put_failure; | |
1da177e4 LT |
585 | err = tcf_action_dump_1(skb, a, bind, ref); |
586 | if (err < 0) | |
4fe683f5 | 587 | goto errout; |
4b3550ef | 588 | nla_nest_end(skb, nest); |
1da177e4 LT |
589 | } |
590 | ||
591 | return 0; | |
592 | ||
7ba699c6 | 593 | nla_put_failure: |
4fe683f5 TG |
594 | err = -EINVAL; |
595 | errout: | |
4b3550ef | 596 | nla_nest_cancel(skb, nest); |
4fe683f5 | 597 | return err; |
1da177e4 LT |
598 | } |
599 | ||
e0535ce5 | 600 | static struct tc_cookie *nla_memdup_cookie(struct nlattr **tb) |
1045ba77 | 601 | { |
e0535ce5 WB |
602 | struct tc_cookie *c = kzalloc(sizeof(*c), GFP_KERNEL); |
603 | if (!c) | |
604 | return NULL; | |
605 | ||
606 | c->data = nla_memdup(tb[TCA_ACT_COOKIE], GFP_KERNEL); | |
607 | if (!c->data) { | |
608 | kfree(c); | |
609 | return NULL; | |
1045ba77 | 610 | } |
e0535ce5 | 611 | c->len = nla_len(tb[TCA_ACT_COOKIE]); |
1045ba77 | 612 | |
e0535ce5 | 613 | return c; |
1045ba77 JHS |
614 | } |
615 | ||
9fb9f251 JP |
616 | struct tc_action *tcf_action_init_1(struct net *net, struct tcf_proto *tp, |
617 | struct nlattr *nla, struct nlattr *est, | |
618 | char *name, int ovr, int bind) | |
1da177e4 LT |
619 | { |
620 | struct tc_action *a; | |
621 | struct tc_action_ops *a_o; | |
e0535ce5 | 622 | struct tc_cookie *cookie = NULL; |
1da177e4 | 623 | char act_name[IFNAMSIZ]; |
cc7ec456 | 624 | struct nlattr *tb[TCA_ACT_MAX + 1]; |
7ba699c6 | 625 | struct nlattr *kind; |
ab27cfb8 | 626 | int err; |
1da177e4 | 627 | |
1da177e4 | 628 | if (name == NULL) { |
fceb6435 | 629 | err = nla_parse_nested(tb, TCA_ACT_MAX, nla, NULL, NULL); |
cee63723 | 630 | if (err < 0) |
1da177e4 | 631 | goto err_out; |
cee63723 | 632 | err = -EINVAL; |
7ba699c6 | 633 | kind = tb[TCA_ACT_KIND]; |
1da177e4 LT |
634 | if (kind == NULL) |
635 | goto err_out; | |
7ba699c6 | 636 | if (nla_strlcpy(act_name, kind, IFNAMSIZ) >= IFNAMSIZ) |
1da177e4 | 637 | goto err_out; |
e0535ce5 WB |
638 | if (tb[TCA_ACT_COOKIE]) { |
639 | int cklen = nla_len(tb[TCA_ACT_COOKIE]); | |
640 | ||
641 | if (cklen > TC_COOKIE_MAX_SIZE) | |
642 | goto err_out; | |
643 | ||
644 | cookie = nla_memdup_cookie(tb); | |
645 | if (!cookie) { | |
646 | err = -ENOMEM; | |
647 | goto err_out; | |
648 | } | |
649 | } | |
1da177e4 | 650 | } else { |
cee63723 | 651 | err = -EINVAL; |
1da177e4 LT |
652 | if (strlcpy(act_name, name, IFNAMSIZ) >= IFNAMSIZ) |
653 | goto err_out; | |
654 | } | |
655 | ||
656 | a_o = tc_lookup_action_n(act_name); | |
657 | if (a_o == NULL) { | |
95a5afca | 658 | #ifdef CONFIG_MODULES |
1da177e4 | 659 | rtnl_unlock(); |
4bba3925 | 660 | request_module("act_%s", act_name); |
1da177e4 LT |
661 | rtnl_lock(); |
662 | ||
663 | a_o = tc_lookup_action_n(act_name); | |
664 | ||
665 | /* We dropped the RTNL semaphore in order to | |
666 | * perform the module load. So, even if we | |
667 | * succeeded in loading the module we have to | |
668 | * tell the caller to replay the request. We | |
669 | * indicate this using -EAGAIN. | |
670 | */ | |
671 | if (a_o != NULL) { | |
ab27cfb8 | 672 | err = -EAGAIN; |
1da177e4 LT |
673 | goto err_mod; |
674 | } | |
675 | #endif | |
ab27cfb8 | 676 | err = -ENOENT; |
1da177e4 LT |
677 | goto err_out; |
678 | } | |
679 | ||
1da177e4 LT |
680 | /* backward compatibility for policer */ |
681 | if (name == NULL) | |
a85a970a | 682 | err = a_o->init(net, tb[TCA_ACT_OPTIONS], est, &a, ovr, bind); |
1da177e4 | 683 | else |
a85a970a | 684 | err = a_o->init(net, nla, est, &a, ovr, bind); |
ab27cfb8 | 685 | if (err < 0) |
a85a970a | 686 | goto err_mod; |
1da177e4 | 687 | |
e0535ce5 WB |
688 | if (name == NULL && tb[TCA_ACT_COOKIE]) { |
689 | if (a->act_cookie) { | |
690 | kfree(a->act_cookie->data); | |
691 | kfree(a->act_cookie); | |
1045ba77 | 692 | } |
e0535ce5 | 693 | a->act_cookie = cookie; |
1045ba77 JHS |
694 | } |
695 | ||
1da177e4 | 696 | /* module count goes up only when brand new policy is created |
cc7ec456 ED |
697 | * if it exists and is only bound to in a_o->init() then |
698 | * ACT_P_CREATED is not returned (a zero is). | |
699 | */ | |
ab27cfb8 | 700 | if (err != ACT_P_CREATED) |
1da177e4 | 701 | module_put(a_o->owner); |
1da177e4 | 702 | |
db50514f JP |
703 | if (TC_ACT_EXT_CMP(a->tcfa_action, TC_ACT_GOTO_CHAIN)) { |
704 | err = tcf_action_goto_chain_init(a, tp); | |
705 | if (err) { | |
706 | LIST_HEAD(actions); | |
707 | ||
708 | list_add_tail(&a->list, &actions); | |
709 | tcf_action_destroy(&actions, bind); | |
710 | return ERR_PTR(err); | |
711 | } | |
712 | } | |
713 | ||
1da177e4 LT |
714 | return a; |
715 | ||
1da177e4 LT |
716 | err_mod: |
717 | module_put(a_o->owner); | |
718 | err_out: | |
e0535ce5 WB |
719 | if (cookie) { |
720 | kfree(cookie->data); | |
721 | kfree(cookie); | |
722 | } | |
ab27cfb8 | 723 | return ERR_PTR(err); |
1da177e4 LT |
724 | } |
725 | ||
aecc5cef JHS |
726 | static void cleanup_a(struct list_head *actions, int ovr) |
727 | { | |
728 | struct tc_action *a; | |
729 | ||
730 | if (!ovr) | |
731 | return; | |
732 | ||
733 | list_for_each_entry(a, actions, list) | |
734 | a->tcfa_refcnt--; | |
735 | } | |
736 | ||
9fb9f251 JP |
737 | int tcf_action_init(struct net *net, struct tcf_proto *tp, struct nlattr *nla, |
738 | struct nlattr *est, char *name, int ovr, int bind, | |
739 | struct list_head *actions) | |
1da177e4 | 740 | { |
cc7ec456 | 741 | struct nlattr *tb[TCA_ACT_MAX_PRIO + 1]; |
33be6271 | 742 | struct tc_action *act; |
cee63723 | 743 | int err; |
1da177e4 LT |
744 | int i; |
745 | ||
fceb6435 | 746 | err = nla_parse_nested(tb, TCA_ACT_MAX_PRIO, nla, NULL, NULL); |
cee63723 | 747 | if (err < 0) |
33be6271 | 748 | return err; |
1da177e4 | 749 | |
7ba699c6 | 750 | for (i = 1; i <= TCA_ACT_MAX_PRIO && tb[i]; i++) { |
9fb9f251 | 751 | act = tcf_action_init_1(net, tp, tb[i], est, name, ovr, bind); |
33be6271 WC |
752 | if (IS_ERR(act)) { |
753 | err = PTR_ERR(act); | |
1da177e4 | 754 | goto err; |
33be6271 | 755 | } |
7ba699c6 | 756 | act->order = i; |
aecc5cef JHS |
757 | if (ovr) |
758 | act->tcfa_refcnt++; | |
33be6271 | 759 | list_add_tail(&act->list, actions); |
1da177e4 | 760 | } |
aecc5cef JHS |
761 | |
762 | /* Remove the temp refcnt which was necessary to protect against | |
763 | * destroying an existing action which was being replaced | |
764 | */ | |
765 | cleanup_a(actions, ovr); | |
33be6271 | 766 | return 0; |
1da177e4 LT |
767 | |
768 | err: | |
33be6271 WC |
769 | tcf_action_destroy(actions, bind); |
770 | return err; | |
1da177e4 LT |
771 | } |
772 | ||
ec0595cc | 773 | int tcf_action_copy_stats(struct sk_buff *skb, struct tc_action *p, |
1da177e4 LT |
774 | int compat_mode) |
775 | { | |
776 | int err = 0; | |
777 | struct gnet_dump d; | |
10297b99 | 778 | |
7eb8896d | 779 | if (p == NULL) |
1da177e4 LT |
780 | goto errout; |
781 | ||
782 | /* compat_mode being true specifies a call that is supposed | |
06fe9fb4 | 783 | * to add additional backward compatibility statistic TLVs. |
1da177e4 LT |
784 | */ |
785 | if (compat_mode) { | |
ec0595cc | 786 | if (p->type == TCA_OLD_COMPAT) |
1da177e4 | 787 | err = gnet_stats_start_copy_compat(skb, 0, |
9854518e ND |
788 | TCA_STATS, |
789 | TCA_XSTATS, | |
ec0595cc | 790 | &p->tcfa_lock, &d, |
9854518e | 791 | TCA_PAD); |
1da177e4 LT |
792 | else |
793 | return 0; | |
794 | } else | |
795 | err = gnet_stats_start_copy(skb, TCA_ACT_STATS, | |
ec0595cc | 796 | &p->tcfa_lock, &d, TCA_ACT_PAD); |
1da177e4 LT |
797 | |
798 | if (err < 0) | |
799 | goto errout; | |
800 | ||
ec0595cc | 801 | if (gnet_stats_copy_basic(NULL, &d, p->cpu_bstats, &p->tcfa_bstats) < 0 || |
1c0d32fd | 802 | gnet_stats_copy_rate_est(&d, &p->tcfa_rate_est) < 0 || |
519c818e | 803 | gnet_stats_copy_queue(&d, p->cpu_qstats, |
ec0595cc WC |
804 | &p->tcfa_qstats, |
805 | p->tcfa_qstats.qlen) < 0) | |
1da177e4 LT |
806 | goto errout; |
807 | ||
808 | if (gnet_stats_finish_copy(&d) < 0) | |
809 | goto errout; | |
810 | ||
811 | return 0; | |
812 | ||
813 | errout: | |
814 | return -1; | |
815 | } | |
816 | ||
0b0f43fe JHS |
817 | static int tca_get_fill(struct sk_buff *skb, struct list_head *actions, |
818 | u32 portid, u32 seq, u16 flags, int event, int bind, | |
819 | int ref) | |
1da177e4 LT |
820 | { |
821 | struct tcamsg *t; | |
822 | struct nlmsghdr *nlh; | |
27a884dc | 823 | unsigned char *b = skb_tail_pointer(skb); |
4b3550ef | 824 | struct nlattr *nest; |
1da177e4 | 825 | |
15e47304 | 826 | nlh = nlmsg_put(skb, portid, seq, event, sizeof(*t), flags); |
8b00a53c DM |
827 | if (!nlh) |
828 | goto out_nlmsg_trim; | |
829 | t = nlmsg_data(nlh); | |
1da177e4 | 830 | t->tca_family = AF_UNSPEC; |
9ef1d4c7 PM |
831 | t->tca__pad1 = 0; |
832 | t->tca__pad2 = 0; | |
10297b99 | 833 | |
4b3550ef PM |
834 | nest = nla_nest_start(skb, TCA_ACT_TAB); |
835 | if (nest == NULL) | |
8b00a53c | 836 | goto out_nlmsg_trim; |
1da177e4 | 837 | |
33be6271 | 838 | if (tcf_action_dump(skb, actions, bind, ref) < 0) |
8b00a53c | 839 | goto out_nlmsg_trim; |
1da177e4 | 840 | |
4b3550ef | 841 | nla_nest_end(skb, nest); |
10297b99 | 842 | |
27a884dc | 843 | nlh->nlmsg_len = skb_tail_pointer(skb) - b; |
1da177e4 LT |
844 | return skb->len; |
845 | ||
8b00a53c | 846 | out_nlmsg_trim: |
dc5fc579 | 847 | nlmsg_trim(skb, b); |
1da177e4 LT |
848 | return -1; |
849 | } | |
850 | ||
851 | static int | |
c4c4290c | 852 | tcf_get_notify(struct net *net, u32 portid, struct nlmsghdr *n, |
33be6271 | 853 | struct list_head *actions, int event) |
1da177e4 LT |
854 | { |
855 | struct sk_buff *skb; | |
1da177e4 LT |
856 | |
857 | skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL); | |
858 | if (!skb) | |
859 | return -ENOBUFS; | |
0b0f43fe JHS |
860 | if (tca_get_fill(skb, actions, portid, n->nlmsg_seq, 0, event, |
861 | 0, 0) <= 0) { | |
1da177e4 LT |
862 | kfree_skb(skb); |
863 | return -EINVAL; | |
864 | } | |
2942e900 | 865 | |
15e47304 | 866 | return rtnl_unicast(skb, net, portid); |
1da177e4 LT |
867 | } |
868 | ||
ddf97ccd WC |
869 | static struct tc_action *tcf_action_get_1(struct net *net, struct nlattr *nla, |
870 | struct nlmsghdr *n, u32 portid) | |
1da177e4 | 871 | { |
cc7ec456 | 872 | struct nlattr *tb[TCA_ACT_MAX + 1]; |
a85a970a | 873 | const struct tc_action_ops *ops; |
1da177e4 LT |
874 | struct tc_action *a; |
875 | int index; | |
ab27cfb8 | 876 | int err; |
1da177e4 | 877 | |
fceb6435 | 878 | err = nla_parse_nested(tb, TCA_ACT_MAX, nla, NULL, NULL); |
cee63723 | 879 | if (err < 0) |
ab27cfb8 | 880 | goto err_out; |
1da177e4 | 881 | |
cee63723 | 882 | err = -EINVAL; |
7ba699c6 PM |
883 | if (tb[TCA_ACT_INDEX] == NULL || |
884 | nla_len(tb[TCA_ACT_INDEX]) < sizeof(index)) | |
ab27cfb8 | 885 | goto err_out; |
1587bac4 | 886 | index = nla_get_u32(tb[TCA_ACT_INDEX]); |
1da177e4 | 887 | |
ab27cfb8 | 888 | err = -EINVAL; |
a85a970a WC |
889 | ops = tc_lookup_action(tb[TCA_ACT_KIND]); |
890 | if (!ops) /* could happen in batch of actions */ | |
891 | goto err_out; | |
ab27cfb8 | 892 | err = -ENOENT; |
a85a970a | 893 | if (ops->lookup(net, &a, index) == 0) |
1da177e4 LT |
894 | goto err_mod; |
895 | ||
a85a970a | 896 | module_put(ops->owner); |
1da177e4 | 897 | return a; |
ab27cfb8 | 898 | |
1da177e4 | 899 | err_mod: |
a85a970a | 900 | module_put(ops->owner); |
ab27cfb8 PM |
901 | err_out: |
902 | return ERR_PTR(err); | |
1da177e4 LT |
903 | } |
904 | ||
7316ae88 | 905 | static int tca_action_flush(struct net *net, struct nlattr *nla, |
15e47304 | 906 | struct nlmsghdr *n, u32 portid) |
1da177e4 LT |
907 | { |
908 | struct sk_buff *skb; | |
909 | unsigned char *b; | |
910 | struct nlmsghdr *nlh; | |
911 | struct tcamsg *t; | |
912 | struct netlink_callback dcb; | |
4b3550ef | 913 | struct nlattr *nest; |
cc7ec456 | 914 | struct nlattr *tb[TCA_ACT_MAX + 1]; |
a85a970a | 915 | const struct tc_action_ops *ops; |
7ba699c6 | 916 | struct nlattr *kind; |
36723873 | 917 | int err = -ENOMEM; |
1da177e4 | 918 | |
1da177e4 LT |
919 | skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL); |
920 | if (!skb) { | |
6ff9c364 | 921 | pr_debug("tca_action_flush: failed skb alloc\n"); |
36723873 | 922 | return err; |
1da177e4 LT |
923 | } |
924 | ||
27a884dc | 925 | b = skb_tail_pointer(skb); |
1da177e4 | 926 | |
fceb6435 | 927 | err = nla_parse_nested(tb, TCA_ACT_MAX, nla, NULL, NULL); |
cee63723 | 928 | if (err < 0) |
1da177e4 LT |
929 | goto err_out; |
930 | ||
cee63723 | 931 | err = -EINVAL; |
7ba699c6 | 932 | kind = tb[TCA_ACT_KIND]; |
a85a970a WC |
933 | ops = tc_lookup_action(kind); |
934 | if (!ops) /*some idjot trying to flush unknown action */ | |
1da177e4 LT |
935 | goto err_out; |
936 | ||
0b0f43fe JHS |
937 | nlh = nlmsg_put(skb, portid, n->nlmsg_seq, RTM_DELACTION, |
938 | sizeof(*t), 0); | |
8b00a53c DM |
939 | if (!nlh) |
940 | goto out_module_put; | |
941 | t = nlmsg_data(nlh); | |
1da177e4 | 942 | t->tca_family = AF_UNSPEC; |
9ef1d4c7 PM |
943 | t->tca__pad1 = 0; |
944 | t->tca__pad2 = 0; | |
1da177e4 | 945 | |
4b3550ef PM |
946 | nest = nla_nest_start(skb, TCA_ACT_TAB); |
947 | if (nest == NULL) | |
8b00a53c | 948 | goto out_module_put; |
1da177e4 | 949 | |
a85a970a | 950 | err = ops->walk(net, skb, &dcb, RTM_DELACTION, ops); |
edb9d1bf | 951 | if (err <= 0) |
8b00a53c | 952 | goto out_module_put; |
1da177e4 | 953 | |
4b3550ef | 954 | nla_nest_end(skb, nest); |
1da177e4 | 955 | |
27a884dc | 956 | nlh->nlmsg_len = skb_tail_pointer(skb) - b; |
1da177e4 | 957 | nlh->nlmsg_flags |= NLM_F_ROOT; |
a85a970a | 958 | module_put(ops->owner); |
15e47304 | 959 | err = rtnetlink_send(skb, net, portid, RTNLGRP_TC, |
cc7ec456 | 960 | n->nlmsg_flags & NLM_F_ECHO); |
1da177e4 LT |
961 | if (err > 0) |
962 | return 0; | |
963 | ||
964 | return err; | |
965 | ||
8b00a53c | 966 | out_module_put: |
a85a970a | 967 | module_put(ops->owner); |
1da177e4 LT |
968 | err_out: |
969 | kfree_skb(skb); | |
1da177e4 LT |
970 | return err; |
971 | } | |
972 | ||
a56e1953 WC |
973 | static int |
974 | tcf_del_notify(struct net *net, struct nlmsghdr *n, struct list_head *actions, | |
975 | u32 portid) | |
976 | { | |
977 | int ret; | |
978 | struct sk_buff *skb; | |
979 | ||
980 | skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL); | |
981 | if (!skb) | |
982 | return -ENOBUFS; | |
983 | ||
984 | if (tca_get_fill(skb, actions, portid, n->nlmsg_seq, 0, RTM_DELACTION, | |
985 | 0, 1) <= 0) { | |
986 | kfree_skb(skb); | |
987 | return -EINVAL; | |
988 | } | |
989 | ||
990 | /* now do the delete */ | |
55334a5d WC |
991 | ret = tcf_action_destroy(actions, 0); |
992 | if (ret < 0) { | |
993 | kfree_skb(skb); | |
994 | return ret; | |
995 | } | |
a56e1953 WC |
996 | |
997 | ret = rtnetlink_send(skb, net, portid, RTNLGRP_TC, | |
998 | n->nlmsg_flags & NLM_F_ECHO); | |
999 | if (ret > 0) | |
1000 | return 0; | |
1001 | return ret; | |
1002 | } | |
1003 | ||
1da177e4 | 1004 | static int |
7316ae88 | 1005 | tca_action_gd(struct net *net, struct nlattr *nla, struct nlmsghdr *n, |
15e47304 | 1006 | u32 portid, int event) |
1da177e4 | 1007 | { |
cee63723 | 1008 | int i, ret; |
cc7ec456 | 1009 | struct nlattr *tb[TCA_ACT_MAX_PRIO + 1]; |
33be6271 WC |
1010 | struct tc_action *act; |
1011 | LIST_HEAD(actions); | |
1da177e4 | 1012 | |
fceb6435 | 1013 | ret = nla_parse_nested(tb, TCA_ACT_MAX_PRIO, nla, NULL, NULL); |
cee63723 PM |
1014 | if (ret < 0) |
1015 | return ret; | |
1da177e4 | 1016 | |
cc7ec456 | 1017 | if (event == RTM_DELACTION && n->nlmsg_flags & NLM_F_ROOT) { |
f97017cd | 1018 | if (tb[1] != NULL) |
15e47304 | 1019 | return tca_action_flush(net, tb[1], n, portid); |
f97017cd JHS |
1020 | else |
1021 | return -EINVAL; | |
1da177e4 LT |
1022 | } |
1023 | ||
7ba699c6 | 1024 | for (i = 1; i <= TCA_ACT_MAX_PRIO && tb[i]; i++) { |
ddf97ccd | 1025 | act = tcf_action_get_1(net, tb[i], n, portid); |
ab27cfb8 PM |
1026 | if (IS_ERR(act)) { |
1027 | ret = PTR_ERR(act); | |
1da177e4 | 1028 | goto err; |
ab27cfb8 | 1029 | } |
7ba699c6 | 1030 | act->order = i; |
33be6271 | 1031 | list_add_tail(&act->list, &actions); |
1da177e4 LT |
1032 | } |
1033 | ||
1034 | if (event == RTM_GETACTION) | |
c4c4290c | 1035 | ret = tcf_get_notify(net, portid, n, &actions, event); |
1da177e4 | 1036 | else { /* delete */ |
a56e1953 WC |
1037 | ret = tcf_del_notify(net, n, &actions, portid); |
1038 | if (ret) | |
1da177e4 | 1039 | goto err; |
1da177e4 LT |
1040 | return ret; |
1041 | } | |
1042 | err: | |
0faa9cb5 JHS |
1043 | if (event != RTM_GETACTION) |
1044 | tcf_action_destroy(&actions, 0); | |
1da177e4 LT |
1045 | return ret; |
1046 | } | |
1047 | ||
a56e1953 WC |
1048 | static int |
1049 | tcf_add_notify(struct net *net, struct nlmsghdr *n, struct list_head *actions, | |
1050 | u32 portid) | |
1da177e4 | 1051 | { |
1da177e4 | 1052 | struct sk_buff *skb; |
1da177e4 LT |
1053 | int err = 0; |
1054 | ||
1055 | skb = alloc_skb(NLMSG_GOODSIZE, GFP_KERNEL); | |
1056 | if (!skb) | |
1057 | return -ENOBUFS; | |
1058 | ||
a56e1953 WC |
1059 | if (tca_get_fill(skb, actions, portid, n->nlmsg_seq, n->nlmsg_flags, |
1060 | RTM_NEWACTION, 0, 0) <= 0) { | |
1061 | kfree_skb(skb); | |
1062 | return -EINVAL; | |
1063 | } | |
10297b99 | 1064 | |
a56e1953 WC |
1065 | err = rtnetlink_send(skb, net, portid, RTNLGRP_TC, |
1066 | n->nlmsg_flags & NLM_F_ECHO); | |
1da177e4 LT |
1067 | if (err > 0) |
1068 | err = 0; | |
1069 | return err; | |
1da177e4 LT |
1070 | } |
1071 | ||
5a7a5555 JHS |
1072 | static int tcf_action_add(struct net *net, struct nlattr *nla, |
1073 | struct nlmsghdr *n, u32 portid, int ovr) | |
1da177e4 LT |
1074 | { |
1075 | int ret = 0; | |
33be6271 | 1076 | LIST_HEAD(actions); |
1da177e4 | 1077 | |
9fb9f251 | 1078 | ret = tcf_action_init(net, NULL, nla, NULL, NULL, ovr, 0, &actions); |
33be6271 | 1079 | if (ret) |
f07fed82 | 1080 | return ret; |
1da177e4 | 1081 | |
f07fed82 | 1082 | return tcf_add_notify(net, n, &actions, portid); |
1da177e4 LT |
1083 | } |
1084 | ||
90825b23 JHS |
1085 | static u32 tcaa_root_flags_allowed = TCA_FLAG_LARGE_DUMP_ON; |
1086 | static const struct nla_policy tcaa_policy[TCA_ROOT_MAX + 1] = { | |
1087 | [TCA_ROOT_FLAGS] = { .type = NLA_BITFIELD32, | |
1088 | .validation_data = &tcaa_root_flags_allowed }, | |
e62e484d | 1089 | [TCA_ROOT_TIME_DELTA] = { .type = NLA_U32 }, |
90825b23 JHS |
1090 | }; |
1091 | ||
c21ef3e3 DA |
1092 | static int tc_ctl_action(struct sk_buff *skb, struct nlmsghdr *n, |
1093 | struct netlink_ext_ack *extack) | |
1da177e4 | 1094 | { |
3b1e0a65 | 1095 | struct net *net = sock_net(skb->sk); |
90825b23 | 1096 | struct nlattr *tca[TCA_ROOT_MAX + 1]; |
15e47304 | 1097 | u32 portid = skb ? NETLINK_CB(skb).portid : 0; |
1da177e4 LT |
1098 | int ret = 0, ovr = 0; |
1099 | ||
0b0f43fe JHS |
1100 | if ((n->nlmsg_type != RTM_GETACTION) && |
1101 | !netlink_capable(skb, CAP_NET_ADMIN)) | |
dfc47ef8 EB |
1102 | return -EPERM; |
1103 | ||
90825b23 | 1104 | ret = nlmsg_parse(n, sizeof(struct tcamsg), tca, TCA_ROOT_MAX, NULL, |
c21ef3e3 | 1105 | extack); |
7ba699c6 PM |
1106 | if (ret < 0) |
1107 | return ret; | |
1108 | ||
1109 | if (tca[TCA_ACT_TAB] == NULL) { | |
6ff9c364 | 1110 | pr_notice("tc_ctl_action: received NO action attribs\n"); |
1da177e4 LT |
1111 | return -EINVAL; |
1112 | } | |
1113 | ||
cc7ec456 | 1114 | /* n->nlmsg_flags & NLM_F_CREATE */ |
1da177e4 LT |
1115 | switch (n->nlmsg_type) { |
1116 | case RTM_NEWACTION: | |
1117 | /* we are going to assume all other flags | |
25985edc | 1118 | * imply create only if it doesn't exist |
1da177e4 LT |
1119 | * Note that CREATE | EXCL implies that |
1120 | * but since we want avoid ambiguity (eg when flags | |
1121 | * is zero) then just set this | |
1122 | */ | |
cc7ec456 | 1123 | if (n->nlmsg_flags & NLM_F_REPLACE) |
1da177e4 LT |
1124 | ovr = 1; |
1125 | replay: | |
15e47304 | 1126 | ret = tcf_action_add(net, tca[TCA_ACT_TAB], n, portid, ovr); |
1da177e4 LT |
1127 | if (ret == -EAGAIN) |
1128 | goto replay; | |
1129 | break; | |
1130 | case RTM_DELACTION: | |
7316ae88 | 1131 | ret = tca_action_gd(net, tca[TCA_ACT_TAB], n, |
15e47304 | 1132 | portid, RTM_DELACTION); |
1da177e4 LT |
1133 | break; |
1134 | case RTM_GETACTION: | |
7316ae88 | 1135 | ret = tca_action_gd(net, tca[TCA_ACT_TAB], n, |
15e47304 | 1136 | portid, RTM_GETACTION); |
1da177e4 LT |
1137 | break; |
1138 | default: | |
1139 | BUG(); | |
1140 | } | |
1141 | ||
1142 | return ret; | |
1143 | } | |
1144 | ||
90825b23 | 1145 | static struct nlattr *find_dump_kind(struct nlattr **nla) |
1da177e4 | 1146 | { |
cc7ec456 | 1147 | struct nlattr *tb1, *tb2[TCA_ACT_MAX + 1]; |
7ba699c6 | 1148 | struct nlattr *tb[TCA_ACT_MAX_PRIO + 1]; |
7ba699c6 | 1149 | struct nlattr *kind; |
1da177e4 | 1150 | |
7ba699c6 | 1151 | tb1 = nla[TCA_ACT_TAB]; |
1da177e4 LT |
1152 | if (tb1 == NULL) |
1153 | return NULL; | |
1154 | ||
7ba699c6 | 1155 | if (nla_parse(tb, TCA_ACT_MAX_PRIO, nla_data(tb1), |
fceb6435 | 1156 | NLMSG_ALIGN(nla_len(tb1)), NULL, NULL) < 0) |
1da177e4 | 1157 | return NULL; |
1da177e4 | 1158 | |
6d834e04 PM |
1159 | if (tb[1] == NULL) |
1160 | return NULL; | |
fceb6435 | 1161 | if (nla_parse_nested(tb2, TCA_ACT_MAX, tb[1], NULL, NULL) < 0) |
1da177e4 | 1162 | return NULL; |
7ba699c6 | 1163 | kind = tb2[TCA_ACT_KIND]; |
1da177e4 | 1164 | |
26dab893 | 1165 | return kind; |
1da177e4 LT |
1166 | } |
1167 | ||
5a7a5555 | 1168 | static int tc_dump_action(struct sk_buff *skb, struct netlink_callback *cb) |
1da177e4 | 1169 | { |
ddf97ccd | 1170 | struct net *net = sock_net(skb->sk); |
1da177e4 | 1171 | struct nlmsghdr *nlh; |
27a884dc | 1172 | unsigned char *b = skb_tail_pointer(skb); |
4b3550ef | 1173 | struct nlattr *nest; |
1da177e4 | 1174 | struct tc_action_ops *a_o; |
1da177e4 | 1175 | int ret = 0; |
8b00a53c | 1176 | struct tcamsg *t = (struct tcamsg *) nlmsg_data(cb->nlh); |
90825b23 JHS |
1177 | struct nlattr *tb[TCA_ROOT_MAX + 1]; |
1178 | struct nlattr *count_attr = NULL; | |
e62e484d | 1179 | unsigned long jiffy_since = 0; |
90825b23 JHS |
1180 | struct nlattr *kind = NULL; |
1181 | struct nla_bitfield32 bf; | |
e62e484d | 1182 | u32 msecs_since = 0; |
90825b23 JHS |
1183 | u32 act_count = 0; |
1184 | ||
1185 | ret = nlmsg_parse(cb->nlh, sizeof(struct tcamsg), tb, TCA_ROOT_MAX, | |
1186 | tcaa_policy, NULL); | |
1187 | if (ret < 0) | |
1188 | return ret; | |
1da177e4 | 1189 | |
90825b23 | 1190 | kind = find_dump_kind(tb); |
1da177e4 | 1191 | if (kind == NULL) { |
6ff9c364 | 1192 | pr_info("tc_dump_action: action bad kind\n"); |
1da177e4 LT |
1193 | return 0; |
1194 | } | |
1195 | ||
26dab893 | 1196 | a_o = tc_lookup_action(kind); |
cc7ec456 | 1197 | if (a_o == NULL) |
1da177e4 | 1198 | return 0; |
1da177e4 | 1199 | |
90825b23 JHS |
1200 | cb->args[2] = 0; |
1201 | if (tb[TCA_ROOT_FLAGS]) { | |
1202 | bf = nla_get_bitfield32(tb[TCA_ROOT_FLAGS]); | |
1203 | cb->args[2] = bf.value; | |
1204 | } | |
1205 | ||
e62e484d JHS |
1206 | if (tb[TCA_ROOT_TIME_DELTA]) { |
1207 | msecs_since = nla_get_u32(tb[TCA_ROOT_TIME_DELTA]); | |
1208 | } | |
1209 | ||
15e47304 | 1210 | nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq, |
8b00a53c DM |
1211 | cb->nlh->nlmsg_type, sizeof(*t), 0); |
1212 | if (!nlh) | |
1213 | goto out_module_put; | |
90825b23 | 1214 | |
e62e484d JHS |
1215 | if (msecs_since) |
1216 | jiffy_since = jiffies - msecs_to_jiffies(msecs_since); | |
1217 | ||
8b00a53c | 1218 | t = nlmsg_data(nlh); |
1da177e4 | 1219 | t->tca_family = AF_UNSPEC; |
9ef1d4c7 PM |
1220 | t->tca__pad1 = 0; |
1221 | t->tca__pad2 = 0; | |
e62e484d | 1222 | cb->args[3] = jiffy_since; |
90825b23 JHS |
1223 | count_attr = nla_reserve(skb, TCA_ROOT_COUNT, sizeof(u32)); |
1224 | if (!count_attr) | |
1225 | goto out_module_put; | |
1da177e4 | 1226 | |
4b3550ef PM |
1227 | nest = nla_nest_start(skb, TCA_ACT_TAB); |
1228 | if (nest == NULL) | |
8b00a53c | 1229 | goto out_module_put; |
1da177e4 | 1230 | |
a85a970a | 1231 | ret = a_o->walk(net, skb, cb, RTM_GETACTION, a_o); |
1da177e4 | 1232 | if (ret < 0) |
8b00a53c | 1233 | goto out_module_put; |
1da177e4 LT |
1234 | |
1235 | if (ret > 0) { | |
4b3550ef | 1236 | nla_nest_end(skb, nest); |
1da177e4 | 1237 | ret = skb->len; |
90825b23 JHS |
1238 | act_count = cb->args[1]; |
1239 | memcpy(nla_data(count_attr), &act_count, sizeof(u32)); | |
1240 | cb->args[1] = 0; | |
1da177e4 | 1241 | } else |
ebecaa66 | 1242 | nlmsg_trim(skb, b); |
1da177e4 | 1243 | |
27a884dc | 1244 | nlh->nlmsg_len = skb_tail_pointer(skb) - b; |
15e47304 | 1245 | if (NETLINK_CB(cb->skb).portid && ret) |
1da177e4 LT |
1246 | nlh->nlmsg_flags |= NLM_F_MULTI; |
1247 | module_put(a_o->owner); | |
1248 | return skb->len; | |
1249 | ||
8b00a53c | 1250 | out_module_put: |
1da177e4 | 1251 | module_put(a_o->owner); |
dc5fc579 | 1252 | nlmsg_trim(skb, b); |
1da177e4 LT |
1253 | return skb->len; |
1254 | } | |
1255 | ||
b3f55bdd JP |
1256 | struct tcf_action_net { |
1257 | struct rhashtable egdev_ht; | |
1258 | }; | |
1259 | ||
1260 | static unsigned int tcf_action_net_id; | |
1261 | ||
1262 | struct tcf_action_egdev_cb { | |
1263 | struct list_head list; | |
1264 | tc_setup_cb_t *cb; | |
1265 | void *cb_priv; | |
1266 | }; | |
1267 | ||
1268 | struct tcf_action_egdev { | |
1269 | struct rhash_head ht_node; | |
1270 | const struct net_device *dev; | |
1271 | unsigned int refcnt; | |
1272 | struct list_head cb_list; | |
1273 | }; | |
1274 | ||
1275 | static const struct rhashtable_params tcf_action_egdev_ht_params = { | |
1276 | .key_offset = offsetof(struct tcf_action_egdev, dev), | |
1277 | .head_offset = offsetof(struct tcf_action_egdev, ht_node), | |
1278 | .key_len = sizeof(const struct net_device *), | |
1279 | }; | |
1280 | ||
1281 | static struct tcf_action_egdev * | |
1282 | tcf_action_egdev_lookup(const struct net_device *dev) | |
1283 | { | |
1284 | struct net *net = dev_net(dev); | |
1285 | struct tcf_action_net *tan = net_generic(net, tcf_action_net_id); | |
1286 | ||
1287 | return rhashtable_lookup_fast(&tan->egdev_ht, &dev, | |
1288 | tcf_action_egdev_ht_params); | |
1289 | } | |
1290 | ||
1291 | static struct tcf_action_egdev * | |
1292 | tcf_action_egdev_get(const struct net_device *dev) | |
1293 | { | |
1294 | struct tcf_action_egdev *egdev; | |
1295 | struct tcf_action_net *tan; | |
1296 | ||
1297 | egdev = tcf_action_egdev_lookup(dev); | |
1298 | if (egdev) | |
1299 | goto inc_ref; | |
1300 | ||
1301 | egdev = kzalloc(sizeof(*egdev), GFP_KERNEL); | |
1302 | if (!egdev) | |
1303 | return NULL; | |
1304 | INIT_LIST_HEAD(&egdev->cb_list); | |
0843c092 | 1305 | egdev->dev = dev; |
b3f55bdd JP |
1306 | tan = net_generic(dev_net(dev), tcf_action_net_id); |
1307 | rhashtable_insert_fast(&tan->egdev_ht, &egdev->ht_node, | |
1308 | tcf_action_egdev_ht_params); | |
1309 | ||
1310 | inc_ref: | |
1311 | egdev->refcnt++; | |
1312 | return egdev; | |
1313 | } | |
1314 | ||
1315 | static void tcf_action_egdev_put(struct tcf_action_egdev *egdev) | |
1316 | { | |
1317 | struct tcf_action_net *tan; | |
1318 | ||
1319 | if (--egdev->refcnt) | |
1320 | return; | |
1321 | tan = net_generic(dev_net(egdev->dev), tcf_action_net_id); | |
1322 | rhashtable_remove_fast(&tan->egdev_ht, &egdev->ht_node, | |
1323 | tcf_action_egdev_ht_params); | |
1324 | kfree(egdev); | |
1325 | } | |
1326 | ||
1327 | static struct tcf_action_egdev_cb * | |
1328 | tcf_action_egdev_cb_lookup(struct tcf_action_egdev *egdev, | |
1329 | tc_setup_cb_t *cb, void *cb_priv) | |
1330 | { | |
1331 | struct tcf_action_egdev_cb *egdev_cb; | |
1332 | ||
1333 | list_for_each_entry(egdev_cb, &egdev->cb_list, list) | |
1334 | if (egdev_cb->cb == cb && egdev_cb->cb_priv == cb_priv) | |
1335 | return egdev_cb; | |
1336 | return NULL; | |
1337 | } | |
1338 | ||
1339 | static int tcf_action_egdev_cb_call(struct tcf_action_egdev *egdev, | |
1340 | enum tc_setup_type type, | |
1341 | void *type_data, bool err_stop) | |
1342 | { | |
1343 | struct tcf_action_egdev_cb *egdev_cb; | |
1344 | int ok_count = 0; | |
1345 | int err; | |
1346 | ||
1347 | list_for_each_entry(egdev_cb, &egdev->cb_list, list) { | |
1348 | err = egdev_cb->cb(type, type_data, egdev_cb->cb_priv); | |
1349 | if (err) { | |
1350 | if (err_stop) | |
1351 | return err; | |
1352 | } else { | |
1353 | ok_count++; | |
1354 | } | |
1355 | } | |
1356 | return ok_count; | |
1357 | } | |
1358 | ||
1359 | static int tcf_action_egdev_cb_add(struct tcf_action_egdev *egdev, | |
1360 | tc_setup_cb_t *cb, void *cb_priv) | |
1361 | { | |
1362 | struct tcf_action_egdev_cb *egdev_cb; | |
1363 | ||
1364 | egdev_cb = tcf_action_egdev_cb_lookup(egdev, cb, cb_priv); | |
1365 | if (WARN_ON(egdev_cb)) | |
1366 | return -EEXIST; | |
1367 | egdev_cb = kzalloc(sizeof(*egdev_cb), GFP_KERNEL); | |
1368 | if (!egdev_cb) | |
1369 | return -ENOMEM; | |
1370 | egdev_cb->cb = cb; | |
1371 | egdev_cb->cb_priv = cb_priv; | |
1372 | list_add(&egdev_cb->list, &egdev->cb_list); | |
1373 | return 0; | |
1374 | } | |
1375 | ||
1376 | static void tcf_action_egdev_cb_del(struct tcf_action_egdev *egdev, | |
1377 | tc_setup_cb_t *cb, void *cb_priv) | |
1378 | { | |
1379 | struct tcf_action_egdev_cb *egdev_cb; | |
1380 | ||
1381 | egdev_cb = tcf_action_egdev_cb_lookup(egdev, cb, cb_priv); | |
1382 | if (WARN_ON(!egdev_cb)) | |
1383 | return; | |
1384 | list_del(&egdev_cb->list); | |
1385 | kfree(egdev_cb); | |
1386 | } | |
1387 | ||
1388 | static int __tc_setup_cb_egdev_register(const struct net_device *dev, | |
1389 | tc_setup_cb_t *cb, void *cb_priv) | |
1390 | { | |
1391 | struct tcf_action_egdev *egdev = tcf_action_egdev_get(dev); | |
1392 | int err; | |
1393 | ||
1394 | if (!egdev) | |
1395 | return -ENOMEM; | |
1396 | err = tcf_action_egdev_cb_add(egdev, cb, cb_priv); | |
1397 | if (err) | |
1398 | goto err_cb_add; | |
1399 | return 0; | |
1400 | ||
1401 | err_cb_add: | |
1402 | tcf_action_egdev_put(egdev); | |
1403 | return err; | |
1404 | } | |
1405 | int tc_setup_cb_egdev_register(const struct net_device *dev, | |
1406 | tc_setup_cb_t *cb, void *cb_priv) | |
1407 | { | |
1408 | int err; | |
1409 | ||
1410 | rtnl_lock(); | |
1411 | err = __tc_setup_cb_egdev_register(dev, cb, cb_priv); | |
1412 | rtnl_unlock(); | |
1413 | return err; | |
1414 | } | |
1415 | EXPORT_SYMBOL_GPL(tc_setup_cb_egdev_register); | |
1416 | ||
1417 | static void __tc_setup_cb_egdev_unregister(const struct net_device *dev, | |
1418 | tc_setup_cb_t *cb, void *cb_priv) | |
1419 | { | |
1420 | struct tcf_action_egdev *egdev = tcf_action_egdev_lookup(dev); | |
1421 | ||
1422 | if (WARN_ON(!egdev)) | |
1423 | return; | |
1424 | tcf_action_egdev_cb_del(egdev, cb, cb_priv); | |
1425 | tcf_action_egdev_put(egdev); | |
1426 | } | |
1427 | void tc_setup_cb_egdev_unregister(const struct net_device *dev, | |
1428 | tc_setup_cb_t *cb, void *cb_priv) | |
1429 | { | |
1430 | rtnl_lock(); | |
1431 | __tc_setup_cb_egdev_unregister(dev, cb, cb_priv); | |
1432 | rtnl_unlock(); | |
1433 | } | |
1434 | EXPORT_SYMBOL_GPL(tc_setup_cb_egdev_unregister); | |
1435 | ||
1436 | int tc_setup_cb_egdev_call(const struct net_device *dev, | |
1437 | enum tc_setup_type type, void *type_data, | |
1438 | bool err_stop) | |
1439 | { | |
1440 | struct tcf_action_egdev *egdev = tcf_action_egdev_lookup(dev); | |
1441 | ||
1442 | if (!egdev) | |
1443 | return 0; | |
1444 | return tcf_action_egdev_cb_call(egdev, type, type_data, err_stop); | |
1445 | } | |
1446 | EXPORT_SYMBOL_GPL(tc_setup_cb_egdev_call); | |
1447 | ||
1448 | static __net_init int tcf_action_net_init(struct net *net) | |
1449 | { | |
1450 | struct tcf_action_net *tan = net_generic(net, tcf_action_net_id); | |
1451 | ||
1452 | return rhashtable_init(&tan->egdev_ht, &tcf_action_egdev_ht_params); | |
1453 | } | |
1454 | ||
1455 | static void __net_exit tcf_action_net_exit(struct net *net) | |
1456 | { | |
1457 | struct tcf_action_net *tan = net_generic(net, tcf_action_net_id); | |
1458 | ||
1459 | rhashtable_destroy(&tan->egdev_ht); | |
1460 | } | |
1461 | ||
1462 | static struct pernet_operations tcf_action_net_ops = { | |
1463 | .init = tcf_action_net_init, | |
1464 | .exit = tcf_action_net_exit, | |
1465 | .id = &tcf_action_net_id, | |
1466 | .size = sizeof(struct tcf_action_net), | |
1467 | }; | |
1468 | ||
1da177e4 LT |
1469 | static int __init tc_action_init(void) |
1470 | { | |
b3f55bdd JP |
1471 | int err; |
1472 | ||
1473 | err = register_pernet_subsys(&tcf_action_net_ops); | |
1474 | if (err) | |
1475 | return err; | |
1476 | ||
b97bac64 FW |
1477 | rtnl_register(PF_UNSPEC, RTM_NEWACTION, tc_ctl_action, NULL, 0); |
1478 | rtnl_register(PF_UNSPEC, RTM_DELACTION, tc_ctl_action, NULL, 0); | |
c7ac8679 | 1479 | rtnl_register(PF_UNSPEC, RTM_GETACTION, tc_ctl_action, tc_dump_action, |
b97bac64 | 1480 | 0); |
1da177e4 | 1481 | |
1da177e4 LT |
1482 | return 0; |
1483 | } | |
1484 | ||
1485 | subsys_initcall(tc_action_init); |