Linux kernel & device driver programming

Cross-Referenced Linux and Device Driver Code

[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ]
Version: [ 2.6.11.8 ] [ 2.6.25 ] [ 2.6.25.8 ] [ 2.6.31.13 ] Architecture: [ i386 ]
  1 /*
  2  * net/sched/sch_fifo.c The simplest FIFO queue.
  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  */
 11 
 12 #include <linux/module.h>
 13 #include <linux/types.h>
 14 #include <linux/kernel.h>
 15 #include <linux/errno.h>
 16 #include <linux/skbuff.h>
 17 #include <net/pkt_sched.h>
 18 
 19 /* 1 band FIFO pseudo-"scheduler" */
 20 
 21 struct fifo_sched_data
 22 {
 23         u32 limit;
 24 };
 25 
 26 static int bfifo_enqueue(struct sk_buff *skb, struct Qdisc* sch)
 27 {
 28         struct fifo_sched_data *q = qdisc_priv(sch);
 29 
 30         if (likely(sch->qstats.backlog + skb->len <= q->limit))
 31                 return qdisc_enqueue_tail(skb, sch);
 32 
 33         return qdisc_reshape_fail(skb, sch);
 34 }
 35 
 36 static int pfifo_enqueue(struct sk_buff *skb, struct Qdisc* sch)
 37 {
 38         struct fifo_sched_data *q = qdisc_priv(sch);
 39 
 40         if (likely(skb_queue_len(&sch->q) < q->limit))
 41                 return qdisc_enqueue_tail(skb, sch);
 42 
 43         return qdisc_reshape_fail(skb, sch);
 44 }
 45 
 46 static int fifo_init(struct Qdisc *sch, struct nlattr *opt)
 47 {
 48         struct fifo_sched_data *q = qdisc_priv(sch);
 49 
 50         if (opt == NULL) {
 51                 u32 limit = sch->dev->tx_queue_len ? : 1;
 52 
 53                 if (sch->ops == &bfifo_qdisc_ops)
 54                         limit *= sch->dev->mtu;
 55 
 56                 q->limit = limit;
 57         } else {
 58                 struct tc_fifo_qopt *ctl = nla_data(opt);
 59 
 60                 if (nla_len(opt) < sizeof(*ctl))
 61                         return -EINVAL;
 62 
 63                 q->limit = ctl->limit;
 64         }
 65 
 66         return 0;
 67 }
 68 
 69 static int fifo_dump(struct Qdisc *sch, struct sk_buff *skb)
 70 {
 71         struct fifo_sched_data *q = qdisc_priv(sch);
 72         struct tc_fifo_qopt opt = { .limit = q->limit };
 73 
 74         NLA_PUT(skb, TCA_OPTIONS, sizeof(opt), &opt);
 75         return skb->len;
 76 
 77 nla_put_failure:
 78         return -1;
 79 }
 80 
 81 struct Qdisc_ops pfifo_qdisc_ops __read_mostly = {
 82         .id             =       "pfifo",
 83         .priv_size      =       sizeof(struct fifo_sched_data),
 84         .enqueue        =       pfifo_enqueue,
 85         .dequeue        =       qdisc_dequeue_head,
 86         .requeue        =       qdisc_requeue,
 87         .drop           =       qdisc_queue_drop,
 88         .init           =       fifo_init,
 89         .reset          =       qdisc_reset_queue,
 90         .change         =       fifo_init,
 91         .dump           =       fifo_dump,
 92         .owner          =       THIS_MODULE,
 93 };
 94 EXPORT_SYMBOL(pfifo_qdisc_ops);
 95 
 96 struct Qdisc_ops bfifo_qdisc_ops __read_mostly = {
 97         .id             =       "bfifo",
 98         .priv_size      =       sizeof(struct fifo_sched_data),
 99         .enqueue        =       bfifo_enqueue,
100         .dequeue        =       qdisc_dequeue_head,
101         .requeue        =       qdisc_requeue,
102         .drop           =       qdisc_queue_drop,
103         .init           =       fifo_init,
104         .reset          =       qdisc_reset_queue,
105         .change         =       fifo_init,
106         .dump           =       fifo_dump,
107         .owner          =       THIS_MODULE,
108 };
109 EXPORT_SYMBOL(bfifo_qdisc_ops);
110 
  This page was automatically generated by the LXR engine.