1 /* 2 * net/sched/cls_matchll.c Match-all classifier 3 * 4 * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com> 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 */ 11 12 #include <linux/kernel.h> 13 #include <linux/init.h> 14 #include <linux/module.h> 15 16 #include <net/sch_generic.h> 17 #include <net/pkt_cls.h> 18 19 struct cls_mall_head { 20 struct tcf_exts exts; 21 struct tcf_result res; 22 u32 handle; 23 u32 flags; 24 unsigned int in_hw_count; 25 struct rcu_work rwork; 26 }; 27 28 static int mall_classify(struct sk_buff *skb, const struct tcf_proto *tp, 29 struct tcf_result *res) 30 { 31 struct cls_mall_head *head = rcu_dereference_bh(tp->root); 32 33 if (tc_skip_sw(head->flags)) 34 return -1; 35 36 *res = head->res; 37 return tcf_exts_exec(skb, &head->exts, res); 38 } 39 40 static int mall_init(struct tcf_proto *tp) 41 { 42 return 0; 43 } 44 45 static void __mall_destroy(struct cls_mall_head *head) 46 { 47 tcf_exts_destroy(&head->exts); 48 tcf_exts_put_net(&head->exts); 49 kfree(head); 50 } 51 52 static void mall_destroy_work(struct work_struct *work) 53 { 54 struct cls_mall_head *head = container_of(to_rcu_work(work), 55 struct cls_mall_head, 56 rwork); 57 rtnl_lock(); 58 __mall_destroy(head); 59 rtnl_unlock(); 60 } 61 62 static void mall_destroy_hw_filter(struct tcf_proto *tp, 63 struct cls_mall_head *head, 64 unsigned long cookie, 65 struct netlink_ext_ack *extack) 66 { 67 struct tc_cls_matchall_offload cls_mall = {}; 68 struct tcf_block *block = tp->chain->block; 69 70 tc_cls_common_offload_init(&cls_mall.common, tp, head->flags, extack); 71 cls_mall.command = TC_CLSMATCHALL_DESTROY; 72 cls_mall.cookie = cookie; 73 74 tc_setup_cb_call(block, TC_SETUP_CLSMATCHALL, &cls_mall, false); 75 tcf_block_offload_dec(block, &head->flags); 76 } 77 78 static int mall_replace_hw_filter(struct tcf_proto *tp, 79 struct cls_mall_head *head, 80 unsigned long cookie, 81 struct netlink_ext_ack *extack) 82 { 83 struct tc_cls_matchall_offload cls_mall = {}; 84 struct tcf_block *block = tp->chain->block; 85 bool skip_sw = tc_skip_sw(head->flags); 86 int err; 87 88 tc_cls_common_offload_init(&cls_mall.common, tp, head->flags, extack); 89 cls_mall.command = TC_CLSMATCHALL_REPLACE; 90 cls_mall.exts = &head->exts; 91 cls_mall.cookie = cookie; 92 93 err = tc_setup_cb_call(block, TC_SETUP_CLSMATCHALL, &cls_mall, skip_sw); 94 if (err < 0) { 95 mall_destroy_hw_filter(tp, head, cookie, NULL); 96 return err; 97 } else if (err > 0) { 98 head->in_hw_count = err; 99 tcf_block_offload_inc(block, &head->flags); 100 } 101 102 if (skip_sw && !(head->flags & TCA_CLS_FLAGS_IN_HW)) 103 return -EINVAL; 104 105 return 0; 106 } 107 108 static void mall_destroy(struct tcf_proto *tp, struct netlink_ext_ack *extack) 109 { 110 struct cls_mall_head *head = rtnl_dereference(tp->root); 111 112 if (!head) 113 return; 114 115 tcf_unbind_filter(tp, &head->res); 116 117 if (!tc_skip_hw(head->flags)) 118 mall_destroy_hw_filter(tp, head, (unsigned long) head, extack); 119 120 if (tcf_exts_get_net(&head->exts)) 121 tcf_queue_work(&head->rwork, mall_destroy_work); 122 else 123 __mall_destroy(head); 124 } 125 126 static void *mall_get(struct tcf_proto *tp, u32 handle) 127 { 128 return NULL; 129 } 130 131 static const struct nla_policy mall_policy[TCA_MATCHALL_MAX + 1] = { 132 [TCA_MATCHALL_UNSPEC] = { .type = NLA_UNSPEC }, 133 [TCA_MATCHALL_CLASSID] = { .type = NLA_U32 }, 134 }; 135 136 static int mall_set_parms(struct net *net, struct tcf_proto *tp, 137 struct cls_mall_head *head, 138 unsigned long base, struct nlattr **tb, 139 struct nlattr *est, bool ovr, 140 struct netlink_ext_ack *extack) 141 { 142 int err; 143 144 err = tcf_exts_validate(net, tp, tb, est, &head->exts, ovr, extack); 145 if (err < 0) 146 return err; 147 148 if (tb[TCA_MATCHALL_CLASSID]) { 149 head->res.classid = nla_get_u32(tb[TCA_MATCHALL_CLASSID]); 150 tcf_bind_filter(tp, &head->res, base); 151 } 152 return 0; 153 } 154 155 static int mall_change(struct net *net, struct sk_buff *in_skb, 156 struct tcf_proto *tp, unsigned long base, 157 u32 handle, struct nlattr **tca, 158 void **arg, bool ovr, struct netlink_ext_ack *extack) 159 { 160 struct cls_mall_head *head = rtnl_dereference(tp->root); 161 struct nlattr *tb[TCA_MATCHALL_MAX + 1]; 162 struct cls_mall_head *new; 163 u32 flags = 0; 164 int err; 165 166 if (!tca[TCA_OPTIONS]) 167 return -EINVAL; 168 169 if (head) 170 return -EEXIST; 171 172 err = nla_parse_nested(tb, TCA_MATCHALL_MAX, tca[TCA_OPTIONS], 173 mall_policy, NULL); 174 if (err < 0) 175 return err; 176 177 if (tb[TCA_MATCHALL_FLAGS]) { 178 flags = nla_get_u32(tb[TCA_MATCHALL_FLAGS]); 179 if (!tc_flags_valid(flags)) 180 return -EINVAL; 181 } 182 183 new = kzalloc(sizeof(*new), GFP_KERNEL); 184 if (!new) 185 return -ENOBUFS; 186 187 err = tcf_exts_init(&new->exts, TCA_MATCHALL_ACT, 0); 188 if (err) 189 goto err_exts_init; 190 191 if (!handle) 192 handle = 1; 193 new->handle = handle; 194 new->flags = flags; 195 196 err = mall_set_parms(net, tp, new, base, tb, tca[TCA_RATE], ovr, 197 extack); 198 if (err) 199 goto err_set_parms; 200 201 if (!tc_skip_hw(new->flags)) { 202 err = mall_replace_hw_filter(tp, new, (unsigned long)new, 203 extack); 204 if (err) 205 goto err_replace_hw_filter; 206 } 207 208 if (!tc_in_hw(new->flags)) 209 new->flags |= TCA_CLS_FLAGS_NOT_IN_HW; 210 211 *arg = head; 212 rcu_assign_pointer(tp->root, new); 213 return 0; 214 215 err_replace_hw_filter: 216 err_set_parms: 217 tcf_exts_destroy(&new->exts); 218 err_exts_init: 219 kfree(new); 220 return err; 221 } 222 223 static int mall_delete(struct tcf_proto *tp, void *arg, bool *last, 224 struct netlink_ext_ack *extack) 225 { 226 return -EOPNOTSUPP; 227 } 228 229 static void mall_walk(struct tcf_proto *tp, struct tcf_walker *arg) 230 { 231 struct cls_mall_head *head = rtnl_dereference(tp->root); 232 233 if (arg->count < arg->skip) 234 goto skip; 235 if (arg->fn(tp, head, arg) < 0) 236 arg->stop = 1; 237 skip: 238 arg->count++; 239 } 240 241 static int mall_reoffload(struct tcf_proto *tp, bool add, tc_setup_cb_t *cb, 242 void *cb_priv, struct netlink_ext_ack *extack) 243 { 244 struct cls_mall_head *head = rtnl_dereference(tp->root); 245 struct tc_cls_matchall_offload cls_mall = {}; 246 struct tcf_block *block = tp->chain->block; 247 int err; 248 249 if (tc_skip_hw(head->flags)) 250 return 0; 251 252 tc_cls_common_offload_init(&cls_mall.common, tp, head->flags, extack); 253 cls_mall.command = add ? 254 TC_CLSMATCHALL_REPLACE : TC_CLSMATCHALL_DESTROY; 255 cls_mall.exts = &head->exts; 256 cls_mall.cookie = (unsigned long)head; 257 258 err = cb(TC_SETUP_CLSMATCHALL, &cls_mall, cb_priv); 259 if (err) { 260 if (add && tc_skip_sw(head->flags)) 261 return err; 262 return 0; 263 } 264 265 tc_cls_offload_cnt_update(block, &head->in_hw_count, &head->flags, add); 266 267 return 0; 268 } 269 270 static int mall_dump(struct net *net, struct tcf_proto *tp, void *fh, 271 struct sk_buff *skb, struct tcmsg *t) 272 { 273 struct cls_mall_head *head = fh; 274 struct nlattr *nest; 275 276 if (!head) 277 return skb->len; 278 279 t->tcm_handle = head->handle; 280 281 nest = nla_nest_start(skb, TCA_OPTIONS); 282 if (!nest) 283 goto nla_put_failure; 284 285 if (head->res.classid && 286 nla_put_u32(skb, TCA_MATCHALL_CLASSID, head->res.classid)) 287 goto nla_put_failure; 288 289 if (head->flags && nla_put_u32(skb, TCA_MATCHALL_FLAGS, head->flags)) 290 goto nla_put_failure; 291 292 if (tcf_exts_dump(skb, &head->exts)) 293 goto nla_put_failure; 294 295 nla_nest_end(skb, nest); 296 297 if (tcf_exts_dump_stats(skb, &head->exts) < 0) 298 goto nla_put_failure; 299 300 return skb->len; 301 302 nla_put_failure: 303 nla_nest_cancel(skb, nest); 304 return -1; 305 } 306 307 static void mall_bind_class(void *fh, u32 classid, unsigned long cl) 308 { 309 struct cls_mall_head *head = fh; 310 311 if (head && head->res.classid == classid) 312 head->res.class = cl; 313 } 314 315 static struct tcf_proto_ops cls_mall_ops __read_mostly = { 316 .kind = "matchall", 317 .classify = mall_classify, 318 .init = mall_init, 319 .destroy = mall_destroy, 320 .get = mall_get, 321 .change = mall_change, 322 .delete = mall_delete, 323 .walk = mall_walk, 324 .reoffload = mall_reoffload, 325 .dump = mall_dump, 326 .bind_class = mall_bind_class, 327 .owner = THIS_MODULE, 328 }; 329 330 static int __init cls_mall_init(void) 331 { 332 return register_tcf_proto_ops(&cls_mall_ops); 333 } 334 335 static void __exit cls_mall_exit(void) 336 { 337 unregister_tcf_proto_ops(&cls_mall_ops); 338 } 339 340 module_init(cls_mall_init); 341 module_exit(cls_mall_exit); 342 343 MODULE_AUTHOR("Jiri Pirko <jiri@mellanox.com>"); 344 MODULE_DESCRIPTION("Match-all classifier"); 345 MODULE_LICENSE("GPL v2"); 346