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