net/sched/cls_matchall.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * net/sched/cls_matchll.c              Match-all classifier
   4  *
   5  * Copyright (c) 2016 Jiri Pirko <jiri@mellanox.com>
   6  */
   7
   8 #include <linux/kernel.h>
   9 #include <linux/init.h>
  10 #include <linux/module.h>
  11 #include <linux/percpu.h>
  12
  13 #include <net/sch_generic.h>
  14 #include <net/pkt_cls.h>
  15 #include <net/tc_wrapper.h>
  16
  17 struct cls_mall_head {
  18         struct tcf_exts exts;
  19         struct tcf_result res;
  20         u32 handle;
  21         u32 flags;
  22         unsigned int in_hw_count;
  23         struct tc_matchall_pcnt __percpu *pf;
  24         struct rcu_work rwork;
  25         bool deleting;
  26 };
  27
  28 TC_INDIRECT_SCOPE int mall_classify(struct sk_buff *skb,
  29                                     const struct tcf_proto *tp,
  30                                     struct tcf_result *res)
  31 {
  32         struct cls_mall_head *head = rcu_dereference_bh(tp->root);
  33
  34         if (unlikely(!head))
  35                 return -1;
  36
  37         if (tc_skip_sw(head->flags))
  38                 return -1;
  39
  40         *res = head->res;
  41         __this_cpu_inc(head->pf->rhit);
  42         return tcf_exts_exec(skb, &head->exts, res);
  43 }
  44
  45 static int mall_init(struct tcf_proto *tp)
  46 {
  47         return 0;
  48 }
  49
  50 static void __mall_destroy(struct cls_mall_head *head)
  51 {
  52         tcf_exts_destroy(&head->exts);
  53         tcf_exts_put_net(&head->exts);
  54         free_percpu(head->pf);
  55         kfree(head);
  56 }
  57
  58 static void mall_destroy_work(struct work_struct *work)
  59 {
  60         struct cls_mall_head *head = container_of(to_rcu_work(work),
  61                                                   struct cls_mall_head,
  62                                                   rwork);
  63         rtnl_lock();
  64         __mall_destroy(head);
  65         rtnl_unlock();
  66 }
  67
  68 static void mall_destroy_hw_filter(struct tcf_proto *tp,
  69                                    struct cls_mall_head *head,
  70                                    unsigned long cookie,
  71                                    struct netlink_ext_ack *extack)
  72 {
  73         struct tc_cls_matchall_offload cls_mall = {};
  74         struct tcf_block *block = tp->chain->block;
  75
  76         tc_cls_common_offload_init(&cls_mall.common, tp, head->flags, extack);
  77         cls_mall.command = TC_CLSMATCHALL_DESTROY;
  78         cls_mall.cookie = cookie;
  79
  80         tc_setup_cb_destroy(block, tp, TC_SETUP_CLSMATCHALL, &cls_mall, false,
  81                             &head->flags, &head->in_hw_count, true);
  82 }
  83
  84 static int mall_replace_hw_filter(struct tcf_proto *tp,
  85                                   struct cls_mall_head *head,
  86                                   unsigned long cookie,
  87                                   struct netlink_ext_ack *extack)
  88 {
  89         struct tc_cls_matchall_offload cls_mall = {};
  90         struct tcf_block *block = tp->chain->block;
  91         bool skip_sw = tc_skip_sw(head->flags);
  92         int err;
  93
  94         cls_mall.rule = flow_rule_alloc(tcf_exts_num_actions(&head->exts));
  95         if (!cls_mall.rule)
  96                 return -ENOMEM;
  97
  98         tc_cls_common_offload_init(&cls_mall.common, tp, head->flags, extack);
  99         cls_mall.command = TC_CLSMATCHALL_REPLACE;
 100         cls_mall.cookie = cookie;
 101
 102         err = tc_setup_offload_action(&cls_mall.rule->action, &head->exts,
 103                                       cls_mall.common.extack);
 104         if (err) {
 105                 kfree(cls_mall.rule);
 106                 mall_destroy_hw_filter(tp, head, cookie, NULL);
 107
 108                 return skip_sw ? err : 0;
 109         }
 110
 111         err = tc_setup_cb_add(block, tp, TC_SETUP_CLSMATCHALL, &cls_mall,
 112                               skip_sw, &head->flags, &head->in_hw_count, true);
 113         tc_cleanup_offload_action(&cls_mall.rule->action);
 114         kfree(cls_mall.rule);
 115
 116         if (err) {
 117                 mall_destroy_hw_filter(tp, head, cookie, NULL);
 118                 return err;
 119         }
 120
 121         if (skip_sw && !(head->flags & TCA_CLS_FLAGS_IN_HW))
 122                 return -EINVAL;
 123
 124         return 0;
 125 }
 126
 127 static void mall_destroy(struct tcf_proto *tp, bool rtnl_held,
 128                          struct netlink_ext_ack *extack)
 129 {
 130         struct cls_mall_head *head = rtnl_dereference(tp->root);
 131
 132         if (!head)
 133                 return;
 134
 135         tcf_unbind_filter(tp, &head->res);
 136
 137         if (!tc_skip_hw(head->flags))
 138                 mall_destroy_hw_filter(tp, head, (unsigned long) head, extack);
 139
 140         if (tcf_exts_get_net(&head->exts))
 141                 tcf_queue_work(&head->rwork, mall_destroy_work);
 142         else
 143                 __mall_destroy(head);
 144 }
 145
 146 static void *mall_get(struct tcf_proto *tp, u32 handle)
 147 {
 148         struct cls_mall_head *head = rtnl_dereference(tp->root);
 149
 150         if (head && head->handle == handle)
 151                 return head;
 152
 153         return NULL;
 154 }
 155
 156 static const struct nla_policy mall_policy[TCA_MATCHALL_MAX + 1] = {
 157         [TCA_MATCHALL_UNSPEC]           = { .type = NLA_UNSPEC },
 158         [TCA_MATCHALL_CLASSID]          = { .type = NLA_U32 },
 159         [TCA_MATCHALL_FLAGS]            = { .type = NLA_U32 },
 160 };
 161
 162 static int mall_set_parms(struct net *net, struct tcf_proto *tp,
 163                           struct cls_mall_head *head,
 164                           unsigned long base, struct nlattr **tb,
 165                           struct nlattr *est, u32 flags, u32 fl_flags,
 166                           struct netlink_ext_ack *extack)
 167 {
 168         int err;
 169
 170         err = tcf_exts_validate_ex(net, tp, tb, est, &head->exts, flags,
 171                                    fl_flags, extack);
 172         if (err < 0)
 173                 return err;
 174
 175         if (tb[TCA_MATCHALL_CLASSID]) {
 176                 head->res.classid = nla_get_u32(tb[TCA_MATCHALL_CLASSID]);
 177                 tcf_bind_filter(tp, &head->res, base);
 178         }
 179         return 0;
 180 }
 181
 182 static int mall_change(struct net *net, struct sk_buff *in_skb,
 183                        struct tcf_proto *tp, unsigned long base,
 184                        u32 handle, struct nlattr **tca,
 185                        void **arg, u32 flags,
 186                        struct netlink_ext_ack *extack)
 187 {
 188         struct cls_mall_head *head = rtnl_dereference(tp->root);
 189         struct nlattr *tb[TCA_MATCHALL_MAX + 1];
 190         struct cls_mall_head *new;
 191         u32 userflags = 0;
 192         int err;
 193
 194         if (!tca[TCA_OPTIONS])
 195                 return -EINVAL;
 196
 197         if (head)
 198                 return -EEXIST;
 199
 200         err = nla_parse_nested_deprecated(tb, TCA_MATCHALL_MAX,
 201                                           tca[TCA_OPTIONS], mall_policy, NULL);
 202         if (err < 0)
 203                 return err;
 204
 205         if (tb[TCA_MATCHALL_FLAGS]) {
 206                 userflags = nla_get_u32(tb[TCA_MATCHALL_FLAGS]);
 207                 if (!tc_flags_valid(userflags))
 208                         return -EINVAL;
 209         }
 210
 211         new = kzalloc(sizeof(*new), GFP_KERNEL);
 212         if (!new)
 213                 return -ENOBUFS;
 214
 215         err = tcf_exts_init(&new->exts, net, TCA_MATCHALL_ACT, 0);
 216         if (err)
 217                 goto err_exts_init;
 218
 219         if (!handle)
 220                 handle = 1;
 221         new->handle = handle;
 222         new->flags = userflags;
 223         new->pf = alloc_percpu(struct tc_matchall_pcnt);
 224         if (!new->pf) {
 225                 err = -ENOMEM;
 226                 goto err_alloc_percpu;
 227         }
 228
 229         err = mall_set_parms(net, tp, new, base, tb, tca[TCA_RATE],
 230                              flags, new->flags, extack);
 231         if (err)
 232                 goto err_set_parms;
 233
 234         if (!tc_skip_hw(new->flags)) {
 235                 err = mall_replace_hw_filter(tp, new, (unsigned long)new,
 236                                              extack);
 237                 if (err)
 238                         goto err_replace_hw_filter;
 239         }
 240
 241         if (!tc_in_hw(new->flags))
 242                 new->flags |= TCA_CLS_FLAGS_NOT_IN_HW;
 243
 244         *arg = head;
 245         rcu_assign_pointer(tp->root, new);
 246         return 0;
 247
 248 err_replace_hw_filter:
 249 err_set_parms:
 250         free_percpu(new->pf);
 251 err_alloc_percpu:
 252         tcf_exts_destroy(&new->exts);
 253 err_exts_init:
 254         kfree(new);
 255         return err;
 256 }
 257
 258 static int mall_delete(struct tcf_proto *tp, void *arg, bool *last,
 259                        bool rtnl_held, struct netlink_ext_ack *extack)
 260 {
 261         struct cls_mall_head *head = rtnl_dereference(tp->root);
 262
 263         head->deleting = true;
 264         *last = true;
 265         return 0;
 266 }
 267
 268 static void mall_walk(struct tcf_proto *tp, struct tcf_walker *arg,
 269                       bool rtnl_held)
 270 {
 271         struct cls_mall_head *head = rtnl_dereference(tp->root);
 272
 273         if (arg->count < arg->skip)
 274                 goto skip;
 275
 276         if (!head || head->deleting)
 277                 return;
 278         if (arg->fn(tp, head, arg) < 0)
 279                 arg->stop = 1;
 280 skip:
 281         arg->count++;
 282 }
 283
 284 static int mall_reoffload(struct tcf_proto *tp, bool add, flow_setup_cb_t *cb,
 285                           void *cb_priv, struct netlink_ext_ack *extack)
 286 {
 287         struct cls_mall_head *head = rtnl_dereference(tp->root);
 288         struct tc_cls_matchall_offload cls_mall = {};
 289         struct tcf_block *block = tp->chain->block;
 290         int err;
 291
 292         if (tc_skip_hw(head->flags))
 293                 return 0;
 294
 295         cls_mall.rule = flow_rule_alloc(tcf_exts_num_actions(&head->exts));
 296         if (!cls_mall.rule)
 297                 return -ENOMEM;
 298
 299         tc_cls_common_offload_init(&cls_mall.common, tp, head->flags, extack);
 300         cls_mall.command = add ?
 301                 TC_CLSMATCHALL_REPLACE : TC_CLSMATCHALL_DESTROY;
 302         cls_mall.cookie = (unsigned long)head;
 303
 304         err = tc_setup_offload_action(&cls_mall.rule->action, &head->exts,
 305                                       cls_mall.common.extack);
 306         if (err) {
 307                 kfree(cls_mall.rule);
 308
 309                 return add && tc_skip_sw(head->flags) ? err : 0;
 310         }
 311
 312         err = tc_setup_cb_reoffload(block, tp, add, cb, TC_SETUP_CLSMATCHALL,
 313                                     &cls_mall, cb_priv, &head->flags,
 314                                     &head->in_hw_count);
 315         tc_cleanup_offload_action(&cls_mall.rule->action);
 316         kfree(cls_mall.rule);
 317
 318         return err;
 319 }
 320
 321 static void mall_stats_hw_filter(struct tcf_proto *tp,
 322                                  struct cls_mall_head *head,
 323                                  unsigned long cookie)
 324 {
 325         struct tc_cls_matchall_offload cls_mall = {};
 326         struct tcf_block *block = tp->chain->block;
 327
 328         tc_cls_common_offload_init(&cls_mall.common, tp, head->flags, NULL);
 329         cls_mall.command = TC_CLSMATCHALL_STATS;
 330         cls_mall.cookie = cookie;
 331
 332         tc_setup_cb_call(block, TC_SETUP_CLSMATCHALL, &cls_mall, false, true);
 333
 334         tcf_exts_hw_stats_update(&head->exts, &cls_mall.stats, cls_mall.use_act_stats);
 335 }
 336
 337 static int mall_dump(struct net *net, struct tcf_proto *tp, void *fh,
 338                      struct sk_buff *skb, struct tcmsg *t, bool rtnl_held)
 339 {
 340         struct tc_matchall_pcnt gpf = {};
 341         struct cls_mall_head *head = fh;
 342         struct nlattr *nest;
 343         int cpu;
 344
 345         if (!head)
 346                 return skb->len;
 347
 348         if (!tc_skip_hw(head->flags))
 349                 mall_stats_hw_filter(tp, head, (unsigned long)head);
 350
 351         t->tcm_handle = head->handle;
 352
 353         nest = nla_nest_start_noflag(skb, TCA_OPTIONS);
 354         if (!nest)
 355                 goto nla_put_failure;
 356
 357         if (head->res.classid &&
 358             nla_put_u32(skb, TCA_MATCHALL_CLASSID, head->res.classid))
 359                 goto nla_put_failure;
 360
 361         if (head->flags && nla_put_u32(skb, TCA_MATCHALL_FLAGS, head->flags))
 362                 goto nla_put_failure;
 363
 364         for_each_possible_cpu(cpu) {
 365                 struct tc_matchall_pcnt *pf = per_cpu_ptr(head->pf, cpu);
 366
 367                 gpf.rhit += pf->rhit;
 368         }
 369
 370         if (nla_put_64bit(skb, TCA_MATCHALL_PCNT,
 371                           sizeof(struct tc_matchall_pcnt),
 372                           &gpf, TCA_MATCHALL_PAD))
 373                 goto nla_put_failure;
 374
 375         if (tcf_exts_dump(skb, &head->exts))
 376                 goto nla_put_failure;
 377
 378         nla_nest_end(skb, nest);
 379
 380         if (tcf_exts_dump_stats(skb, &head->exts) < 0)
 381                 goto nla_put_failure;
 382
 383         return skb->len;
 384
 385 nla_put_failure:
 386         nla_nest_cancel(skb, nest);
 387         return -1;
 388 }
 389
 390 static void mall_bind_class(void *fh, u32 classid, unsigned long cl, void *q,
 391                             unsigned long base)
 392 {
 393         struct cls_mall_head *head = fh;
 394
 395         tc_cls_bind_class(classid, cl, q, &head->res, base);
 396 }
 397
 398 static struct tcf_proto_ops cls_mall_ops __read_mostly = {
 399         .kind           = "matchall",
 400         .classify       = mall_classify,
 401         .init           = mall_init,
 402         .destroy        = mall_destroy,
 403         .get            = mall_get,
 404         .change         = mall_change,
 405         .delete         = mall_delete,
 406         .walk           = mall_walk,
 407         .reoffload      = mall_reoffload,
 408         .dump           = mall_dump,
 409         .bind_class     = mall_bind_class,
 410         .owner          = THIS_MODULE,
 411 };
 412
 413 static int __init cls_mall_init(void)
 414 {
 415         return register_tcf_proto_ops(&cls_mall_ops);
 416 }
 417
 418 static void __exit cls_mall_exit(void)
 419 {
 420         unregister_tcf_proto_ops(&cls_mall_ops);
 421 }
 422
 423 module_init(cls_mall_init);
 424 module_exit(cls_mall_exit);
 425
 426 MODULE_AUTHOR("Jiri Pirko <jiri@mellanox.com>");
 427 MODULE_DESCRIPTION("Match-all classifier");
 428 MODULE_LICENSE("GPL v2");