net/sched/sch_ingress.c

   1 /* net/sched/sch_ingress.c - Ingress and clsact qdisc
   2  *
   3  *              This program is free software; you can redistribute it and/or
   4  *              modify it under the terms of the GNU General Public License
   5  *              as published by the Free Software Foundation; either version
   6  *              2 of the License, or (at your option) any later version.
   7  *
   8  * Authors:     Jamal Hadi Salim 1999
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/types.h>
  13 #include <linux/list.h>
  14 #include <linux/skbuff.h>
  15 #include <linux/rtnetlink.h>
  16
  17 #include <net/netlink.h>
  18 #include <net/pkt_sched.h>
  19
  20 static struct Qdisc *ingress_leaf(struct Qdisc *sch, unsigned long arg)
  21 {
  22         return NULL;
  23 }
  24
  25 static unsigned long ingress_get(struct Qdisc *sch, u32 classid)
  26 {
  27         return TC_H_MIN(classid) + 1;
  28 }
  29
  30 static bool ingress_cl_offload(u32 classid)
  31 {
  32         return true;
  33 }
  34
  35 static unsigned long ingress_bind_filter(struct Qdisc *sch,
  36                                          unsigned long parent, u32 classid)
  37 {
  38         return ingress_get(sch, classid);
  39 }
  40
  41 static void ingress_put(struct Qdisc *sch, unsigned long cl)
  42 {
  43 }
  44
  45 static void ingress_walk(struct Qdisc *sch, struct qdisc_walker *walker)
  46 {
  47 }
  48
  49 static struct tcf_proto __rcu **ingress_find_tcf(struct Qdisc *sch,
  50                                                  unsigned long cl)
  51 {
  52         struct net_device *dev = qdisc_dev(sch);
  53
  54         return &dev->ingress_cl_list;
  55 }
  56
  57 static int ingress_init(struct Qdisc *sch, struct nlattr *opt)
  58 {
  59         net_inc_ingress_queue();
  60         sch->flags |= TCQ_F_CPUSTATS;
  61
  62         return 0;
  63 }
  64
  65 static void ingress_destroy(struct Qdisc *sch)
  66 {
  67         struct net_device *dev = qdisc_dev(sch);
  68
  69         tcf_destroy_chain(&dev->ingress_cl_list);
  70         net_dec_ingress_queue();
  71 }
  72
  73 static int ingress_dump(struct Qdisc *sch, struct sk_buff *skb)
  74 {
  75         struct nlattr *nest;
  76
  77         nest = nla_nest_start(skb, TCA_OPTIONS);
  78         if (nest == NULL)
  79                 goto nla_put_failure;
  80
  81         return nla_nest_end(skb, nest);
  82
  83 nla_put_failure:
  84         nla_nest_cancel(skb, nest);
  85         return -1;
  86 }
  87
  88 static const struct Qdisc_class_ops ingress_class_ops = {
  89         .leaf           =       ingress_leaf,
  90         .get            =       ingress_get,
  91         .put            =       ingress_put,
  92         .walk           =       ingress_walk,
  93         .tcf_chain      =       ingress_find_tcf,
  94         .tcf_cl_offload =       ingress_cl_offload,
  95         .bind_tcf       =       ingress_bind_filter,
  96         .unbind_tcf     =       ingress_put,
  97 };
  98
  99 static struct Qdisc_ops ingress_qdisc_ops __read_mostly = {
 100         .cl_ops         =       &ingress_class_ops,
 101         .id             =       "ingress",
 102         .init           =       ingress_init,
 103         .destroy        =       ingress_destroy,
 104         .dump           =       ingress_dump,
 105         .owner          =       THIS_MODULE,
 106 };
 107
 108 static unsigned long clsact_get(struct Qdisc *sch, u32 classid)
 109 {
 110         switch (TC_H_MIN(classid)) {
 111         case TC_H_MIN(TC_H_MIN_INGRESS):
 112         case TC_H_MIN(TC_H_MIN_EGRESS):
 113                 return TC_H_MIN(classid);
 114         default:
 115                 return 0;
 116         }
 117 }
 118
 119 static bool clsact_cl_offload(u32 classid)
 120 {
 121         return TC_H_MIN(classid) == TC_H_MIN(TC_H_MIN_INGRESS);
 122 }
 123
 124 static unsigned long clsact_bind_filter(struct Qdisc *sch,
 125                                         unsigned long parent, u32 classid)
 126 {
 127         return clsact_get(sch, classid);
 128 }
 129
 130 static struct tcf_proto __rcu **clsact_find_tcf(struct Qdisc *sch,
 131                                                 unsigned long cl)
 132 {
 133         struct net_device *dev = qdisc_dev(sch);
 134
 135         switch (cl) {
 136         case TC_H_MIN(TC_H_MIN_INGRESS):
 137                 return &dev->ingress_cl_list;
 138         case TC_H_MIN(TC_H_MIN_EGRESS):
 139                 return &dev->egress_cl_list;
 140         default:
 141                 return NULL;
 142         }
 143 }
 144
 145 static int clsact_init(struct Qdisc *sch, struct nlattr *opt)
 146 {
 147         net_inc_ingress_queue();
 148         net_inc_egress_queue();
 149
 150         sch->flags |= TCQ_F_CPUSTATS;
 151
 152         return 0;
 153 }
 154
 155 static void clsact_destroy(struct Qdisc *sch)
 156 {
 157         struct net_device *dev = qdisc_dev(sch);
 158
 159         tcf_destroy_chain(&dev->ingress_cl_list);
 160         tcf_destroy_chain(&dev->egress_cl_list);
 161
 162         net_dec_ingress_queue();
 163         net_dec_egress_queue();
 164 }
 165
 166 static const struct Qdisc_class_ops clsact_class_ops = {
 167         .leaf           =       ingress_leaf,
 168         .get            =       clsact_get,
 169         .put            =       ingress_put,
 170         .walk           =       ingress_walk,
 171         .tcf_chain      =       clsact_find_tcf,
 172         .tcf_cl_offload =       clsact_cl_offload,
 173         .bind_tcf       =       clsact_bind_filter,
 174         .unbind_tcf     =       ingress_put,
 175 };
 176
 177 static struct Qdisc_ops clsact_qdisc_ops __read_mostly = {
 178         .cl_ops         =       &clsact_class_ops,
 179         .id             =       "clsact",
 180         .init           =       clsact_init,
 181         .destroy        =       clsact_destroy,
 182         .dump           =       ingress_dump,
 183         .owner          =       THIS_MODULE,
 184 };
 185
 186 static int __init ingress_module_init(void)
 187 {
 188         int ret;
 189
 190         ret = register_qdisc(&ingress_qdisc_ops);
 191         if (!ret) {
 192                 ret = register_qdisc(&clsact_qdisc_ops);
 193                 if (ret)
 194                         unregister_qdisc(&ingress_qdisc_ops);
 195         }
 196
 197         return ret;
 198 }
 199
 200 static void __exit ingress_module_exit(void)
 201 {
 202         unregister_qdisc(&ingress_qdisc_ops);
 203         unregister_qdisc(&clsact_qdisc_ops);
 204 }
 205
 206 module_init(ingress_module_init);
 207 module_exit(ingress_module_exit);
 208
 209 MODULE_ALIAS("sch_clsact");
 210 MODULE_LICENSE("GPL");