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 {
  53         struct ingress_sched_data *q = qdisc_priv(sch);
  54
  55         return q->block;
  56 }
  57
  58 static void clsact_chain_head_change(struct tcf_proto *tp_head, void *priv)
  59 {
  60         struct mini_Qdisc_pair *miniqp = priv;
  61
  62         mini_qdisc_pair_swap(miniqp, tp_head);
  63 }
  64
  65 static int ingress_init(struct Qdisc *sch, struct nlattr *opt)
  66 {
  67         struct ingress_sched_data *q = qdisc_priv(sch);
  68         struct net_device *dev = qdisc_dev(sch);
  69
  70         net_inc_ingress_queue();
  71
  72         mini_qdisc_pair_init(&q->miniqp, sch, &dev->miniq_ingress);
  73
  74         q->block_info.binder_type = TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS;
  75         q->block_info.chain_head_change = clsact_chain_head_change;
  76         q->block_info.chain_head_change_priv = &q->miniqp;
  77
  78         return tcf_block_get_ext(&q->block, sch, &q->block_info);
  79 }
  80
  81 static void ingress_destroy(struct Qdisc *sch)
  82 {
  83         struct ingress_sched_data *q = qdisc_priv(sch);
  84
  85         tcf_block_put_ext(q->block, sch, &q->block_info);
  86         net_dec_ingress_queue();
  87 }
  88
  89 static int ingress_dump(struct Qdisc *sch, struct sk_buff *skb)
  90 {
  91         struct nlattr *nest;
  92
  93         nest = nla_nest_start(skb, TCA_OPTIONS);
  94         if (nest == NULL)
  95                 goto nla_put_failure;
  96
  97         return nla_nest_end(skb, nest);
  98
  99 nla_put_failure:
 100         nla_nest_cancel(skb, nest);
 101         return -1;
 102 }
 103
 104 static const struct Qdisc_class_ops ingress_class_ops = {
 105         .leaf           =       ingress_leaf,
 106         .find           =       ingress_find,
 107         .walk           =       ingress_walk,
 108         .tcf_block      =       ingress_tcf_block,
 109         .bind_tcf       =       ingress_bind_filter,
 110         .unbind_tcf     =       ingress_unbind_filter,
 111 };
 112
 113 static struct Qdisc_ops ingress_qdisc_ops __read_mostly = {
 114         .cl_ops         =       &ingress_class_ops,
 115         .id             =       "ingress",
 116         .priv_size      =       sizeof(struct ingress_sched_data),
 117         .static_flags   =       TCQ_F_CPUSTATS,
 118         .init           =       ingress_init,
 119         .destroy        =       ingress_destroy,
 120         .dump           =       ingress_dump,
 121         .owner          =       THIS_MODULE,
 122 };
 123
 124 struct clsact_sched_data {
 125         struct tcf_block *ingress_block;
 126         struct tcf_block *egress_block;
 127         struct tcf_block_ext_info ingress_block_info;
 128         struct tcf_block_ext_info egress_block_info;
 129         struct mini_Qdisc_pair miniqp_ingress;
 130         struct mini_Qdisc_pair miniqp_egress;
 131 };
 132
 133 static unsigned long clsact_find(struct Qdisc *sch, u32 classid)
 134 {
 135         switch (TC_H_MIN(classid)) {
 136         case TC_H_MIN(TC_H_MIN_INGRESS):
 137         case TC_H_MIN(TC_H_MIN_EGRESS):
 138                 return TC_H_MIN(classid);
 139         default:
 140                 return 0;
 141         }
 142 }
 143
 144 static unsigned long clsact_bind_filter(struct Qdisc *sch,
 145                                         unsigned long parent, u32 classid)
 146 {
 147         return clsact_find(sch, classid);
 148 }
 149
 150 static struct tcf_block *clsact_tcf_block(struct Qdisc *sch, unsigned long cl)
 151 {
 152         struct clsact_sched_data *q = qdisc_priv(sch);
 153
 154         switch (cl) {
 155         case TC_H_MIN(TC_H_MIN_INGRESS):
 156                 return q->ingress_block;
 157         case TC_H_MIN(TC_H_MIN_EGRESS):
 158                 return q->egress_block;
 159         default:
 160                 return NULL;
 161         }
 162 }
 163
 164 static int clsact_init(struct Qdisc *sch, struct nlattr *opt)
 165 {
 166         struct clsact_sched_data *q = qdisc_priv(sch);
 167         struct net_device *dev = qdisc_dev(sch);
 168         int err;
 169
 170         net_inc_ingress_queue();
 171         net_inc_egress_queue();
 172
 173         mini_qdisc_pair_init(&q->miniqp_ingress, sch, &dev->miniq_ingress);
 174
 175         q->ingress_block_info.binder_type = TCF_BLOCK_BINDER_TYPE_CLSACT_INGRESS;
 176         q->ingress_block_info.chain_head_change = clsact_chain_head_change;
 177         q->ingress_block_info.chain_head_change_priv = &q->miniqp_ingress;
 178
 179         err = tcf_block_get_ext(&q->ingress_block, sch, &q->ingress_block_info);
 180         if (err)
 181                 return err;
 182
 183         mini_qdisc_pair_init(&q->miniqp_egress, sch, &dev->miniq_egress);
 184
 185         q->egress_block_info.binder_type = TCF_BLOCK_BINDER_TYPE_CLSACT_EGRESS;
 186         q->egress_block_info.chain_head_change = clsact_chain_head_change;
 187         q->egress_block_info.chain_head_change_priv = &q->miniqp_egress;
 188
 189         return tcf_block_get_ext(&q->egress_block, sch, &q->egress_block_info);
 190 }
 191
 192 static void clsact_destroy(struct Qdisc *sch)
 193 {
 194         struct clsact_sched_data *q = qdisc_priv(sch);
 195
 196         tcf_block_put_ext(q->egress_block, sch, &q->egress_block_info);
 197         tcf_block_put_ext(q->ingress_block, sch, &q->ingress_block_info);
 198
 199         net_dec_ingress_queue();
 200         net_dec_egress_queue();
 201 }
 202
 203 static const struct Qdisc_class_ops clsact_class_ops = {
 204         .leaf           =       ingress_leaf,
 205         .find           =       clsact_find,
 206         .walk           =       ingress_walk,
 207         .tcf_block      =       clsact_tcf_block,
 208         .bind_tcf       =       clsact_bind_filter,
 209         .unbind_tcf     =       ingress_unbind_filter,
 210 };
 211
 212 static struct Qdisc_ops clsact_qdisc_ops __read_mostly = {
 213         .cl_ops         =       &clsact_class_ops,
 214         .id             =       "clsact",
 215         .priv_size      =       sizeof(struct clsact_sched_data),
 216         .static_flags   =       TCQ_F_CPUSTATS,
 217         .init           =       clsact_init,
 218         .destroy        =       clsact_destroy,
 219         .dump           =       ingress_dump,
 220         .owner          =       THIS_MODULE,
 221 };
 222
 223 static int __init ingress_module_init(void)
 224 {
 225         int ret;
 226
 227         ret = register_qdisc(&ingress_qdisc_ops);
 228         if (!ret) {
 229                 ret = register_qdisc(&clsact_qdisc_ops);
 230                 if (ret)
 231                         unregister_qdisc(&ingress_qdisc_ops);
 232         }
 233
 234         return ret;
 235 }
 236
 237 static void __exit ingress_module_exit(void)
 238 {
 239         unregister_qdisc(&ingress_qdisc_ops);
 240         unregister_qdisc(&clsact_qdisc_ops);
 241 }
 242
 243 module_init(ingress_module_init);
 244 module_exit(ingress_module_exit);
 245
 246 MODULE_ALIAS("sch_clsact");
 247 MODULE_LICENSE("GPL");