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 #include <net/pkt_cls.h>
  20
  21 struct ingress_sched_data {
  22         struct tcf_block *block;
  23         struct tcf_block_ext_info block_info;
  24         struct mini_Qdisc_pair miniqp;
  25 };
  26
  27 static struct Qdisc *ingress_leaf(struct Qdisc *sch, unsigned long arg)
  28 {
  29         return NULL;
  30 }
  31
  32 static unsigned long ingress_find(struct Qdisc *sch, u32 classid)
  33 {
  34         return TC_H_MIN(classid) + 1;
  35 }
  36
  37 static unsigned long ingress_bind_filter(struct Qdisc *sch,
  38                                          unsigned long parent, u32 classid)
  39 {
  40         return ingress_find(sch, classid);
  41 }
  42
  43 static void ingress_unbind_filter(struct Qdisc *sch, unsigned long cl)
  44 {
  45 }
  46
  47 static void ingress_walk(struct Qdisc *sch, struct qdisc_walker *walker)
  48 {
  49 }
  50
  51 static struct tcf_block *ingress_tcf_block(struct Qdisc *sch, unsigned long cl,
  52                                            struct netlink_ext_ack *extack)
  53 {
  54         struct ingress_sched_data *q = qdisc_priv(sch);
  55
  56         return q->block;
  57 }
  58
  59 static void clsact_chain_head_change(struct tcf_proto *tp_head, void *priv)
  60 {
  61         struct mini_Qdisc_pair *miniqp = priv;
  62
  63         mini_qdisc_pair_swap(miniqp, tp_head);
  64 };
  65
  66 static void ingress_ingress_block_set(struct Qdisc *sch, u32 block_index)
  67 {
  68         struct ingress_sched_data *q = qdisc_priv(sch);
  69
  70         q->block_info.block_index = block_index;
  71 }
  72
  73 static u32 ingress_ingress_block_get(struct Qdisc *sch)
  74 {
  75         struct ingress_sched_data *q = qdisc_priv(sch);
  76
  77         return q->block_info.block_index;
  78 }
  79
  80 static int ingress_init(struct Qdisc *sch, struct nlattr *opt,
  81                         struct netlink_ext_ack *extack)
  82 {
  83         struct ingress_sched_data *q = qdisc_priv(sch);
  84         struct net_device *dev = qdisc_dev(sch);
  85
  86         net_inc_ingress_queue();
  87
  88         mini_qdisc_pair_init(&q->miniqp, sch, &dev->miniq_ingress);
  89
  90         q->block_info.binder_type = TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS;
  91         q->block_info.chain_head_change = clsact_chain_head_change;
  92         q->block_info.chain_head_change_priv = &q->miniqp;
  93
  94         return tcf_block_get_ext(&q->block, sch, &q->block_info, extack);
  95 }
  96
  97 static void ingress_destroy(struct Qdisc *sch)
  98 {
  99         struct ingress_sched_data *q = qdisc_priv(sch);
 100
 101         tcf_block_put_ext(q->block, sch, &q->block_info);
 102         net_dec_ingress_queue();
 103 }
 104
 105 static int ingress_dump(struct Qdisc *sch, struct sk_buff *skb)
 106 {
 107         struct nlattr *nest;
 108
 109         nest = nla_nest_start(skb, TCA_OPTIONS);
 110         if (nest == NULL)
 111                 goto nla_put_failure;
 112
 113         return nla_nest_end(skb, nest);
 114
 115 nla_put_failure:
 116         nla_nest_cancel(skb, nest);
 117         return -1;
 118 }
 119
 120 static const struct Qdisc_class_ops ingress_class_ops = {
 121         .leaf           =       ingress_leaf,
 122         .find           =       ingress_find,
 123         .walk           =       ingress_walk,
 124         .tcf_block      =       ingress_tcf_block,
 125         .bind_tcf       =       ingress_bind_filter,
 126         .unbind_tcf     =       ingress_unbind_filter,
 127 };
 128
 129 static struct Qdisc_ops ingress_qdisc_ops __read_mostly = {
 130         .cl_ops                 =       &ingress_class_ops,
 131         .id                     =       "ingress",
 132         .priv_size              =       sizeof(struct ingress_sched_data),
 133         .static_flags           =       TCQ_F_CPUSTATS,
 134         .init                   =       ingress_init,
 135         .destroy                =       ingress_destroy,
 136         .dump                   =       ingress_dump,
 137         .ingress_block_set      =       ingress_ingress_block_set,
 138         .ingress_block_get      =       ingress_ingress_block_get,
 139         .owner                  =       THIS_MODULE,
 140 };
 141
 142 struct clsact_sched_data {
 143         struct tcf_block *ingress_block;
 144         struct tcf_block *egress_block;
 145         struct tcf_block_ext_info ingress_block_info;
 146         struct tcf_block_ext_info egress_block_info;
 147         struct mini_Qdisc_pair miniqp_ingress;
 148         struct mini_Qdisc_pair miniqp_egress;
 149 };
 150
 151 static unsigned long clsact_find(struct Qdisc *sch, u32 classid)
 152 {
 153         switch (TC_H_MIN(classid)) {
 154         case TC_H_MIN(TC_H_MIN_INGRESS):
 155         case TC_H_MIN(TC_H_MIN_EGRESS):
 156                 return TC_H_MIN(classid);
 157         default:
 158                 return 0;
 159         }
 160 }
 161
 162 static unsigned long clsact_bind_filter(struct Qdisc *sch,
 163                                         unsigned long parent, u32 classid)
 164 {
 165         return clsact_find(sch, classid);
 166 }
 167
 168 static struct tcf_block *clsact_tcf_block(struct Qdisc *sch, unsigned long cl,
 169                                           struct netlink_ext_ack *extack)
 170 {
 171         struct clsact_sched_data *q = qdisc_priv(sch);
 172
 173         switch (cl) {
 174         case TC_H_MIN(TC_H_MIN_INGRESS):
 175                 return q->ingress_block;
 176         case TC_H_MIN(TC_H_MIN_EGRESS):
 177                 return q->egress_block;
 178         default:
 179                 return NULL;
 180         }
 181 }
 182
 183 static void clsact_ingress_block_set(struct Qdisc *sch, u32 block_index)
 184 {
 185         struct clsact_sched_data *q = qdisc_priv(sch);
 186
 187         q->ingress_block_info.block_index = block_index;
 188 }
 189
 190 static void clsact_egress_block_set(struct Qdisc *sch, u32 block_index)
 191 {
 192         struct clsact_sched_data *q = qdisc_priv(sch);
 193
 194         q->egress_block_info.block_index = block_index;
 195 }
 196
 197 static u32 clsact_ingress_block_get(struct Qdisc *sch)
 198 {
 199         struct clsact_sched_data *q = qdisc_priv(sch);
 200
 201         return q->ingress_block_info.block_index;
 202 }
 203
 204 static u32 clsact_egress_block_get(struct Qdisc *sch)
 205 {
 206         struct clsact_sched_data *q = qdisc_priv(sch);
 207
 208         return q->egress_block_info.block_index;
 209 }
 210
 211 static int clsact_init(struct Qdisc *sch, struct nlattr *opt,
 212                        struct netlink_ext_ack *extack)
 213 {
 214         struct clsact_sched_data *q = qdisc_priv(sch);
 215         struct net_device *dev = qdisc_dev(sch);
 216         int err;
 217
 218         net_inc_ingress_queue();
 219         net_inc_egress_queue();
 220
 221         mini_qdisc_pair_init(&q->miniqp_ingress, sch, &dev->miniq_ingress);
 222
 223         q->ingress_block_info.binder_type = TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS;
 224         q->ingress_block_info.chain_head_change = clsact_chain_head_change;
 225         q->ingress_block_info.chain_head_change_priv = &q->miniqp_ingress;
 226
 227         err = tcf_block_get_ext(&q->ingress_block, sch, &q->ingress_block_info,
 228                                 extack);
 229         if (err)
 230                 return err;
 231
 232         mini_qdisc_pair_init(&q->miniqp_egress, sch, &dev->miniq_egress);
 233
 234         q->egress_block_info.binder_type = TCF_BLOCK_BINDER_TYPE_CLSACT_EGRESS;
 235         q->egress_block_info.chain_head_change = clsact_chain_head_change;
 236         q->egress_block_info.chain_head_change_priv = &q->miniqp_egress;
 237
 238         return tcf_block_get_ext(&q->egress_block, sch, &q->egress_block_info, extack);
 239 }
 240
 241 static void clsact_destroy(struct Qdisc *sch)
 242 {
 243         struct clsact_sched_data *q = qdisc_priv(sch);
 244
 245         tcf_block_put_ext(q->egress_block, sch, &q->egress_block_info);
 246         tcf_block_put_ext(q->ingress_block, sch, &q->ingress_block_info);
 247
 248         net_dec_ingress_queue();
 249         net_dec_egress_queue();
 250 }
 251
 252 static const struct Qdisc_class_ops clsact_class_ops = {
 253         .leaf           =       ingress_leaf,
 254         .find           =       clsact_find,
 255         .walk           =       ingress_walk,
 256         .tcf_block      =       clsact_tcf_block,
 257         .bind_tcf       =       clsact_bind_filter,
 258         .unbind_tcf     =       ingress_unbind_filter,
 259 };
 260
 261 static struct Qdisc_ops clsact_qdisc_ops __read_mostly = {
 262         .cl_ops                 =       &clsact_class_ops,
 263         .id                     =       "clsact",
 264         .priv_size              =       sizeof(struct clsact_sched_data),
 265         .static_flags           =       TCQ_F_CPUSTATS,
 266         .init                   =       clsact_init,
 267         .destroy                =       clsact_destroy,
 268         .dump                   =       ingress_dump,
 269         .ingress_block_set      =       clsact_ingress_block_set,
 270         .egress_block_set       =       clsact_egress_block_set,
 271         .ingress_block_get      =       clsact_ingress_block_get,
 272         .egress_block_get       =       clsact_egress_block_get,
 273         .owner                  =       THIS_MODULE,
 274 };
 275
 276 static int __init ingress_module_init(void)
 277 {
 278         int ret;
 279
 280         ret = register_qdisc(&ingress_qdisc_ops);
 281         if (!ret) {
 282                 ret = register_qdisc(&clsact_qdisc_ops);
 283                 if (ret)
 284                         unregister_qdisc(&ingress_qdisc_ops);
 285         }
 286
 287         return ret;
 288 }
 289
 290 static void __exit ingress_module_exit(void)
 291 {
 292         unregister_qdisc(&ingress_qdisc_ops);
 293         unregister_qdisc(&clsact_qdisc_ops);
 294 }
 295
 296 module_init(ingress_module_init);
 297 module_exit(ingress_module_exit);
 298
 299 MODULE_ALIAS("sch_clsact");
 300 MODULE_LICENSE("GPL");