1 /* 2 * Codel - The Controlled-Delay Active Queue Management algorithm 3 * 4 * Copyright (C) 2011-2012 Kathleen Nichols <nichols@pollere.com> 5 * Copyright (C) 2011-2012 Van Jacobson <van@pollere.net> 6 * 7 * Implemented on linux by : 8 * Copyright (C) 2012 Michael D. Taht <dave.taht@bufferbloat.net> 9 * Copyright (C) 2012,2015 Eric Dumazet <edumazet@google.com> 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce the above copyright 18 * notice, this list of conditions and the following disclaimer in the 19 * documentation and/or other materials provided with the distribution. 20 * 3. The names of the authors may not be used to endorse or promote products 21 * derived from this software without specific prior written permission. 22 * 23 * Alternatively, provided that this notice is retained in full, this 24 * software may be distributed under the terms of the GNU General 25 * Public License ("GPL") version 2, in which case the provisions of the 26 * GPL apply INSTEAD OF those given above. 27 * 28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 30 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 31 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 32 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 33 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 34 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 35 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 36 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 37 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 38 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH 39 * DAMAGE. 40 * 41 */ 42 43 #include <linux/module.h> 44 #include <linux/slab.h> 45 #include <linux/types.h> 46 #include <linux/kernel.h> 47 #include <linux/errno.h> 48 #include <linux/skbuff.h> 49 #include <linux/prefetch.h> 50 #include <net/pkt_sched.h> 51 #include <net/codel.h> 52 #include <net/codel_impl.h> 53 #include <net/codel_qdisc.h> 54 55 56 #define DEFAULT_CODEL_LIMIT 1000 57 58 struct codel_sched_data { 59 struct codel_params params; 60 struct codel_vars vars; 61 struct codel_stats stats; 62 u32 drop_overlimit; 63 }; 64 65 /* This is the specific function called from codel_dequeue() 66 * to dequeue a packet from queue. Note: backlog is handled in 67 * codel, we dont need to reduce it here. 68 */ 69 static struct sk_buff *dequeue_func(struct codel_vars *vars, void *ctx) 70 { 71 struct Qdisc *sch = ctx; 72 struct sk_buff *skb = __qdisc_dequeue_head(&sch->q); 73 74 if (skb) { 75 sch->qstats.backlog -= qdisc_pkt_len(skb); 76 prefetch(&skb->end); /* we'll need skb_shinfo() */ 77 } 78 return skb; 79 } 80 81 static void drop_func(struct sk_buff *skb, void *ctx) 82 { 83 struct Qdisc *sch = ctx; 84 85 kfree_skb(skb); 86 qdisc_qstats_drop(sch); 87 } 88 89 static struct sk_buff *codel_qdisc_dequeue(struct Qdisc *sch) 90 { 91 struct codel_sched_data *q = qdisc_priv(sch); 92 struct sk_buff *skb; 93 94 skb = codel_dequeue(sch, &sch->qstats.backlog, &q->params, &q->vars, 95 &q->stats, qdisc_pkt_len, codel_get_enqueue_time, 96 drop_func, dequeue_func); 97 98 if (q->stats.drop_count) { 99 qdisc_tree_reduce_backlog(sch, q->stats.drop_count, q->stats.drop_len); 100 q->stats.drop_count = 0; 101 q->stats.drop_len = 0; 102 } 103 if (skb) 104 qdisc_bstats_update(sch, skb); 105 return skb; 106 } 107 108 static int codel_qdisc_enqueue(struct sk_buff *skb, struct Qdisc *sch, 109 struct sk_buff **to_free) 110 { 111 struct codel_sched_data *q; 112 113 if (likely(qdisc_qlen(sch) < sch->limit)) { 114 codel_set_enqueue_time(skb); 115 return qdisc_enqueue_tail(skb, sch); 116 } 117 q = qdisc_priv(sch); 118 q->drop_overlimit++; 119 return qdisc_drop(skb, sch, to_free); 120 } 121 122 static const struct nla_policy codel_policy[TCA_CODEL_MAX + 1] = { 123 [TCA_CODEL_TARGET] = { .type = NLA_U32 }, 124 [TCA_CODEL_LIMIT] = { .type = NLA_U32 }, 125 [TCA_CODEL_INTERVAL] = { .type = NLA_U32 }, 126 [TCA_CODEL_ECN] = { .type = NLA_U32 }, 127 [TCA_CODEL_CE_THRESHOLD]= { .type = NLA_U32 }, 128 }; 129 130 static int codel_change(struct Qdisc *sch, struct nlattr *opt, 131 struct netlink_ext_ack *extack) 132 { 133 struct codel_sched_data *q = qdisc_priv(sch); 134 struct nlattr *tb[TCA_CODEL_MAX + 1]; 135 unsigned int qlen, dropped = 0; 136 int err; 137 138 err = nla_parse_nested_deprecated(tb, TCA_CODEL_MAX, opt, 139 codel_policy, NULL); 140 if (err < 0) 141 return err; 142 143 sch_tree_lock(sch); 144 145 if (tb[TCA_CODEL_TARGET]) { 146 u32 target = nla_get_u32(tb[TCA_CODEL_TARGET]); 147 148 q->params.target = ((u64)target * NSEC_PER_USEC) >> CODEL_SHIFT; 149 } 150 151 if (tb[TCA_CODEL_CE_THRESHOLD]) { 152 u64 val = nla_get_u32(tb[TCA_CODEL_CE_THRESHOLD]); 153 154 q->params.ce_threshold = (val * NSEC_PER_USEC) >> CODEL_SHIFT; 155 } 156 157 if (tb[TCA_CODEL_INTERVAL]) { 158 u32 interval = nla_get_u32(tb[TCA_CODEL_INTERVAL]); 159 160 q->params.interval = ((u64)interval * NSEC_PER_USEC) >> CODEL_SHIFT; 161 } 162 163 if (tb[TCA_CODEL_LIMIT]) 164 sch->limit = nla_get_u32(tb[TCA_CODEL_LIMIT]); 165 166 if (tb[TCA_CODEL_ECN]) 167 q->params.ecn = !!nla_get_u32(tb[TCA_CODEL_ECN]); 168 169 qlen = sch->q.qlen; 170 while (sch->q.qlen > sch->limit) { 171 struct sk_buff *skb = __qdisc_dequeue_head(&sch->q); 172 173 dropped += qdisc_pkt_len(skb); 174 qdisc_qstats_backlog_dec(sch, skb); 175 rtnl_qdisc_drop(skb, sch); 176 } 177 qdisc_tree_reduce_backlog(sch, qlen - sch->q.qlen, dropped); 178 179 sch_tree_unlock(sch); 180 return 0; 181 } 182 183 static int codel_init(struct Qdisc *sch, struct nlattr *opt, 184 struct netlink_ext_ack *extack) 185 { 186 struct codel_sched_data *q = qdisc_priv(sch); 187 188 sch->limit = DEFAULT_CODEL_LIMIT; 189 190 codel_params_init(&q->params); 191 codel_vars_init(&q->vars); 192 codel_stats_init(&q->stats); 193 q->params.mtu = psched_mtu(qdisc_dev(sch)); 194 195 if (opt) { 196 int err = codel_change(sch, opt, extack); 197 198 if (err) 199 return err; 200 } 201 202 if (sch->limit >= 1) 203 sch->flags |= TCQ_F_CAN_BYPASS; 204 else 205 sch->flags &= ~TCQ_F_CAN_BYPASS; 206 207 return 0; 208 } 209 210 static int codel_dump(struct Qdisc *sch, struct sk_buff *skb) 211 { 212 struct codel_sched_data *q = qdisc_priv(sch); 213 struct nlattr *opts; 214 215 opts = nla_nest_start_noflag(skb, TCA_OPTIONS); 216 if (opts == NULL) 217 goto nla_put_failure; 218 219 if (nla_put_u32(skb, TCA_CODEL_TARGET, 220 codel_time_to_us(q->params.target)) || 221 nla_put_u32(skb, TCA_CODEL_LIMIT, 222 sch->limit) || 223 nla_put_u32(skb, TCA_CODEL_INTERVAL, 224 codel_time_to_us(q->params.interval)) || 225 nla_put_u32(skb, TCA_CODEL_ECN, 226 q->params.ecn)) 227 goto nla_put_failure; 228 if (q->params.ce_threshold != CODEL_DISABLED_THRESHOLD && 229 nla_put_u32(skb, TCA_CODEL_CE_THRESHOLD, 230 codel_time_to_us(q->params.ce_threshold))) 231 goto nla_put_failure; 232 return nla_nest_end(skb, opts); 233 234 nla_put_failure: 235 nla_nest_cancel(skb, opts); 236 return -1; 237 } 238 239 static int codel_dump_stats(struct Qdisc *sch, struct gnet_dump *d) 240 { 241 const struct codel_sched_data *q = qdisc_priv(sch); 242 struct tc_codel_xstats st = { 243 .maxpacket = q->stats.maxpacket, 244 .count = q->vars.count, 245 .lastcount = q->vars.lastcount, 246 .drop_overlimit = q->drop_overlimit, 247 .ldelay = codel_time_to_us(q->vars.ldelay), 248 .dropping = q->vars.dropping, 249 .ecn_mark = q->stats.ecn_mark, 250 .ce_mark = q->stats.ce_mark, 251 }; 252 253 if (q->vars.dropping) { 254 codel_tdiff_t delta = q->vars.drop_next - codel_get_time(); 255 256 if (delta >= 0) 257 st.drop_next = codel_time_to_us(delta); 258 else 259 st.drop_next = -codel_time_to_us(-delta); 260 } 261 262 return gnet_stats_copy_app(d, &st, sizeof(st)); 263 } 264 265 static void codel_reset(struct Qdisc *sch) 266 { 267 struct codel_sched_data *q = qdisc_priv(sch); 268 269 qdisc_reset_queue(sch); 270 codel_vars_init(&q->vars); 271 } 272 273 static struct Qdisc_ops codel_qdisc_ops __read_mostly = { 274 .id = "codel", 275 .priv_size = sizeof(struct codel_sched_data), 276 277 .enqueue = codel_qdisc_enqueue, 278 .dequeue = codel_qdisc_dequeue, 279 .peek = qdisc_peek_dequeued, 280 .init = codel_init, 281 .reset = codel_reset, 282 .change = codel_change, 283 .dump = codel_dump, 284 .dump_stats = codel_dump_stats, 285 .owner = THIS_MODULE, 286 }; 287 288 static int __init codel_module_init(void) 289 { 290 return register_qdisc(&codel_qdisc_ops); 291 } 292 293 static void __exit codel_module_exit(void) 294 { 295 unregister_qdisc(&codel_qdisc_ops); 296 } 297 298 module_init(codel_module_init) 299 module_exit(codel_module_exit) 300 301 MODULE_DESCRIPTION("Controlled Delay queue discipline"); 302 MODULE_AUTHOR("Dave Taht"); 303 MODULE_AUTHOR("Eric Dumazet"); 304 MODULE_LICENSE("Dual BSD/GPL"); 305