blob: 93b0a7b6f9b474641595d4f093b79330bd0d05f9 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * net/sched/cls_fw.c Classifier mapping ipchains' fwmark to traffic class.
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 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
10 *
11 * Changes:
12 * Karlis Peisenieks <karlis@mt.lv> : 990415 : fw_walk off by one
13 * Karlis Peisenieks <karlis@mt.lv> : 990415 : fw_delete killed all the filter (and kernel).
14 * Alex <alex@pilotsoft.com> : 2004xxyy: Added Action extension
15 *
16 * JHS: We should remove the CONFIG_NET_CLS_IND from here
17 * eventually when the meta match extension is made available
18 *
19 */
20
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/module.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090022#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include <linux/types.h>
24#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include <linux/string.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include <linux/skbuff.h>
Patrick McHardy0ba48052007-07-02 22:49:07 -070028#include <net/netlink.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <net/act_api.h>
30#include <net/pkt_cls.h>
31
Thomas Grafc5c13fa2005-04-24 20:19:54 -070032#define HTSIZE (PAGE_SIZE/sizeof(struct fw_filter *))
33
Linus Torvalds1da177e2005-04-16 15:20:36 -070034struct fw_head
35{
Thomas Grafc5c13fa2005-04-24 20:19:54 -070036 struct fw_filter *ht[HTSIZE];
Patrick McHardyb4e9b522006-08-25 16:11:42 -070037 u32 mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -070038};
39
40struct fw_filter
41{
42 struct fw_filter *next;
43 u32 id;
44 struct tcf_result res;
45#ifdef CONFIG_NET_CLS_IND
46 char indev[IFNAMSIZ];
47#endif /* CONFIG_NET_CLS_IND */
48 struct tcf_exts exts;
49};
50
Patrick McHardy52390082008-01-31 18:36:18 -080051static const struct tcf_ext_map fw_ext_map = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 .action = TCA_FW_ACT,
53 .police = TCA_FW_POLICE
54};
55
56static __inline__ int fw_hash(u32 handle)
57{
Thomas Grafc5c13fa2005-04-24 20:19:54 -070058 if (HTSIZE == 4096)
59 return ((handle >> 24) & 0xFFF) ^
60 ((handle >> 12) & 0xFFF) ^
61 (handle & 0xFFF);
62 else if (HTSIZE == 2048)
63 return ((handle >> 22) & 0x7FF) ^
64 ((handle >> 11) & 0x7FF) ^
65 (handle & 0x7FF);
66 else if (HTSIZE == 1024)
67 return ((handle >> 20) & 0x3FF) ^
68 ((handle >> 10) & 0x3FF) ^
69 (handle & 0x3FF);
70 else if (HTSIZE == 512)
71 return (handle >> 27) ^
72 ((handle >> 18) & 0x1FF) ^
73 ((handle >> 9) & 0x1FF) ^
74 (handle & 0x1FF);
75 else if (HTSIZE == 256) {
76 u8 *t = (u8 *) &handle;
77 return t[0] ^ t[1] ^ t[2] ^ t[3];
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +090078 } else
Thomas Grafc5c13fa2005-04-24 20:19:54 -070079 return handle & (HTSIZE - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -070080}
81
82static int fw_classify(struct sk_buff *skb, struct tcf_proto *tp,
83 struct tcf_result *res)
84{
85 struct fw_head *head = (struct fw_head*)tp->root;
86 struct fw_filter *f;
87 int r;
Patrick McHardy5c804bf2006-12-05 13:46:13 -080088 u32 id = skb->mark;
Linus Torvalds1da177e2005-04-16 15:20:36 -070089
90 if (head != NULL) {
Patrick McHardy5c804bf2006-12-05 13:46:13 -080091 id &= head->mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 for (f=head->ht[fw_hash(id)]; f; f=f->next) {
93 if (f->id == id) {
94 *res = f->res;
95#ifdef CONFIG_NET_CLS_IND
96 if (!tcf_match_indev(skb, f->indev))
97 continue;
98#endif /* CONFIG_NET_CLS_IND */
99 r = tcf_exts_exec(skb, &f->exts, res);
100 if (r < 0)
101 continue;
102
103 return r;
104 }
105 }
106 } else {
107 /* old method */
108 if (id && (TC_H_MAJ(id) == 0 || !(TC_H_MAJ(id^tp->q->handle)))) {
109 res->classid = id;
110 res->class = 0;
111 return 0;
112 }
113 }
114
115 return -1;
116}
117
118static unsigned long fw_get(struct tcf_proto *tp, u32 handle)
119{
120 struct fw_head *head = (struct fw_head*)tp->root;
121 struct fw_filter *f;
122
123 if (head == NULL)
124 return 0;
125
126 for (f=head->ht[fw_hash(handle)]; f; f=f->next) {
127 if (f->id == handle)
128 return (unsigned long)f;
129 }
130 return 0;
131}
132
133static void fw_put(struct tcf_proto *tp, unsigned long f)
134{
135}
136
137static int fw_init(struct tcf_proto *tp)
138{
139 return 0;
140}
141
142static inline void
143fw_delete_filter(struct tcf_proto *tp, struct fw_filter *f)
144{
145 tcf_unbind_filter(tp, &f->res);
146 tcf_exts_destroy(tp, &f->exts);
147 kfree(f);
148}
149
150static void fw_destroy(struct tcf_proto *tp)
151{
Patrick McHardy47a1a1d2008-11-19 08:03:09 +0000152 struct fw_head *head = tp->root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 struct fw_filter *f;
154 int h;
155
156 if (head == NULL)
157 return;
158
Thomas Grafc5c13fa2005-04-24 20:19:54 -0700159 for (h=0; h<HTSIZE; h++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160 while ((f=head->ht[h]) != NULL) {
161 head->ht[h] = f->next;
162 fw_delete_filter(tp, f);
163 }
164 }
165 kfree(head);
166}
167
168static int fw_delete(struct tcf_proto *tp, unsigned long arg)
169{
170 struct fw_head *head = (struct fw_head*)tp->root;
171 struct fw_filter *f = (struct fw_filter*)arg;
172 struct fw_filter **fp;
173
174 if (head == NULL || f == NULL)
175 goto out;
176
177 for (fp=&head->ht[fw_hash(f->id)]; *fp; fp = &(*fp)->next) {
178 if (*fp == f) {
179 tcf_tree_lock(tp);
180 *fp = f->next;
181 tcf_tree_unlock(tp);
182 fw_delete_filter(tp, f);
183 return 0;
184 }
185 }
186out:
187 return -EINVAL;
188}
189
Patrick McHardy6fa8c012008-01-23 20:36:12 -0800190static const struct nla_policy fw_policy[TCA_FW_MAX + 1] = {
191 [TCA_FW_CLASSID] = { .type = NLA_U32 },
192 [TCA_FW_INDEV] = { .type = NLA_STRING, .len = IFNAMSIZ },
193 [TCA_FW_MASK] = { .type = NLA_U32 },
194};
195
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196static int
197fw_change_attrs(struct tcf_proto *tp, struct fw_filter *f,
Patrick McHardyadd93b62008-01-22 22:11:33 -0800198 struct nlattr **tb, struct nlattr **tca, unsigned long base)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199{
Patrick McHardyb4e9b522006-08-25 16:11:42 -0700200 struct fw_head *head = (struct fw_head *)tp->root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 struct tcf_exts e;
Patrick McHardyb4e9b522006-08-25 16:11:42 -0700202 u32 mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 int err;
204
Patrick McHardyadd93b62008-01-22 22:11:33 -0800205 err = tcf_exts_validate(tp, tb, tca[TCA_RATE], &e, &fw_ext_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 if (err < 0)
207 return err;
208
209 err = -EINVAL;
Patrick McHardyadd93b62008-01-22 22:11:33 -0800210 if (tb[TCA_FW_CLASSID]) {
Patrick McHardy1587bac2008-01-23 20:35:03 -0800211 f->res.classid = nla_get_u32(tb[TCA_FW_CLASSID]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 tcf_bind_filter(tp, &f->res, base);
213 }
214
215#ifdef CONFIG_NET_CLS_IND
Patrick McHardyadd93b62008-01-22 22:11:33 -0800216 if (tb[TCA_FW_INDEV]) {
217 err = tcf_change_indev(tp, f->indev, tb[TCA_FW_INDEV]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218 if (err < 0)
219 goto errout;
220 }
221#endif /* CONFIG_NET_CLS_IND */
222
Patrick McHardyadd93b62008-01-22 22:11:33 -0800223 if (tb[TCA_FW_MASK]) {
Patrick McHardy1587bac2008-01-23 20:35:03 -0800224 mask = nla_get_u32(tb[TCA_FW_MASK]);
Patrick McHardyb4e9b522006-08-25 16:11:42 -0700225 if (mask != head->mask)
226 goto errout;
227 } else if (head->mask != 0xFFFFFFFF)
228 goto errout;
229
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 tcf_exts_change(tp, &f->exts, &e);
231
232 return 0;
233errout:
234 tcf_exts_destroy(tp, &e);
235 return err;
236}
237
238static int fw_change(struct tcf_proto *tp, unsigned long base,
239 u32 handle,
Patrick McHardyadd93b62008-01-22 22:11:33 -0800240 struct nlattr **tca,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241 unsigned long *arg)
242{
243 struct fw_head *head = (struct fw_head*)tp->root;
244 struct fw_filter *f = (struct fw_filter *) *arg;
Patrick McHardyadd93b62008-01-22 22:11:33 -0800245 struct nlattr *opt = tca[TCA_OPTIONS];
246 struct nlattr *tb[TCA_FW_MAX + 1];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 int err;
248
249 if (!opt)
250 return handle ? -EINVAL : 0;
251
Patrick McHardy6fa8c012008-01-23 20:36:12 -0800252 err = nla_parse_nested(tb, TCA_FW_MAX, opt, fw_policy);
Patrick McHardycee63722008-01-23 20:33:32 -0800253 if (err < 0)
254 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
256 if (f != NULL) {
257 if (f->id != handle && handle)
258 return -EINVAL;
259 return fw_change_attrs(tp, f, tb, tca, base);
260 }
261
262 if (!handle)
263 return -EINVAL;
264
265 if (head == NULL) {
Patrick McHardyb4e9b522006-08-25 16:11:42 -0700266 u32 mask = 0xFFFFFFFF;
Patrick McHardy6fa8c012008-01-23 20:36:12 -0800267 if (tb[TCA_FW_MASK])
Patrick McHardy1587bac2008-01-23 20:35:03 -0800268 mask = nla_get_u32(tb[TCA_FW_MASK]);
Patrick McHardyb4e9b522006-08-25 16:11:42 -0700269
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700270 head = kzalloc(sizeof(struct fw_head), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 if (head == NULL)
272 return -ENOBUFS;
Patrick McHardyb4e9b522006-08-25 16:11:42 -0700273 head->mask = mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274
275 tcf_tree_lock(tp);
276 tp->root = head;
277 tcf_tree_unlock(tp);
278 }
279
Panagiotis Issaris0da974f2006-07-21 14:51:30 -0700280 f = kzalloc(sizeof(struct fw_filter), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 if (f == NULL)
282 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283
284 f->id = handle;
285
286 err = fw_change_attrs(tp, f, tb, tca, base);
287 if (err < 0)
288 goto errout;
289
290 f->next = head->ht[fw_hash(handle)];
291 tcf_tree_lock(tp);
292 head->ht[fw_hash(handle)] = f;
293 tcf_tree_unlock(tp);
294
295 *arg = (unsigned long)f;
296 return 0;
297
298errout:
Jesper Juhla51482b2005-11-08 09:41:34 -0800299 kfree(f);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 return err;
301}
302
303static void fw_walk(struct tcf_proto *tp, struct tcf_walker *arg)
304{
305 struct fw_head *head = (struct fw_head*)tp->root;
306 int h;
307
308 if (head == NULL)
309 arg->stop = 1;
310
311 if (arg->stop)
312 return;
313
Thomas Grafc5c13fa2005-04-24 20:19:54 -0700314 for (h = 0; h < HTSIZE; h++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 struct fw_filter *f;
316
317 for (f = head->ht[h]; f; f = f->next) {
318 if (arg->count < arg->skip) {
319 arg->count++;
320 continue;
321 }
322 if (arg->fn(tp, (unsigned long)f, arg) < 0) {
323 arg->stop = 1;
324 return;
325 }
326 arg->count++;
327 }
328 }
329}
330
331static int fw_dump(struct tcf_proto *tp, unsigned long fh,
332 struct sk_buff *skb, struct tcmsg *t)
333{
Patrick McHardyb4e9b522006-08-25 16:11:42 -0700334 struct fw_head *head = (struct fw_head *)tp->root;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335 struct fw_filter *f = (struct fw_filter*)fh;
Arnaldo Carvalho de Melo27a884d2007-04-19 20:29:13 -0700336 unsigned char *b = skb_tail_pointer(skb);
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800337 struct nlattr *nest;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338
339 if (f == NULL)
340 return skb->len;
341
342 t->tcm_handle = f->id;
343
344 if (!f->res.classid && !tcf_exts_is_available(&f->exts))
345 return skb->len;
346
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800347 nest = nla_nest_start(skb, TCA_OPTIONS);
348 if (nest == NULL)
349 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350
351 if (f->res.classid)
Patrick McHardy24beeab2008-01-23 20:34:48 -0800352 NLA_PUT_U32(skb, TCA_FW_CLASSID, f->res.classid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353#ifdef CONFIG_NET_CLS_IND
354 if (strlen(f->indev))
Patrick McHardy57e1c482008-01-23 20:34:28 -0800355 NLA_PUT_STRING(skb, TCA_FW_INDEV, f->indev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356#endif /* CONFIG_NET_CLS_IND */
Patrick McHardyb4e9b522006-08-25 16:11:42 -0700357 if (head->mask != 0xFFFFFFFF)
Patrick McHardy24beeab2008-01-23 20:34:48 -0800358 NLA_PUT_U32(skb, TCA_FW_MASK, head->mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359
360 if (tcf_exts_dump(skb, &f->exts, &fw_ext_map) < 0)
Patrick McHardyadd93b62008-01-22 22:11:33 -0800361 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362
Patrick McHardy4b3550ef2008-01-23 20:34:11 -0800363 nla_nest_end(skb, nest);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364
365 if (tcf_exts_dump_stats(skb, &f->exts, &fw_ext_map) < 0)
Patrick McHardyadd93b62008-01-22 22:11:33 -0800366 goto nla_put_failure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367
368 return skb->len;
369
Patrick McHardyadd93b62008-01-22 22:11:33 -0800370nla_put_failure:
Arnaldo Carvalho de Melodc5fc572007-03-25 23:06:12 -0700371 nlmsg_trim(skb, b);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 return -1;
373}
374
Patrick McHardy2eb9d752008-01-22 22:10:42 -0800375static struct tcf_proto_ops cls_fw_ops __read_mostly = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376 .kind = "fw",
377 .classify = fw_classify,
378 .init = fw_init,
379 .destroy = fw_destroy,
380 .get = fw_get,
381 .put = fw_put,
382 .change = fw_change,
383 .delete = fw_delete,
384 .walk = fw_walk,
385 .dump = fw_dump,
386 .owner = THIS_MODULE,
387};
388
389static int __init init_fw(void)
390{
391 return register_tcf_proto_ops(&cls_fw_ops);
392}
393
YOSHIFUJI Hideaki10297b92007-02-09 23:25:16 +0900394static void __exit exit_fw(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395{
396 unregister_tcf_proto_ops(&cls_fw_ops);
397}
398
399module_init(init_fw)
400module_exit(exit_fw)
401MODULE_LICENSE("GPL");