Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * net/sched/cls_tcindex.c Packet classifier for skb->tc_index |
| 3 | * |
| 4 | * Written 1998,1999 by Werner Almesberger, EPFL ICA |
| 5 | */ |
| 6 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 7 | #include <linux/module.h> |
| 8 | #include <linux/types.h> |
| 9 | #include <linux/kernel.h> |
| 10 | #include <linux/skbuff.h> |
| 11 | #include <linux/errno.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 12 | #include <linux/slab.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | #include <net/act_api.h> |
Arnaldo Carvalho de Melo | dc5fc57 | 2007-03-25 23:06:12 -0700 | [diff] [blame] | 14 | #include <net/netlink.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | #include <net/pkt_cls.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 16 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | /* |
| 18 | * Passing parameters to the root seems to be done more awkwardly than really |
| 19 | * necessary. At least, u32 doesn't seem to use such dirty hacks. To be |
| 20 | * verified. FIXME. |
| 21 | */ |
| 22 | |
| 23 | #define PERFECT_HASH_THRESHOLD 64 /* use perfect hash if not bigger */ |
| 24 | #define DEFAULT_HASH_SIZE 64 /* optimized for diffserv */ |
| 25 | |
| 26 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | struct tcindex_filter_result { |
| 28 | struct tcf_exts exts; |
| 29 | struct tcf_result res; |
Alexei Starovoitov | ed7aa87 | 2015-08-25 20:06:33 -0700 | [diff] [blame] | 30 | struct rcu_head rcu; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | }; |
| 32 | |
| 33 | struct tcindex_filter { |
| 34 | u16 key; |
| 35 | struct tcindex_filter_result result; |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 36 | struct tcindex_filter __rcu *next; |
| 37 | struct rcu_head rcu; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 38 | }; |
| 39 | |
| 40 | |
| 41 | struct tcindex_data { |
| 42 | struct tcindex_filter_result *perfect; /* perfect hash; NULL if none */ |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 43 | struct tcindex_filter __rcu **h; /* imperfect hash; */ |
| 44 | struct tcf_proto *tp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 45 | u16 mask; /* AND key with mask */ |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 46 | u32 shift; /* shift ANDed key to the right */ |
| 47 | u32 hash; /* hash table size; 0 if undefined */ |
| 48 | u32 alloc_hash; /* allocated size */ |
| 49 | u32 fall_through; /* 0: only classify if explicit match */ |
| 50 | struct rcu_head rcu; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 51 | }; |
| 52 | |
Jamal Hadi Salim | 5a7a555 | 2016-09-18 08:45:33 -0400 | [diff] [blame] | 53 | static inline int tcindex_filter_is_set(struct tcindex_filter_result *r) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 54 | { |
| 55 | return tcf_exts_is_predicative(&r->exts) || r->res.classid; |
| 56 | } |
| 57 | |
Jamal Hadi Salim | 5a7a555 | 2016-09-18 08:45:33 -0400 | [diff] [blame] | 58 | static struct tcindex_filter_result *tcindex_lookup(struct tcindex_data *p, |
| 59 | u16 key) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 60 | { |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 61 | if (p->perfect) { |
| 62 | struct tcindex_filter_result *f = p->perfect + key; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 64 | return tcindex_filter_is_set(f) ? f : NULL; |
| 65 | } else if (p->h) { |
| 66 | struct tcindex_filter __rcu **fp; |
| 67 | struct tcindex_filter *f; |
| 68 | |
| 69 | fp = &p->h[key % p->hash]; |
| 70 | for (f = rcu_dereference_bh_rtnl(*fp); |
| 71 | f; |
| 72 | fp = &f->next, f = rcu_dereference_bh_rtnl(*fp)) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 73 | if (f->key == key) |
| 74 | return &f->result; |
| 75 | } |
| 76 | |
| 77 | return NULL; |
| 78 | } |
| 79 | |
| 80 | |
Eric Dumazet | dc7f9f6 | 2011-07-05 23:25:42 +0000 | [diff] [blame] | 81 | static int tcindex_classify(struct sk_buff *skb, const struct tcf_proto *tp, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 82 | struct tcf_result *res) |
| 83 | { |
WANG Cong | 2f9a220 | 2014-09-15 14:06:48 -0700 | [diff] [blame] | 84 | struct tcindex_data *p = rcu_dereference_bh(tp->root); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 85 | struct tcindex_filter_result *f; |
| 86 | int key = (skb->tc_index & p->mask) >> p->shift; |
| 87 | |
Stephen Hemminger | aa767bf | 2008-01-21 02:26:41 -0800 | [diff] [blame] | 88 | pr_debug("tcindex_classify(skb %p,tp %p,res %p),p %p\n", |
| 89 | skb, tp, res, p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 90 | |
| 91 | f = tcindex_lookup(p, key); |
| 92 | if (!f) { |
| 93 | if (!p->fall_through) |
| 94 | return -1; |
| 95 | res->classid = TC_H_MAKE(TC_H_MAJ(tp->q->handle), key); |
| 96 | res->class = 0; |
Stephen Hemminger | aa767bf | 2008-01-21 02:26:41 -0800 | [diff] [blame] | 97 | pr_debug("alg 0x%x\n", res->classid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | return 0; |
| 99 | } |
| 100 | *res = f->res; |
Stephen Hemminger | aa767bf | 2008-01-21 02:26:41 -0800 | [diff] [blame] | 101 | pr_debug("map 0x%x\n", res->classid); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 102 | |
| 103 | return tcf_exts_exec(skb, &f->exts, res); |
| 104 | } |
| 105 | |
| 106 | |
| 107 | static unsigned long tcindex_get(struct tcf_proto *tp, u32 handle) |
| 108 | { |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 109 | struct tcindex_data *p = rtnl_dereference(tp->root); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 110 | struct tcindex_filter_result *r; |
| 111 | |
Stephen Hemminger | aa767bf | 2008-01-21 02:26:41 -0800 | [diff] [blame] | 112 | pr_debug("tcindex_get(tp %p,handle 0x%08x)\n", tp, handle); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 113 | if (p->perfect && handle >= p->alloc_hash) |
| 114 | return 0; |
| 115 | r = tcindex_lookup(p, handle); |
| 116 | return r && tcindex_filter_is_set(r) ? (unsigned long) r : 0UL; |
| 117 | } |
| 118 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 119 | static int tcindex_init(struct tcf_proto *tp) |
| 120 | { |
| 121 | struct tcindex_data *p; |
| 122 | |
Stephen Hemminger | aa767bf | 2008-01-21 02:26:41 -0800 | [diff] [blame] | 123 | pr_debug("tcindex_init(tp %p)\n", tp); |
| 124 | p = kzalloc(sizeof(struct tcindex_data), GFP_KERNEL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 125 | if (!p) |
| 126 | return -ENOMEM; |
| 127 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 128 | p->mask = 0xffff; |
| 129 | p->hash = DEFAULT_HASH_SIZE; |
| 130 | p->fall_through = 1; |
| 131 | |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 132 | rcu_assign_pointer(tp->root, p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 133 | return 0; |
| 134 | } |
| 135 | |
Alexei Starovoitov | ed7aa87 | 2015-08-25 20:06:33 -0700 | [diff] [blame] | 136 | static void tcindex_destroy_rexts(struct rcu_head *head) |
| 137 | { |
| 138 | struct tcindex_filter_result *r; |
| 139 | |
| 140 | r = container_of(head, struct tcindex_filter_result, rcu); |
| 141 | tcf_exts_destroy(&r->exts); |
| 142 | } |
| 143 | |
| 144 | static void tcindex_destroy_fexts(struct rcu_head *head) |
| 145 | { |
Jamal Hadi Salim | 5a7a555 | 2016-09-18 08:45:33 -0400 | [diff] [blame] | 146 | struct tcindex_filter *f = container_of(head, struct tcindex_filter, |
| 147 | rcu); |
Alexei Starovoitov | ed7aa87 | 2015-08-25 20:06:33 -0700 | [diff] [blame] | 148 | |
| 149 | tcf_exts_destroy(&f->result.exts); |
| 150 | kfree(f); |
| 151 | } |
| 152 | |
| 153 | static int tcindex_delete(struct tcf_proto *tp, unsigned long arg) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 154 | { |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 155 | struct tcindex_data *p = rtnl_dereference(tp->root); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 156 | struct tcindex_filter_result *r = (struct tcindex_filter_result *) arg; |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 157 | struct tcindex_filter __rcu **walk; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 158 | struct tcindex_filter *f = NULL; |
| 159 | |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 160 | pr_debug("tcindex_delete(tp %p,arg 0x%lx),p %p\n", tp, arg, p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 161 | if (p->perfect) { |
| 162 | if (!r->res.class) |
| 163 | return -ENOENT; |
| 164 | } else { |
| 165 | int i; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 166 | |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 167 | for (i = 0; i < p->hash; i++) { |
| 168 | walk = p->h + i; |
| 169 | for (f = rtnl_dereference(*walk); f; |
| 170 | walk = &f->next, f = rtnl_dereference(*walk)) { |
| 171 | if (&f->result == r) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 172 | goto found; |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 173 | } |
| 174 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 175 | return -ENOENT; |
| 176 | |
| 177 | found: |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 178 | rcu_assign_pointer(*walk, rtnl_dereference(f->next)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 179 | } |
| 180 | tcf_unbind_filter(tp, &r->res); |
Alexei Starovoitov | ed7aa87 | 2015-08-25 20:06:33 -0700 | [diff] [blame] | 181 | /* all classifiers are required to call tcf_exts_destroy() after rcu |
| 182 | * grace period, since converted-to-rcu actions are relying on that |
| 183 | * in cleanup() callback |
| 184 | */ |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 185 | if (f) |
Alexei Starovoitov | ed7aa87 | 2015-08-25 20:06:33 -0700 | [diff] [blame] | 186 | call_rcu(&f->rcu, tcindex_destroy_fexts); |
| 187 | else |
| 188 | call_rcu(&r->rcu, tcindex_destroy_rexts); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 189 | return 0; |
| 190 | } |
| 191 | |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 192 | static int tcindex_destroy_element(struct tcf_proto *tp, |
| 193 | unsigned long arg, |
| 194 | struct tcf_walker *walker) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | { |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 196 | return tcindex_delete(tp, arg); |
| 197 | } |
| 198 | |
| 199 | static void __tcindex_destroy(struct rcu_head *head) |
| 200 | { |
| 201 | struct tcindex_data *p = container_of(head, struct tcindex_data, rcu); |
| 202 | |
| 203 | kfree(p->perfect); |
| 204 | kfree(p->h); |
| 205 | kfree(p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 206 | } |
| 207 | |
| 208 | static inline int |
| 209 | valid_perfect_hash(struct tcindex_data *p) |
| 210 | { |
| 211 | return p->hash > (p->mask >> p->shift); |
| 212 | } |
| 213 | |
Patrick McHardy | 6fa8c01 | 2008-01-23 20:36:12 -0800 | [diff] [blame] | 214 | static const struct nla_policy tcindex_policy[TCA_TCINDEX_MAX + 1] = { |
| 215 | [TCA_TCINDEX_HASH] = { .type = NLA_U32 }, |
| 216 | [TCA_TCINDEX_MASK] = { .type = NLA_U16 }, |
| 217 | [TCA_TCINDEX_SHIFT] = { .type = NLA_U32 }, |
| 218 | [TCA_TCINDEX_FALL_THROUGH] = { .type = NLA_U32 }, |
| 219 | [TCA_TCINDEX_CLASSID] = { .type = NLA_U32 }, |
| 220 | }; |
| 221 | |
WANG Cong | b9a24bb | 2016-08-19 12:36:54 -0700 | [diff] [blame] | 222 | static int tcindex_filter_result_init(struct tcindex_filter_result *r) |
Cong Wang | bf63ac7 | 2014-05-19 12:15:49 -0700 | [diff] [blame] | 223 | { |
| 224 | memset(r, 0, sizeof(*r)); |
WANG Cong | b9a24bb | 2016-08-19 12:36:54 -0700 | [diff] [blame] | 225 | return tcf_exts_init(&r->exts, TCA_TCINDEX_ACT, TCA_TCINDEX_POLICE); |
Cong Wang | bf63ac7 | 2014-05-19 12:15:49 -0700 | [diff] [blame] | 226 | } |
| 227 | |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 228 | static void __tcindex_partial_destroy(struct rcu_head *head) |
| 229 | { |
| 230 | struct tcindex_data *p = container_of(head, struct tcindex_data, rcu); |
| 231 | |
| 232 | kfree(p->perfect); |
| 233 | kfree(p); |
| 234 | } |
| 235 | |
WANG Cong | b9a24bb | 2016-08-19 12:36:54 -0700 | [diff] [blame] | 236 | static void tcindex_free_perfect_hash(struct tcindex_data *cp) |
| 237 | { |
| 238 | int i; |
| 239 | |
| 240 | for (i = 0; i < cp->hash; i++) |
| 241 | tcf_exts_destroy(&cp->perfect[i].exts); |
| 242 | kfree(cp->perfect); |
| 243 | } |
| 244 | |
| 245 | static int tcindex_alloc_perfect_hash(struct tcindex_data *cp) |
| 246 | { |
| 247 | int i, err = 0; |
| 248 | |
| 249 | cp->perfect = kcalloc(cp->hash, sizeof(struct tcindex_filter_result), |
| 250 | GFP_KERNEL); |
| 251 | if (!cp->perfect) |
| 252 | return -ENOMEM; |
| 253 | |
| 254 | for (i = 0; i < cp->hash; i++) { |
| 255 | err = tcf_exts_init(&cp->perfect[i].exts, |
| 256 | TCA_TCINDEX_ACT, TCA_TCINDEX_POLICE); |
| 257 | if (err < 0) |
| 258 | goto errout; |
| 259 | } |
| 260 | |
| 261 | return 0; |
| 262 | |
| 263 | errout: |
| 264 | tcindex_free_perfect_hash(cp); |
| 265 | return err; |
| 266 | } |
| 267 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 268 | static int |
Benjamin LaHaise | c1b5273 | 2013-01-14 05:15:39 +0000 | [diff] [blame] | 269 | tcindex_set_parms(struct net *net, struct tcf_proto *tp, unsigned long base, |
| 270 | u32 handle, struct tcindex_data *p, |
| 271 | struct tcindex_filter_result *r, struct nlattr **tb, |
Cong Wang | 2f7ef2f | 2014-04-25 13:54:06 -0700 | [diff] [blame] | 272 | struct nlattr *est, bool ovr) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 273 | { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 274 | struct tcindex_filter_result new_filter_result, *old_r = r; |
| 275 | struct tcindex_filter_result cr; |
WANG Cong | b9a24bb | 2016-08-19 12:36:54 -0700 | [diff] [blame] | 276 | struct tcindex_data *cp = NULL, *oldp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 277 | struct tcindex_filter *f = NULL; /* make gcc behave */ |
WANG Cong | b9a24bb | 2016-08-19 12:36:54 -0700 | [diff] [blame] | 278 | int err, balloc = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 279 | struct tcf_exts e; |
| 280 | |
WANG Cong | b9a24bb | 2016-08-19 12:36:54 -0700 | [diff] [blame] | 281 | err = tcf_exts_init(&e, TCA_TCINDEX_ACT, TCA_TCINDEX_POLICE); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 282 | if (err < 0) |
| 283 | return err; |
WANG Cong | b9a24bb | 2016-08-19 12:36:54 -0700 | [diff] [blame] | 284 | err = tcf_exts_validate(net, tp, tb, est, &e, ovr); |
| 285 | if (err < 0) |
| 286 | goto errout; |
YOSHIFUJI Hideaki | 10297b9 | 2007-02-09 23:25:16 +0900 | [diff] [blame] | 287 | |
WANG Cong | 02c5e84 | 2014-09-25 12:06:04 -0700 | [diff] [blame] | 288 | err = -ENOMEM; |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 289 | /* tcindex_data attributes must look atomic to classifier/lookup so |
| 290 | * allocate new tcindex data and RCU assign it onto root. Keeping |
| 291 | * perfect hash and hash pointers from old data. |
| 292 | */ |
WANG Cong | a57a65b | 2014-09-15 14:06:46 -0700 | [diff] [blame] | 293 | cp = kzalloc(sizeof(*cp), GFP_KERNEL); |
WANG Cong | 02c5e84 | 2014-09-25 12:06:04 -0700 | [diff] [blame] | 294 | if (!cp) |
WANG Cong | 44b75e4 | 2014-09-15 16:43:42 -0700 | [diff] [blame] | 295 | goto errout; |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 296 | |
| 297 | cp->mask = p->mask; |
| 298 | cp->shift = p->shift; |
| 299 | cp->hash = p->hash; |
| 300 | cp->alloc_hash = p->alloc_hash; |
| 301 | cp->fall_through = p->fall_through; |
| 302 | cp->tp = tp; |
| 303 | |
| 304 | if (p->perfect) { |
WANG Cong | 6e05656 | 2014-09-30 16:07:23 -0700 | [diff] [blame] | 305 | int i; |
| 306 | |
WANG Cong | b9a24bb | 2016-08-19 12:36:54 -0700 | [diff] [blame] | 307 | if (tcindex_alloc_perfect_hash(cp) < 0) |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 308 | goto errout; |
WANG Cong | 6e05656 | 2014-09-30 16:07:23 -0700 | [diff] [blame] | 309 | for (i = 0; i < cp->hash; i++) |
WANG Cong | b9a24bb | 2016-08-19 12:36:54 -0700 | [diff] [blame] | 310 | cp->perfect[i].res = p->perfect[i].res; |
WANG Cong | 44b75e4 | 2014-09-15 16:43:42 -0700 | [diff] [blame] | 311 | balloc = 1; |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 312 | } |
| 313 | cp->h = p->h; |
| 314 | |
WANG Cong | b9a24bb | 2016-08-19 12:36:54 -0700 | [diff] [blame] | 315 | err = tcindex_filter_result_init(&new_filter_result); |
| 316 | if (err < 0) |
| 317 | goto errout1; |
| 318 | err = tcindex_filter_result_init(&cr); |
| 319 | if (err < 0) |
| 320 | goto errout1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 321 | if (old_r) |
Cong Wang | bf63ac7 | 2014-05-19 12:15:49 -0700 | [diff] [blame] | 322 | cr.res = r->res; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 323 | |
Patrick McHardy | 6fa8c01 | 2008-01-23 20:36:12 -0800 | [diff] [blame] | 324 | if (tb[TCA_TCINDEX_HASH]) |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 325 | cp->hash = nla_get_u32(tb[TCA_TCINDEX_HASH]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 326 | |
Patrick McHardy | 6fa8c01 | 2008-01-23 20:36:12 -0800 | [diff] [blame] | 327 | if (tb[TCA_TCINDEX_MASK]) |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 328 | cp->mask = nla_get_u16(tb[TCA_TCINDEX_MASK]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 329 | |
Patrick McHardy | 6fa8c01 | 2008-01-23 20:36:12 -0800 | [diff] [blame] | 330 | if (tb[TCA_TCINDEX_SHIFT]) |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 331 | cp->shift = nla_get_u32(tb[TCA_TCINDEX_SHIFT]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 332 | |
| 333 | err = -EBUSY; |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 334 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 335 | /* Hash already allocated, make sure that we still meet the |
| 336 | * requirements for the allocated hash. |
| 337 | */ |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 338 | if (cp->perfect) { |
| 339 | if (!valid_perfect_hash(cp) || |
| 340 | cp->hash > cp->alloc_hash) |
WANG Cong | 44b75e4 | 2014-09-15 16:43:42 -0700 | [diff] [blame] | 341 | goto errout_alloc; |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 342 | } else if (cp->h && cp->hash != cp->alloc_hash) { |
WANG Cong | 44b75e4 | 2014-09-15 16:43:42 -0700 | [diff] [blame] | 343 | goto errout_alloc; |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 344 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 345 | |
| 346 | err = -EINVAL; |
Patrick McHardy | 6fa8c01 | 2008-01-23 20:36:12 -0800 | [diff] [blame] | 347 | if (tb[TCA_TCINDEX_FALL_THROUGH]) |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 348 | cp->fall_through = nla_get_u32(tb[TCA_TCINDEX_FALL_THROUGH]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 349 | |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 350 | if (!cp->hash) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 351 | /* Hash not specified, use perfect hash if the upper limit |
| 352 | * of the hashing index is below the threshold. |
| 353 | */ |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 354 | if ((cp->mask >> cp->shift) < PERFECT_HASH_THRESHOLD) |
| 355 | cp->hash = (cp->mask >> cp->shift) + 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 356 | else |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 357 | cp->hash = DEFAULT_HASH_SIZE; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 358 | } |
| 359 | |
WANG Cong | 68f6a7c | 2014-09-25 12:06:05 -0700 | [diff] [blame] | 360 | if (!cp->perfect && !cp->h) |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 361 | cp->alloc_hash = cp->hash; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 362 | |
| 363 | /* Note: this could be as restrictive as if (handle & ~(mask >> shift)) |
| 364 | * but then, we'd fail handles that may become valid after some future |
| 365 | * mask change. While this is extremely unlikely to ever matter, |
| 366 | * the check below is safer (and also more backwards-compatible). |
| 367 | */ |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 368 | if (cp->perfect || valid_perfect_hash(cp)) |
| 369 | if (handle >= cp->alloc_hash) |
WANG Cong | 44b75e4 | 2014-09-15 16:43:42 -0700 | [diff] [blame] | 370 | goto errout_alloc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 371 | |
| 372 | |
| 373 | err = -ENOMEM; |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 374 | if (!cp->perfect && !cp->h) { |
| 375 | if (valid_perfect_hash(cp)) { |
WANG Cong | b9a24bb | 2016-08-19 12:36:54 -0700 | [diff] [blame] | 376 | if (tcindex_alloc_perfect_hash(cp) < 0) |
WANG Cong | 44b75e4 | 2014-09-15 16:43:42 -0700 | [diff] [blame] | 377 | goto errout_alloc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 378 | balloc = 1; |
| 379 | } else { |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 380 | struct tcindex_filter __rcu **hash; |
| 381 | |
| 382 | hash = kcalloc(cp->hash, |
| 383 | sizeof(struct tcindex_filter *), |
| 384 | GFP_KERNEL); |
| 385 | |
| 386 | if (!hash) |
WANG Cong | 44b75e4 | 2014-09-15 16:43:42 -0700 | [diff] [blame] | 387 | goto errout_alloc; |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 388 | |
| 389 | cp->h = hash; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 390 | balloc = 2; |
| 391 | } |
| 392 | } |
| 393 | |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 394 | if (cp->perfect) |
| 395 | r = cp->perfect + handle; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 396 | else |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 397 | r = tcindex_lookup(cp, handle) ? : &new_filter_result; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 398 | |
| 399 | if (r == &new_filter_result) { |
Panagiotis Issaris | 0da974f | 2006-07-21 14:51:30 -0700 | [diff] [blame] | 400 | f = kzalloc(sizeof(*f), GFP_KERNEL); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 401 | if (!f) |
| 402 | goto errout_alloc; |
WANG Cong | 6e05656 | 2014-09-30 16:07:23 -0700 | [diff] [blame] | 403 | f->key = handle; |
WANG Cong | 6e05656 | 2014-09-30 16:07:23 -0700 | [diff] [blame] | 404 | f->next = NULL; |
WANG Cong | b9a24bb | 2016-08-19 12:36:54 -0700 | [diff] [blame] | 405 | err = tcindex_filter_result_init(&f->result); |
| 406 | if (err < 0) { |
| 407 | kfree(f); |
| 408 | goto errout_alloc; |
| 409 | } |
YOSHIFUJI Hideaki | 10297b9 | 2007-02-09 23:25:16 +0900 | [diff] [blame] | 410 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 411 | |
Patrick McHardy | add93b6 | 2008-01-22 22:11:33 -0800 | [diff] [blame] | 412 | if (tb[TCA_TCINDEX_CLASSID]) { |
Patrick McHardy | 1587bac | 2008-01-23 20:35:03 -0800 | [diff] [blame] | 413 | cr.res.classid = nla_get_u32(tb[TCA_TCINDEX_CLASSID]); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 414 | tcf_bind_filter(tp, &cr.res, base); |
YOSHIFUJI Hideaki | 10297b9 | 2007-02-09 23:25:16 +0900 | [diff] [blame] | 415 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 416 | |
Cong Wang | bf63ac7 | 2014-05-19 12:15:49 -0700 | [diff] [blame] | 417 | if (old_r) |
| 418 | tcf_exts_change(tp, &r->exts, &e); |
| 419 | else |
| 420 | tcf_exts_change(tp, &cr.exts, &e); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 421 | |
WANG Cong | b9a24bb | 2016-08-19 12:36:54 -0700 | [diff] [blame] | 422 | if (old_r && old_r != r) { |
| 423 | err = tcindex_filter_result_init(old_r); |
| 424 | if (err < 0) { |
| 425 | kfree(f); |
| 426 | goto errout_alloc; |
| 427 | } |
| 428 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 429 | |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 430 | oldp = p; |
Cong Wang | bf63ac7 | 2014-05-19 12:15:49 -0700 | [diff] [blame] | 431 | r->res = cr.res; |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 432 | rcu_assign_pointer(tp->root, cp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 433 | |
| 434 | if (r == &new_filter_result) { |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 435 | struct tcindex_filter *nfp; |
| 436 | struct tcindex_filter __rcu **fp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 437 | |
WANG Cong | 6e05656 | 2014-09-30 16:07:23 -0700 | [diff] [blame] | 438 | tcf_exts_change(tp, &f->result.exts, &r->exts); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 439 | |
WANG Cong | 69301ea | 2014-09-15 16:43:43 -0700 | [diff] [blame] | 440 | fp = cp->h + (handle % cp->hash); |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 441 | for (nfp = rtnl_dereference(*fp); |
| 442 | nfp; |
| 443 | fp = &nfp->next, nfp = rtnl_dereference(*fp)) |
| 444 | ; /* nothing */ |
| 445 | |
| 446 | rcu_assign_pointer(*fp, f); |
| 447 | } |
| 448 | |
| 449 | if (oldp) |
| 450 | call_rcu(&oldp->rcu, __tcindex_partial_destroy); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 451 | return 0; |
| 452 | |
| 453 | errout_alloc: |
| 454 | if (balloc == 1) |
WANG Cong | b9a24bb | 2016-08-19 12:36:54 -0700 | [diff] [blame] | 455 | tcindex_free_perfect_hash(cp); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 456 | else if (balloc == 2) |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 457 | kfree(cp->h); |
WANG Cong | b9a24bb | 2016-08-19 12:36:54 -0700 | [diff] [blame] | 458 | errout1: |
| 459 | tcf_exts_destroy(&cr.exts); |
| 460 | tcf_exts_destroy(&new_filter_result.exts); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 461 | errout: |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 462 | kfree(cp); |
WANG Cong | 18d0264 | 2014-09-25 10:26:37 -0700 | [diff] [blame] | 463 | tcf_exts_destroy(&e); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 464 | return err; |
| 465 | } |
| 466 | |
| 467 | static int |
Benjamin LaHaise | c1b5273 | 2013-01-14 05:15:39 +0000 | [diff] [blame] | 468 | tcindex_change(struct net *net, struct sk_buff *in_skb, |
Eric W. Biederman | af4c664 | 2012-05-25 13:42:45 -0600 | [diff] [blame] | 469 | struct tcf_proto *tp, unsigned long base, u32 handle, |
Cong Wang | 2f7ef2f | 2014-04-25 13:54:06 -0700 | [diff] [blame] | 470 | struct nlattr **tca, unsigned long *arg, bool ovr) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 471 | { |
Patrick McHardy | add93b6 | 2008-01-22 22:11:33 -0800 | [diff] [blame] | 472 | struct nlattr *opt = tca[TCA_OPTIONS]; |
| 473 | struct nlattr *tb[TCA_TCINDEX_MAX + 1]; |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 474 | struct tcindex_data *p = rtnl_dereference(tp->root); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 475 | struct tcindex_filter_result *r = (struct tcindex_filter_result *) *arg; |
Patrick McHardy | cee6372 | 2008-01-23 20:33:32 -0800 | [diff] [blame] | 476 | int err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 477 | |
Stephen Hemminger | aa767bf | 2008-01-21 02:26:41 -0800 | [diff] [blame] | 478 | pr_debug("tcindex_change(tp %p,handle 0x%08x,tca %p,arg %p),opt %p," |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 479 | "p %p,r %p,*arg 0x%lx\n", |
| 480 | tp, handle, tca, arg, opt, p, r, arg ? *arg : 0L); |
| 481 | |
| 482 | if (!opt) |
| 483 | return 0; |
| 484 | |
Patrick McHardy | 6fa8c01 | 2008-01-23 20:36:12 -0800 | [diff] [blame] | 485 | err = nla_parse_nested(tb, TCA_TCINDEX_MAX, opt, tcindex_policy); |
Patrick McHardy | cee6372 | 2008-01-23 20:33:32 -0800 | [diff] [blame] | 486 | if (err < 0) |
| 487 | return err; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 488 | |
Benjamin LaHaise | c1b5273 | 2013-01-14 05:15:39 +0000 | [diff] [blame] | 489 | return tcindex_set_parms(net, tp, base, handle, p, r, tb, |
Cong Wang | 2f7ef2f | 2014-04-25 13:54:06 -0700 | [diff] [blame] | 490 | tca[TCA_RATE], ovr); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 491 | } |
| 492 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 493 | static void tcindex_walk(struct tcf_proto *tp, struct tcf_walker *walker) |
| 494 | { |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 495 | struct tcindex_data *p = rtnl_dereference(tp->root); |
Stephen Hemminger | aa767bf | 2008-01-21 02:26:41 -0800 | [diff] [blame] | 496 | struct tcindex_filter *f, *next; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 497 | int i; |
| 498 | |
Stephen Hemminger | aa767bf | 2008-01-21 02:26:41 -0800 | [diff] [blame] | 499 | pr_debug("tcindex_walk(tp %p,walker %p),p %p\n", tp, walker, p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 500 | if (p->perfect) { |
| 501 | for (i = 0; i < p->hash; i++) { |
| 502 | if (!p->perfect[i].res.class) |
| 503 | continue; |
| 504 | if (walker->count >= walker->skip) { |
| 505 | if (walker->fn(tp, |
| 506 | (unsigned long) (p->perfect+i), walker) |
| 507 | < 0) { |
| 508 | walker->stop = 1; |
| 509 | return; |
| 510 | } |
| 511 | } |
| 512 | walker->count++; |
| 513 | } |
| 514 | } |
| 515 | if (!p->h) |
| 516 | return; |
| 517 | for (i = 0; i < p->hash; i++) { |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 518 | for (f = rtnl_dereference(p->h[i]); f; f = next) { |
| 519 | next = rtnl_dereference(f->next); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 520 | if (walker->count >= walker->skip) { |
Stephen Hemminger | aa767bf | 2008-01-21 02:26:41 -0800 | [diff] [blame] | 521 | if (walker->fn(tp, (unsigned long) &f->result, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 522 | walker) < 0) { |
| 523 | walker->stop = 1; |
| 524 | return; |
| 525 | } |
| 526 | } |
| 527 | walker->count++; |
| 528 | } |
| 529 | } |
| 530 | } |
| 531 | |
Cong Wang | 1e052be | 2015-03-06 11:47:59 -0800 | [diff] [blame] | 532 | static bool tcindex_destroy(struct tcf_proto *tp, bool force) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 533 | { |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 534 | struct tcindex_data *p = rtnl_dereference(tp->root); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 535 | struct tcf_walker walker; |
| 536 | |
Cong Wang | 1e052be | 2015-03-06 11:47:59 -0800 | [diff] [blame] | 537 | if (!force) |
| 538 | return false; |
| 539 | |
Stephen Hemminger | aa767bf | 2008-01-21 02:26:41 -0800 | [diff] [blame] | 540 | pr_debug("tcindex_destroy(tp %p),p %p\n", tp, p); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 541 | walker.count = 0; |
| 542 | walker.skip = 0; |
Himangi Saraogi | e40f5c7 | 2014-07-25 01:50:41 +0530 | [diff] [blame] | 543 | walker.fn = tcindex_destroy_element; |
Stephen Hemminger | aa767bf | 2008-01-21 02:26:41 -0800 | [diff] [blame] | 544 | tcindex_walk(tp, &walker); |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 545 | |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 546 | call_rcu(&p->rcu, __tcindex_destroy); |
Cong Wang | 1e052be | 2015-03-06 11:47:59 -0800 | [diff] [blame] | 547 | return true; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 548 | } |
| 549 | |
| 550 | |
WANG Cong | 832d1d5 | 2014-01-09 16:14:01 -0800 | [diff] [blame] | 551 | static int tcindex_dump(struct net *net, struct tcf_proto *tp, unsigned long fh, |
Jamal Hadi Salim | 5a7a555 | 2016-09-18 08:45:33 -0400 | [diff] [blame] | 552 | struct sk_buff *skb, struct tcmsg *t) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 553 | { |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 554 | struct tcindex_data *p = rtnl_dereference(tp->root); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 555 | struct tcindex_filter_result *r = (struct tcindex_filter_result *) fh; |
Patrick McHardy | 4b3550ef | 2008-01-23 20:34:11 -0800 | [diff] [blame] | 556 | struct nlattr *nest; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 557 | |
Jiri Pirko | 6ea3b44 | 2014-12-09 22:23:29 +0100 | [diff] [blame] | 558 | pr_debug("tcindex_dump(tp %p,fh 0x%lx,skb %p,t %p),p %p,r %p\n", |
| 559 | tp, fh, skb, t, p, r); |
Stephen Hemminger | aa767bf | 2008-01-21 02:26:41 -0800 | [diff] [blame] | 560 | pr_debug("p->perfect %p p->h %p\n", p->perfect, p->h); |
Patrick McHardy | 4b3550ef | 2008-01-23 20:34:11 -0800 | [diff] [blame] | 561 | |
| 562 | nest = nla_nest_start(skb, TCA_OPTIONS); |
| 563 | if (nest == NULL) |
| 564 | goto nla_put_failure; |
| 565 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 566 | if (!fh) { |
| 567 | t->tcm_handle = ~0; /* whatever ... */ |
David S. Miller | 1b34ec4 | 2012-03-29 05:11:39 -0400 | [diff] [blame] | 568 | if (nla_put_u32(skb, TCA_TCINDEX_HASH, p->hash) || |
| 569 | nla_put_u16(skb, TCA_TCINDEX_MASK, p->mask) || |
| 570 | nla_put_u32(skb, TCA_TCINDEX_SHIFT, p->shift) || |
| 571 | nla_put_u32(skb, TCA_TCINDEX_FALL_THROUGH, p->fall_through)) |
| 572 | goto nla_put_failure; |
Patrick McHardy | 4b3550ef | 2008-01-23 20:34:11 -0800 | [diff] [blame] | 573 | nla_nest_end(skb, nest); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 574 | } else { |
| 575 | if (p->perfect) { |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 576 | t->tcm_handle = r - p->perfect; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 577 | } else { |
| 578 | struct tcindex_filter *f; |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 579 | struct tcindex_filter __rcu **fp; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 580 | int i; |
| 581 | |
| 582 | t->tcm_handle = 0; |
| 583 | for (i = 0; !t->tcm_handle && i < p->hash; i++) { |
John Fastabend | 331b729 | 2014-09-12 20:08:20 -0700 | [diff] [blame] | 584 | fp = &p->h[i]; |
| 585 | for (f = rtnl_dereference(*fp); |
| 586 | !t->tcm_handle && f; |
| 587 | fp = &f->next, f = rtnl_dereference(*fp)) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 588 | if (&f->result == r) |
| 589 | t->tcm_handle = f->key; |
| 590 | } |
| 591 | } |
| 592 | } |
Stephen Hemminger | aa767bf | 2008-01-21 02:26:41 -0800 | [diff] [blame] | 593 | pr_debug("handle = %d\n", t->tcm_handle); |
David S. Miller | 1b34ec4 | 2012-03-29 05:11:39 -0400 | [diff] [blame] | 594 | if (r->res.class && |
| 595 | nla_put_u32(skb, TCA_TCINDEX_CLASSID, r->res.classid)) |
| 596 | goto nla_put_failure; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 597 | |
WANG Cong | 5da57f4 | 2013-12-15 20:15:07 -0800 | [diff] [blame] | 598 | if (tcf_exts_dump(skb, &r->exts) < 0) |
Patrick McHardy | add93b6 | 2008-01-22 22:11:33 -0800 | [diff] [blame] | 599 | goto nla_put_failure; |
Patrick McHardy | 4b3550ef | 2008-01-23 20:34:11 -0800 | [diff] [blame] | 600 | nla_nest_end(skb, nest); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 601 | |
WANG Cong | 5da57f4 | 2013-12-15 20:15:07 -0800 | [diff] [blame] | 602 | if (tcf_exts_dump_stats(skb, &r->exts) < 0) |
Patrick McHardy | add93b6 | 2008-01-22 22:11:33 -0800 | [diff] [blame] | 603 | goto nla_put_failure; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 604 | } |
YOSHIFUJI Hideaki | 10297b9 | 2007-02-09 23:25:16 +0900 | [diff] [blame] | 605 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 606 | return skb->len; |
| 607 | |
Patrick McHardy | add93b6 | 2008-01-22 22:11:33 -0800 | [diff] [blame] | 608 | nla_put_failure: |
Jiri Pirko | 6ea3b44 | 2014-12-09 22:23:29 +0100 | [diff] [blame] | 609 | nla_nest_cancel(skb, nest); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 610 | return -1; |
| 611 | } |
| 612 | |
Patrick McHardy | 2eb9d75 | 2008-01-22 22:10:42 -0800 | [diff] [blame] | 613 | static struct tcf_proto_ops cls_tcindex_ops __read_mostly = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 614 | .kind = "tcindex", |
| 615 | .classify = tcindex_classify, |
| 616 | .init = tcindex_init, |
| 617 | .destroy = tcindex_destroy, |
| 618 | .get = tcindex_get, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 619 | .change = tcindex_change, |
| 620 | .delete = tcindex_delete, |
| 621 | .walk = tcindex_walk, |
| 622 | .dump = tcindex_dump, |
| 623 | .owner = THIS_MODULE, |
| 624 | }; |
| 625 | |
| 626 | static int __init init_tcindex(void) |
| 627 | { |
| 628 | return register_tcf_proto_ops(&cls_tcindex_ops); |
| 629 | } |
| 630 | |
YOSHIFUJI Hideaki | 10297b9 | 2007-02-09 23:25:16 +0900 | [diff] [blame] | 631 | static void __exit exit_tcindex(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 632 | { |
| 633 | unregister_tcf_proto_ops(&cls_tcindex_ops); |
| 634 | } |
| 635 | |
| 636 | module_init(init_tcindex) |
| 637 | module_exit(exit_tcindex) |
| 638 | MODULE_LICENSE("GPL"); |