1 /* 2 * net/sched/sch_prio.c Simple 3-band priority "scheduler". 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public License 6 * as published by the Free Software Foundation; either version 7 * 2 of the License, or (at your option) any later version. 8 * 9 * Authors: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> 10 * Fixes: 19990609: J Hadi Salim <hadi@nortelnetworks.com>: 11 * Init -- EINVAL when opt undefined 12 */ 13 14 #include <linux/module.h> 15 #include <linux/types.h> 16 #include <linux/kernel.h> 17 #include <linux/string.h> 18 #include <linux/errno.h> 19 #include <linux/skbuff.h> 20 #include <net/netlink.h> 21 #include <net/pkt_sched.h> 22 23 24 struct prio_sched_data 25 { 26 int bands; 27 struct tcf_proto *filter_list; 28 u8 prio2band[TC_PRIO_MAX+1]; 29 struct Qdisc *queues[TCQ_PRIO_BANDS]; 30 }; 31 32 33 static struct Qdisc * 34 prio_classify(struct sk_buff *skb, struct Qdisc *sch, int *qerr) 35 { 36 struct prio_sched_data *q = qdisc_priv(sch); 37 u32 band = skb->priority; 38 struct tcf_result res; 39 int err; 40 41 *qerr = NET_XMIT_BYPASS; 42 if (TC_H_MAJ(skb->priority) != sch->handle) { 43 err = tc_classify(skb, q->filter_list, &res); 44 #ifdef CONFIG_NET_CLS_ACT 45 switch (err) { 46 case TC_ACT_STOLEN: 47 case TC_ACT_QUEUED: 48 *qerr = NET_XMIT_SUCCESS; 49 case TC_ACT_SHOT: 50 return NULL; 51 } 52 #endif 53 if (!q->filter_list || err < 0) { 54 if (TC_H_MAJ(band)) 55 band = 0; 56 return q->queues[q->prio2band[band&TC_PRIO_MAX]]; 57 } 58 band = res.classid; 59 } 60 band = TC_H_MIN(band) - 1; 61 if (band >= q->bands) 62 return q->queues[q->prio2band[0]]; 63 64 return q->queues[band]; 65 } 66 67 static int 68 prio_enqueue(struct sk_buff *skb, struct Qdisc *sch) 69 { 70 struct Qdisc *qdisc; 71 int ret; 72 73 qdisc = prio_classify(skb, sch, &ret); 74 #ifdef CONFIG_NET_CLS_ACT 75 if (qdisc == NULL) { 76 77 if (ret == NET_XMIT_BYPASS) 78 sch->qstats.drops++; 79 kfree_skb(skb); 80 return ret; 81 } 82 #endif 83 84 ret = qdisc_enqueue(skb, qdisc); 85 if (ret == NET_XMIT_SUCCESS) { 86 sch->bstats.bytes += qdisc_pkt_len(skb); 87 sch->bstats.packets++; 88 sch->q.qlen++; 89 return NET_XMIT_SUCCESS; 90 } 91 sch->qstats.drops++; 92 return ret; 93 } 94 95 96 static int 97 prio_requeue(struct sk_buff *skb, struct Qdisc* sch) 98 { 99 struct Qdisc *qdisc; 100 int ret; 101 102 qdisc = prio_classify(skb, sch, &ret); 103 #ifdef CONFIG_NET_CLS_ACT 104 if (qdisc == NULL) { 105 if (ret == NET_XMIT_BYPASS) 106 sch->qstats.drops++; 107 kfree_skb(skb); 108 return ret; 109 } 110 #endif 111 112 if ((ret = qdisc->ops->requeue(skb, qdisc)) == NET_XMIT_SUCCESS) { 113 sch->q.qlen++; 114 sch->qstats.requeues++; 115 return 0; 116 } 117 sch->qstats.drops++; 118 return NET_XMIT_DROP; 119 } 120 121 122 static struct sk_buff *prio_dequeue(struct Qdisc* sch) 123 { 124 struct prio_sched_data *q = qdisc_priv(sch); 125 int prio; 126 127 for (prio = 0; prio < q->bands; prio++) { 128 struct Qdisc *qdisc = q->queues[prio]; 129 struct sk_buff *skb = qdisc->dequeue(qdisc); 130 if (skb) { 131 sch->q.qlen--; 132 return skb; 133 } 134 } 135 return NULL; 136 137 } 138 139 static unsigned int prio_drop(struct Qdisc* sch) 140 { 141 struct prio_sched_data *q = qdisc_priv(sch); 142 int prio; 143 unsigned int len; 144 struct Qdisc *qdisc; 145 146 for (prio = q->bands-1; prio >= 0; prio--) { 147 qdisc = q->queues[prio]; 148 if (qdisc->ops->drop && (len = qdisc->ops->drop(qdisc)) != 0) { 149 sch->q.qlen--; 150 return len; 151 } 152 } 153 return 0; 154 } 155 156 157 static void 158 prio_reset(struct Qdisc* sch) 159 { 160 int prio; 161 struct prio_sched_data *q = qdisc_priv(sch); 162 163 for (prio=0; prio<q->bands; prio++) 164 qdisc_reset(q->queues[prio]); 165 sch->q.qlen = 0; 166 } 167 168 static void 169 prio_destroy(struct Qdisc* sch) 170 { 171 int prio; 172 struct prio_sched_data *q = qdisc_priv(sch); 173 174 tcf_destroy_chain(&q->filter_list); 175 for (prio=0; prio<q->bands; prio++) 176 qdisc_destroy(q->queues[prio]); 177 } 178 179 static int prio_tune(struct Qdisc *sch, struct nlattr *opt) 180 { 181 struct prio_sched_data *q = qdisc_priv(sch); 182 struct tc_prio_qopt *qopt; 183 int i; 184 185 if (nla_len(opt) < sizeof(*qopt)) 186 return -EINVAL; 187 qopt = nla_data(opt); 188 189 if (qopt->bands > TCQ_PRIO_BANDS || qopt->bands < 2) 190 return -EINVAL; 191 192 for (i=0; i<=TC_PRIO_MAX; i++) { 193 if (qopt->priomap[i] >= qopt->bands) 194 return -EINVAL; 195 } 196 197 sch_tree_lock(sch); 198 q->bands = qopt->bands; 199 memcpy(q->prio2band, qopt->priomap, TC_PRIO_MAX+1); 200 201 for (i=q->bands; i<TCQ_PRIO_BANDS; i++) { 202 struct Qdisc *child = xchg(&q->queues[i], &noop_qdisc); 203 if (child != &noop_qdisc) { 204 qdisc_tree_decrease_qlen(child, child->q.qlen); 205 qdisc_destroy(child); 206 } 207 } 208 sch_tree_unlock(sch); 209 210 for (i=0; i<q->bands; i++) { 211 if (q->queues[i] == &noop_qdisc) { 212 struct Qdisc *child; 213 child = qdisc_create_dflt(qdisc_dev(sch), sch->dev_queue, 214 &pfifo_qdisc_ops, 215 TC_H_MAKE(sch->handle, i + 1)); 216 if (child) { 217 sch_tree_lock(sch); 218 child = xchg(&q->queues[i], child); 219 220 if (child != &noop_qdisc) { 221 qdisc_tree_decrease_qlen(child, 222 child->q.qlen); 223 qdisc_destroy(child); 224 } 225 sch_tree_unlock(sch); 226 } 227 } 228 } 229 return 0; 230 } 231 232 static int prio_init(struct Qdisc *sch, struct nlattr *opt) 233 { 234 struct prio_sched_data *q = qdisc_priv(sch); 235 int i; 236 237 for (i=0; i<TCQ_PRIO_BANDS; i++) 238 q->queues[i] = &noop_qdisc; 239 240 if (opt == NULL) { 241 return -EINVAL; 242 } else { 243 int err; 244 245 if ((err= prio_tune(sch, opt)) != 0) 246 return err; 247 } 248 return 0; 249 } 250 251 static int prio_dump(struct Qdisc *sch, struct sk_buff *skb) 252 { 253 struct prio_sched_data *q = qdisc_priv(sch); 254 unsigned char *b = skb_tail_pointer(skb); 255 struct nlattr *nest; 256 struct tc_prio_qopt opt; 257 258 opt.bands = q->bands; 259 memcpy(&opt.priomap, q->prio2band, TC_PRIO_MAX+1); 260 261 nest = nla_nest_compat_start(skb, TCA_OPTIONS, sizeof(opt), &opt); 262 if (nest == NULL) 263 goto nla_put_failure; 264 nla_nest_compat_end(skb, nest); 265 266 return skb->len; 267 268 nla_put_failure: 269 nlmsg_trim(skb, b); 270 return -1; 271 } 272 273 static int prio_graft(struct Qdisc *sch, unsigned long arg, struct Qdisc *new, 274 struct Qdisc **old) 275 { 276 struct prio_sched_data *q = qdisc_priv(sch); 277 unsigned long band = arg - 1; 278 279 if (band >= q->bands) 280 return -EINVAL; 281 282 if (new == NULL) 283 new = &noop_qdisc; 284 285 sch_tree_lock(sch); 286 *old = q->queues[band]; 287 q->queues[band] = new; 288 qdisc_tree_decrease_qlen(*old, (*old)->q.qlen); 289 qdisc_reset(*old); 290 sch_tree_unlock(sch); 291 292 return 0; 293 } 294 295 static struct Qdisc * 296 prio_leaf(struct Qdisc *sch, unsigned long arg) 297 { 298 struct prio_sched_data *q = qdisc_priv(sch); 299 unsigned long band = arg - 1; 300 301 if (band >= q->bands) 302 return NULL; 303 304 return q->queues[band]; 305 } 306 307 static unsigned long prio_get(struct Qdisc *sch, u32 classid) 308 { 309 struct prio_sched_data *q = qdisc_priv(sch); 310 unsigned long band = TC_H_MIN(classid); 311 312 if (band - 1 >= q->bands) 313 return 0; 314 return band; 315 } 316 317 static unsigned long prio_bind(struct Qdisc *sch, unsigned long parent, u32 classid) 318 { 319 return prio_get(sch, classid); 320 } 321 322 323 static void prio_put(struct Qdisc *q, unsigned long cl) 324 { 325 return; 326 } 327 328 static int prio_change(struct Qdisc *sch, u32 handle, u32 parent, struct nlattr **tca, unsigned long *arg) 329 { 330 unsigned long cl = *arg; 331 struct prio_sched_data *q = qdisc_priv(sch); 332 333 if (cl - 1 > q->bands) 334 return -ENOENT; 335 return 0; 336 } 337 338 static int prio_delete(struct Qdisc *sch, unsigned long cl) 339 { 340 struct prio_sched_data *q = qdisc_priv(sch); 341 if (cl - 1 > q->bands) 342 return -ENOENT; 343 return 0; 344 } 345 346 347 static int prio_dump_class(struct Qdisc *sch, unsigned long cl, struct sk_buff *skb, 348 struct tcmsg *tcm) 349 { 350 struct prio_sched_data *q = qdisc_priv(sch); 351 352 if (cl - 1 > q->bands) 353 return -ENOENT; 354 tcm->tcm_handle |= TC_H_MIN(cl); 355 if (q->queues[cl-1]) 356 tcm->tcm_info = q->queues[cl-1]->handle; 357 return 0; 358 } 359 360 static int prio_dump_class_stats(struct Qdisc *sch, unsigned long cl, 361 struct gnet_dump *d) 362 { 363 struct prio_sched_data *q = qdisc_priv(sch); 364 struct Qdisc *cl_q; 365 366 cl_q = q->queues[cl - 1]; 367 if (gnet_stats_copy_basic(d, &cl_q->bstats) < 0 || 368 gnet_stats_copy_queue(d, &cl_q->qstats) < 0) 369 return -1; 370 371 return 0; 372 } 373 374 static void prio_walk(struct Qdisc *sch, struct qdisc_walker *arg) 375 { 376 struct prio_sched_data *q = qdisc_priv(sch); 377 int prio; 378 379 if (arg->stop) 380 return; 381 382 for (prio = 0; prio < q->bands; prio++) { 383 if (arg->count < arg->skip) { 384 arg->count++; 385 continue; 386 } 387 if (arg->fn(sch, prio+1, arg) < 0) { 388 arg->stop = 1; 389 break; 390 } 391 arg->count++; 392 } 393 } 394 395 static struct tcf_proto ** prio_find_tcf(struct Qdisc *sch, unsigned long cl) 396 { 397 struct prio_sched_data *q = qdisc_priv(sch); 398 399 if (cl) 400 return NULL; 401 return &q->filter_list; 402 } 403 404 static const struct Qdisc_class_ops prio_class_ops = { 405 .graft = prio_graft, 406 .leaf = prio_leaf, 407 .get = prio_get, 408 .put = prio_put, 409 .change = prio_change, 410 .delete = prio_delete, 411 .walk = prio_walk, 412 .tcf_chain = prio_find_tcf, 413 .bind_tcf = prio_bind, 414 .unbind_tcf = prio_put, 415 .dump = prio_dump_class, 416 .dump_stats = prio_dump_class_stats, 417 }; 418 419 static struct Qdisc_ops prio_qdisc_ops __read_mostly = { 420 .next = NULL, 421 .cl_ops = &prio_class_ops, 422 .id = "prio", 423 .priv_size = sizeof(struct prio_sched_data), 424 .enqueue = prio_enqueue, 425 .dequeue = prio_dequeue, 426 .requeue = prio_requeue, 427 .drop = prio_drop, 428 .init = prio_init, 429 .reset = prio_reset, 430 .destroy = prio_destroy, 431 .change = prio_tune, 432 .dump = prio_dump, 433 .owner = THIS_MODULE, 434 }; 435 436 static int __init prio_module_init(void) 437 { 438 return register_qdisc(&prio_qdisc_ops); 439 } 440 441 static void __exit prio_module_exit(void) 442 { 443 unregister_qdisc(&prio_qdisc_ops); 444 } 445 446 module_init(prio_module_init) 447 module_exit(prio_module_exit) 448 449 MODULE_LICENSE("GPL"); 450