URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [net/] [sched/] [sch_dsmark.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/* net/sched/sch_dsmark.c - Differentiated Services field marker */
 
/* Written 1998-2000 by Werner Almesberger, EPFL ICA */
 
 
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/skbuff.h>
#include <linux/rtnetlink.h>
#include <net/pkt_sched.h>
#include <net/dsfield.h>
#include <net/inet_ecn.h>
#include <asm/byteorder.h>
 
 
#if 0 /* control */
#define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
#else
#define DPRINTK(format,args...)
#endif
 
#if 0 /* data */
#define D2PRINTK(format,args...) printk(KERN_DEBUG format,##args)
#else
#define D2PRINTK(format,args...)
#endif
 
 
#define PRIV(sch) ((struct dsmark_qdisc_data *) qdisc_priv(sch))
 
 
/*
 * classid      class           marking
 * -------      -----           -------
 *   n/a          0             n/a
 *   x:0          1             use entry [0]
 *   ...         ...            ...
 *   x:y y>0      y+1            use entry [y]
 *   ...         ...            ...
 * x:indices-1  indices         use entry [indices-1]
 *   ...         ...            ...
 *   x:y         y+1            use entry [y & (indices-1)]
 *   ...         ...            ...
 * 0xffff       0x10000         use entry [indices-1]
 */
 
 
#define NO_DEFAULT_INDEX        (1 << 16)
 
struct dsmark_qdisc_data {
        struct Qdisc            *q;
        struct tcf_proto        *filter_list;
        u8                      *mask;  /* "owns" the array */
        u8                      *value;
        u16                     indices;
        u32                     default_index;  /* index range is 0...0xffff */
        int                     set_tc_index;
};
 
static inline int dsmark_valid_indices(u16 indices)
{
        while (indices != 1) {
                if (indices & 1)
                        return 0;
                indices >>= 1;
        }
 
        return 1;
}
 
static inline int dsmark_valid_index(struct dsmark_qdisc_data *p, u16 index)
{
        return (index <= p->indices && index > 0);
}
 
/* ------------------------- Class/flow operations ------------------------- */
 
static int dsmark_graft(struct Qdisc *sch, unsigned long arg,
                        struct Qdisc *new, struct Qdisc **old)
{
        struct dsmark_qdisc_data *p = PRIV(sch);
 
        DPRINTK("dsmark_graft(sch %p,[qdisc %p],new %p,old %p)\n",
                sch, p, new, old);
 
        if (new == NULL) {
                new = qdisc_create_dflt(sch->dev, &pfifo_qdisc_ops,
                                        sch->handle);
                if (new == NULL)
                        new = &noop_qdisc;
        }
 
        sch_tree_lock(sch);
        *old = xchg(&p->q, new);
        qdisc_tree_decrease_qlen(*old, (*old)->q.qlen);
        qdisc_reset(*old);
        sch_tree_unlock(sch);
 
        return 0;
}
 
static struct Qdisc *dsmark_leaf(struct Qdisc *sch, unsigned long arg)
{
        return PRIV(sch)->q;
}
 
static unsigned long dsmark_get(struct Qdisc *sch, u32 classid)
{
        DPRINTK("dsmark_get(sch %p,[qdisc %p],classid %x)\n",
                sch, PRIV(sch), classid);
 
        return TC_H_MIN(classid) + 1;
}
 
static unsigned long dsmark_bind_filter(struct Qdisc *sch,
                                        unsigned long parent, u32 classid)
{
        return dsmark_get(sch, classid);
}
 
static void dsmark_put(struct Qdisc *sch, unsigned long cl)
{
}
 
static int dsmark_change(struct Qdisc *sch, u32 classid, u32 parent,
                         struct rtattr **tca, unsigned long *arg)
{
        struct dsmark_qdisc_data *p = PRIV(sch);
        struct rtattr *opt = tca[TCA_OPTIONS-1];
        struct rtattr *tb[TCA_DSMARK_MAX];
        int err = -EINVAL;
        u8 mask = 0;
 
        DPRINTK("dsmark_change(sch %p,[qdisc %p],classid %x,parent %x),"
                "arg 0x%lx\n", sch, p, classid, parent, *arg);
 
        if (!dsmark_valid_index(p, *arg)) {
                err = -ENOENT;
                goto rtattr_failure;
        }
 
        if (!opt || rtattr_parse_nested(tb, TCA_DSMARK_MAX, opt))
                goto rtattr_failure;
 
        if (tb[TCA_DSMARK_MASK-1])
                mask = RTA_GET_U8(tb[TCA_DSMARK_MASK-1]);
 
        if (tb[TCA_DSMARK_VALUE-1])
                p->value[*arg-1] = RTA_GET_U8(tb[TCA_DSMARK_VALUE-1]);
 
        if (tb[TCA_DSMARK_MASK-1])
                p->mask[*arg-1] = mask;
 
        err = 0;
 
rtattr_failure:
        return err;
}
 
static int dsmark_delete(struct Qdisc *sch, unsigned long arg)
{
        struct dsmark_qdisc_data *p = PRIV(sch);
 
        if (!dsmark_valid_index(p, arg))
                return -EINVAL;
 
        p->mask[arg-1] = 0xff;
        p->value[arg-1] = 0;
 
        return 0;
}
 
static void dsmark_walk(struct Qdisc *sch,struct qdisc_walker *walker)
{
        struct dsmark_qdisc_data *p = PRIV(sch);
        int i;
 
        DPRINTK("dsmark_walk(sch %p,[qdisc %p],walker %p)\n", sch, p, walker);
 
        if (walker->stop)
                return;
 
        for (i = 0; i < p->indices; i++) {
                if (p->mask[i] == 0xff && !p->value[i])
                        goto ignore;
                if (walker->count >= walker->skip) {
                        if (walker->fn(sch, i+1, walker) < 0) {
                                walker->stop = 1;
                                break;
                        }
                }
ignore:
                walker->count++;
        }
}
 
static struct tcf_proto **dsmark_find_tcf(struct Qdisc *sch,unsigned long cl)
{
        return &PRIV(sch)->filter_list;
}
 
/* --------------------------- Qdisc operations ---------------------------- */
 
static int dsmark_enqueue(struct sk_buff *skb,struct Qdisc *sch)
{
        struct dsmark_qdisc_data *p = PRIV(sch);
        int err;
 
        D2PRINTK("dsmark_enqueue(skb %p,sch %p,[qdisc %p])\n", skb, sch, p);
 
        if (p->set_tc_index) {
                /* FIXME: Safe with non-linear skbs? --RR */
                switch (skb->protocol) {
                        case __constant_htons(ETH_P_IP):
                                skb->tc_index = ipv4_get_dsfield(ip_hdr(skb))
                                        & ~INET_ECN_MASK;
                                break;
                        case __constant_htons(ETH_P_IPV6):
                                skb->tc_index = ipv6_get_dsfield(ipv6_hdr(skb))
                                        & ~INET_ECN_MASK;
                                break;
                        default:
                                skb->tc_index = 0;
                                break;
                }
        }
 
        if (TC_H_MAJ(skb->priority) == sch->handle)
                skb->tc_index = TC_H_MIN(skb->priority);
        else {
                struct tcf_result res;
                int result = tc_classify(skb, p->filter_list, &res);
 
                D2PRINTK("result %d class 0x%04x\n", result, res.classid);
 
                switch (result) {
#ifdef CONFIG_NET_CLS_ACT
                case TC_ACT_QUEUED:
                case TC_ACT_STOLEN:
                        kfree_skb(skb);
                        return NET_XMIT_SUCCESS;
                case TC_ACT_SHOT:
                        kfree_skb(skb);
                        sch->qstats.drops++;
                        return NET_XMIT_BYPASS;
#endif
                case TC_ACT_OK:
                        skb->tc_index = TC_H_MIN(res.classid);
                        break;
                default:
                        if (p->default_index != NO_DEFAULT_INDEX)
                                skb->tc_index = p->default_index;
                        break;
                }
        }
 
        err = p->q->enqueue(skb,p->q);
        if (err != NET_XMIT_SUCCESS) {
                sch->qstats.drops++;
                return err;
        }
 
        sch->bstats.bytes += skb->len;
        sch->bstats.packets++;
        sch->q.qlen++;
 
        return NET_XMIT_SUCCESS;
}
 
static struct sk_buff *dsmark_dequeue(struct Qdisc *sch)
{
        struct dsmark_qdisc_data *p = PRIV(sch);
        struct sk_buff *skb;
        u32 index;
 
        D2PRINTK("dsmark_dequeue(sch %p,[qdisc %p])\n", sch, p);
 
        skb = p->q->ops->dequeue(p->q);
        if (skb == NULL)
                return NULL;
 
        sch->q.qlen--;
 
        index = skb->tc_index & (p->indices - 1);
        D2PRINTK("index %d->%d\n", skb->tc_index, index);
 
        switch (skb->protocol) {
                case __constant_htons(ETH_P_IP):
                        ipv4_change_dsfield(ip_hdr(skb), p->mask[index],
                                            p->value[index]);
                        break;
                case __constant_htons(ETH_P_IPV6):
                        ipv6_change_dsfield(ipv6_hdr(skb), p->mask[index],
                                            p->value[index]);
                        break;
                default:
                        /*
                         * Only complain if a change was actually attempted.
                         * This way, we can send non-IP traffic through dsmark
                         * and don't need yet another qdisc as a bypass.
                         */
                        if (p->mask[index] != 0xff || p->value[index])
                                printk(KERN_WARNING "dsmark_dequeue: "
                                       "unsupported protocol %d\n",
                                       ntohs(skb->protocol));
                        break;
        }
 
        return skb;
}
 
static int dsmark_requeue(struct sk_buff *skb,struct Qdisc *sch)
{
        struct dsmark_qdisc_data *p = PRIV(sch);
        int err;
 
        D2PRINTK("dsmark_requeue(skb %p,sch %p,[qdisc %p])\n", skb, sch, p);
 
        err = p->q->ops->requeue(skb, p->q);
        if (err != NET_XMIT_SUCCESS) {
                sch->qstats.drops++;
                return err;
        }
 
        sch->q.qlen++;
        sch->qstats.requeues++;
 
        return NET_XMIT_SUCCESS;
}
 
static unsigned int dsmark_drop(struct Qdisc *sch)
{
        struct dsmark_qdisc_data *p = PRIV(sch);
        unsigned int len;
 
        DPRINTK("dsmark_reset(sch %p,[qdisc %p])\n", sch, p);
 
        if (p->q->ops->drop == NULL)
                return 0;
 
        len = p->q->ops->drop(p->q);
        if (len)
                sch->q.qlen--;
 
        return len;
}
 
static int dsmark_init(struct Qdisc *sch, struct rtattr *opt)
{
        struct dsmark_qdisc_data *p = PRIV(sch);
        struct rtattr *tb[TCA_DSMARK_MAX];
        int err = -EINVAL;
        u32 default_index = NO_DEFAULT_INDEX;
        u16 indices;
        u8 *mask;
 
        DPRINTK("dsmark_init(sch %p,[qdisc %p],opt %p)\n", sch, p, opt);
 
        if (!opt || rtattr_parse_nested(tb, TCA_DSMARK_MAX, opt) < 0)
                goto errout;
 
        indices = RTA_GET_U16(tb[TCA_DSMARK_INDICES-1]);
        if (!indices || !dsmark_valid_indices(indices))
                goto errout;
 
        if (tb[TCA_DSMARK_DEFAULT_INDEX-1])
                default_index = RTA_GET_U16(tb[TCA_DSMARK_DEFAULT_INDEX-1]);
 
        mask = kmalloc(indices * 2, GFP_KERNEL);
        if (mask == NULL) {
                err = -ENOMEM;
                goto errout;
        }
 
        p->mask = mask;
        memset(p->mask, 0xff, indices);
 
        p->value = p->mask + indices;
        memset(p->value, 0, indices);
 
        p->indices = indices;
        p->default_index = default_index;
        p->set_tc_index = RTA_GET_FLAG(tb[TCA_DSMARK_SET_TC_INDEX-1]);
 
        p->q = qdisc_create_dflt(sch->dev, &pfifo_qdisc_ops, sch->handle);
        if (p->q == NULL)
                p->q = &noop_qdisc;
 
        DPRINTK("dsmark_init: qdisc %p\n", p->q);
 
        err = 0;
errout:
rtattr_failure:
        return err;
}
 
static void dsmark_reset(struct Qdisc *sch)
{
        struct dsmark_qdisc_data *p = PRIV(sch);
 
        DPRINTK("dsmark_reset(sch %p,[qdisc %p])\n", sch, p);
        qdisc_reset(p->q);
        sch->q.qlen = 0;
}
 
static void dsmark_destroy(struct Qdisc *sch)
{
        struct dsmark_qdisc_data *p = PRIV(sch);
 
        DPRINTK("dsmark_destroy(sch %p,[qdisc %p])\n", sch, p);
 
        tcf_destroy_chain(p->filter_list);
        qdisc_destroy(p->q);
        kfree(p->mask);
}
 
static int dsmark_dump_class(struct Qdisc *sch, unsigned long cl,
                             struct sk_buff *skb, struct tcmsg *tcm)
{
        struct dsmark_qdisc_data *p = PRIV(sch);
        struct rtattr *opts = NULL;
 
        DPRINTK("dsmark_dump_class(sch %p,[qdisc %p],class %ld\n", sch, p, cl);
 
        if (!dsmark_valid_index(p, cl))
                return -EINVAL;
 
        tcm->tcm_handle = TC_H_MAKE(TC_H_MAJ(sch->handle), cl-1);
        tcm->tcm_info = p->q->handle;
 
        opts = RTA_NEST(skb, TCA_OPTIONS);
        RTA_PUT_U8(skb,TCA_DSMARK_MASK, p->mask[cl-1]);
        RTA_PUT_U8(skb,TCA_DSMARK_VALUE, p->value[cl-1]);
 
        return RTA_NEST_END(skb, opts);
 
rtattr_failure:
        return RTA_NEST_CANCEL(skb, opts);
}
 
static int dsmark_dump(struct Qdisc *sch, struct sk_buff *skb)
{
        struct dsmark_qdisc_data *p = PRIV(sch);
        struct rtattr *opts = NULL;
 
        opts = RTA_NEST(skb, TCA_OPTIONS);
        RTA_PUT_U16(skb, TCA_DSMARK_INDICES, p->indices);
 
        if (p->default_index != NO_DEFAULT_INDEX)
                RTA_PUT_U16(skb, TCA_DSMARK_DEFAULT_INDEX, p->default_index);
 
        if (p->set_tc_index)
                RTA_PUT_FLAG(skb, TCA_DSMARK_SET_TC_INDEX);
 
        return RTA_NEST_END(skb, opts);
 
rtattr_failure:
        return RTA_NEST_CANCEL(skb, opts);
}
 
static struct Qdisc_class_ops dsmark_class_ops = {
        .graft          =       dsmark_graft,
        .leaf           =       dsmark_leaf,
        .get            =       dsmark_get,
        .put            =       dsmark_put,
        .change         =       dsmark_change,
        .delete         =       dsmark_delete,
        .walk           =       dsmark_walk,
        .tcf_chain      =       dsmark_find_tcf,
        .bind_tcf       =       dsmark_bind_filter,
        .unbind_tcf     =       dsmark_put,
        .dump           =       dsmark_dump_class,
};
 
static struct Qdisc_ops dsmark_qdisc_ops = {
        .next           =       NULL,
        .cl_ops         =       &dsmark_class_ops,
        .id             =       "dsmark",
        .priv_size      =       sizeof(struct dsmark_qdisc_data),
        .enqueue        =       dsmark_enqueue,
        .dequeue        =       dsmark_dequeue,
        .requeue        =       dsmark_requeue,
        .drop           =       dsmark_drop,
        .init           =       dsmark_init,
        .reset          =       dsmark_reset,
        .destroy        =       dsmark_destroy,
        .change         =       NULL,
        .dump           =       dsmark_dump,
        .owner          =       THIS_MODULE,
};
 
static int __init dsmark_module_init(void)
{
        return register_qdisc(&dsmark_qdisc_ops);
}
 
static void __exit dsmark_module_exit(void)
{
        unregister_qdisc(&dsmark_qdisc_ops);
}
 
module_init(dsmark_module_init)
module_exit(dsmark_module_exit)
 
MODULE_LICENSE("GPL");

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [net/] [sched/] [sch_dsmark.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/* net/sched/sch_dsmark.c - Differentiated Services field marker */`
2
3			`/* Written 1998-2000 by Werner Almesberger, EPFL ICA */`
4
5
6			`#include <linux/module.h>`
7			`#include <linux/init.h>`
8			`#include <linux/types.h>`
9			`#include <linux/string.h>`
10			`#include <linux/errno.h>`
11			`#include <linux/skbuff.h>`
12			`#include <linux/rtnetlink.h>`
13			`#include <net/pkt_sched.h>`
14			`#include <net/dsfield.h>`
15			`#include <net/inet_ecn.h>`
16			`#include <asm/byteorder.h>`
17
18
19			`#if 0 /* control */`
20			`#define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)`
21			`#else`
22			`#define DPRINTK(format,args...)`
23			`#endif`
24
25			`#if 0 /* data */`
26			`#define D2PRINTK(format,args...) printk(KERN_DEBUG format,##args)`
27			`#else`
28			`#define D2PRINTK(format,args...)`
29			`#endif`
30
31
32			`#define PRIV(sch) ((struct dsmark_qdisc_data *) qdisc_priv(sch))`
33
34
35			`/*`
36			`* classid class marking`
37			`* ------- ----- -------`
38			`* n/a 0 n/a`
39			`* x:0 1 use entry [0]`
40			`* ... ... ...`
41			`* x:y y>0 y+1 use entry [y]`
42			`* ... ... ...`
43			`* x:indices-1 indices use entry [indices-1]`
44			`* ... ... ...`
45			`* x:y y+1 use entry [y & (indices-1)]`
46			`* ... ... ...`
47			`* 0xffff 0x10000 use entry [indices-1]`
48			`*/`
49
50
51			`#define NO_DEFAULT_INDEX (1 << 16)`
52
53			`struct dsmark_qdisc_data {`
54			`struct Qdisc *q;`
55			`struct tcf_proto *filter_list;`
56			`u8 mask; / "owns" the array */`
57			`u8 *value;`
58			`u16 indices;`
59			`u32 default_index; /* index range is 0...0xffff */`
60			`int set_tc_index;`
61			`};`
62
63			`static inline int dsmark_valid_indices(u16 indices)`
64			`{`
65			`while (indices != 1) {`
66			`if (indices & 1)`
67			`return 0;`
68			`indices >>= 1;`
69			`}`
70
71			`return 1;`
72			`}`
73
74			`static inline int dsmark_valid_index(struct dsmark_qdisc_data *p, u16 index)`
75			`{`
76			`return (index <= p->indices && index > 0);`
77			`}`
78
79			`/* ------------------------- Class/flow operations ------------------------- */`
80
81			`static int dsmark_graft(struct Qdisc *sch, unsigned long arg,`
82			`struct Qdisc new, struct Qdisc *old)`
83			`{`
84			`struct dsmark_qdisc_data *p = PRIV(sch);`
85
86			`DPRINTK("dsmark_graft(sch %p,[qdisc %p],new %p,old %p)\n",`
87			`sch, p, new, old);`
88
89			`if (new == NULL) {`
90			`new = qdisc_create_dflt(sch->dev, &pfifo_qdisc_ops,`
91			`sch->handle);`
92			`if (new == NULL)`
93			`new = &noop_qdisc;`
94			`}`
95
96			`sch_tree_lock(sch);`
97			`*old = xchg(&p->q, new);`
98			`qdisc_tree_decrease_qlen(old, (old)->q.qlen);`
99			`qdisc_reset(*old);`
100			`sch_tree_unlock(sch);`
101
102			`return 0;`
103			`}`
104
105			`static struct Qdisc dsmark_leaf(struct Qdisc sch, unsigned long arg)`
106			`{`
107			`return PRIV(sch)->q;`
108			`}`
109
110			`static unsigned long dsmark_get(struct Qdisc *sch, u32 classid)`
111			`{`
112			`DPRINTK("dsmark_get(sch %p,[qdisc %p],classid %x)\n",`
113			`sch, PRIV(sch), classid);`
114
115			`return TC_H_MIN(classid) + 1;`
116			`}`
117
118			`static unsigned long dsmark_bind_filter(struct Qdisc *sch,`
119			`unsigned long parent, u32 classid)`
120			`{`
121			`return dsmark_get(sch, classid);`
122			`}`
123
124			`static void dsmark_put(struct Qdisc *sch, unsigned long cl)`
125			`{`
126			`}`
127
128			`static int dsmark_change(struct Qdisc *sch, u32 classid, u32 parent,`
129			`struct rtattr *tca, unsigned long arg)`
130			`{`
131			`struct dsmark_qdisc_data *p = PRIV(sch);`
132			`struct rtattr *opt = tca[TCA_OPTIONS-1];`
133			`struct rtattr *tb[TCA_DSMARK_MAX];`
134			`int err = -EINVAL;`
135			`u8 mask = 0;`
136
137			`DPRINTK("dsmark_change(sch %p,[qdisc %p],classid %x,parent %x),"`
138			`"arg 0x%lx\n", sch, p, classid, parent, *arg);`
139
140			`if (!dsmark_valid_index(p, *arg)) {`
141			`err = -ENOENT;`
142			`goto rtattr_failure;`
143			`}`
144
145			`if (!opt \|\| rtattr_parse_nested(tb, TCA_DSMARK_MAX, opt))`
146			`goto rtattr_failure;`
147
148			`if (tb[TCA_DSMARK_MASK-1])`
149			`mask = RTA_GET_U8(tb[TCA_DSMARK_MASK-1]);`
150
151			`if (tb[TCA_DSMARK_VALUE-1])`
152			`p->value[*arg-1] = RTA_GET_U8(tb[TCA_DSMARK_VALUE-1]);`
153
154			`if (tb[TCA_DSMARK_MASK-1])`
155			`p->mask[*arg-1] = mask;`
156
157			`err = 0;`
158
159			`rtattr_failure:`
160			`return err;`
161			`}`
162
163			`static int dsmark_delete(struct Qdisc *sch, unsigned long arg)`
164			`{`
165			`struct dsmark_qdisc_data *p = PRIV(sch);`
166
167			`if (!dsmark_valid_index(p, arg))`
168			`return -EINVAL;`
169
170			`p->mask[arg-1] = 0xff;`
171			`p->value[arg-1] = 0;`
172
173			`return 0;`
174			`}`
175
176			`static void dsmark_walk(struct Qdisc sch,struct qdisc_walker walker)`
177			`{`
178			`struct dsmark_qdisc_data *p = PRIV(sch);`
179			`int i;`
180
181			`DPRINTK("dsmark_walk(sch %p,[qdisc %p],walker %p)\n", sch, p, walker);`
182
183			`if (walker->stop)`
184			`return;`
185
186			`for (i = 0; i < p->indices; i++) {`
187			`if (p->mask[i] == 0xff && !p->value[i])`
188			`goto ignore;`
189			`if (walker->count >= walker->skip) {`
190			`if (walker->fn(sch, i+1, walker) < 0) {`
191			`walker->stop = 1;`
192			`break;`
193			`}`
194			`}`
195			`ignore:`
196			`walker->count++;`
197			`}`
198			`}`
199
200			`static struct tcf_proto *dsmark_find_tcf(struct Qdisc sch,unsigned long cl)`
201			`{`
202			`return &PRIV(sch)->filter_list;`
203			`}`
204
205			`/* --------------------------- Qdisc operations ---------------------------- */`
206
207			`static int dsmark_enqueue(struct sk_buff skb,struct Qdisc sch)`
208			`{`
209			`struct dsmark_qdisc_data *p = PRIV(sch);`
210			`int err;`
211
212			`D2PRINTK("dsmark_enqueue(skb %p,sch %p,[qdisc %p])\n", skb, sch, p);`
213
214			`if (p->set_tc_index) {`
215			`/* FIXME: Safe with non-linear skbs? --RR */`
216			`switch (skb->protocol) {`
217			`case __constant_htons(ETH_P_IP):`
218			`skb->tc_index = ipv4_get_dsfield(ip_hdr(skb))`
219			`& ~INET_ECN_MASK;`
220			`break;`
221			`case __constant_htons(ETH_P_IPV6):`
222			`skb->tc_index = ipv6_get_dsfield(ipv6_hdr(skb))`
223			`& ~INET_ECN_MASK;`
224			`break;`
225			`default:`
226			`skb->tc_index = 0;`
227			`break;`
228			`}`
229			`}`
230
231			`if (TC_H_MAJ(skb->priority) == sch->handle)`
232			`skb->tc_index = TC_H_MIN(skb->priority);`
233			`else {`
234			`struct tcf_result res;`
235			`int result = tc_classify(skb, p->filter_list, &res);`
236
237			`D2PRINTK("result %d class 0x%04x\n", result, res.classid);`
238
239			`switch (result) {`
240			`#ifdef CONFIG_NET_CLS_ACT`
241			`case TC_ACT_QUEUED:`
242			`case TC_ACT_STOLEN:`
243			`kfree_skb(skb);`
244			`return NET_XMIT_SUCCESS;`
245			`case TC_ACT_SHOT:`
246			`kfree_skb(skb);`
247			`sch->qstats.drops++;`
248			`return NET_XMIT_BYPASS;`
249			`#endif`
250			`case TC_ACT_OK:`
251			`skb->tc_index = TC_H_MIN(res.classid);`
252			`break;`
253			`default:`
254			`if (p->default_index != NO_DEFAULT_INDEX)`
255			`skb->tc_index = p->default_index;`
256			`break;`
257			`}`
258			`}`
259
260			`err = p->q->enqueue(skb,p->q);`
261			`if (err != NET_XMIT_SUCCESS) {`
262			`sch->qstats.drops++;`
263			`return err;`
264			`}`
265
266			`sch->bstats.bytes += skb->len;`
267			`sch->bstats.packets++;`
268			`sch->q.qlen++;`
269
270			`return NET_XMIT_SUCCESS;`
271			`}`
272
273			`static struct sk_buff dsmark_dequeue(struct Qdisc sch)`
274			`{`
275			`struct dsmark_qdisc_data *p = PRIV(sch);`
276			`struct sk_buff *skb;`
277			`u32 index;`
278
279			`D2PRINTK("dsmark_dequeue(sch %p,[qdisc %p])\n", sch, p);`
280
281			`skb = p->q->ops->dequeue(p->q);`
282			`if (skb == NULL)`
283			`return NULL;`
284
285			`sch->q.qlen--;`
286
287			`index = skb->tc_index & (p->indices - 1);`
288			`D2PRINTK("index %d->%d\n", skb->tc_index, index);`
289
290			`switch (skb->protocol) {`
291			`case __constant_htons(ETH_P_IP):`
292			`ipv4_change_dsfield(ip_hdr(skb), p->mask[index],`
293			`p->value[index]);`
294			`break;`
295			`case __constant_htons(ETH_P_IPV6):`
296			`ipv6_change_dsfield(ipv6_hdr(skb), p->mask[index],`
297			`p->value[index]);`
298			`break;`
299			`default:`
300			`/*`
301			`* Only complain if a change was actually attempted.`
302			`* This way, we can send non-IP traffic through dsmark`
303			`* and don't need yet another qdisc as a bypass.`
304			`*/`
305			`if (p->mask[index] != 0xff \|\| p->value[index])`
306			`printk(KERN_WARNING "dsmark_dequeue: "`
307			`"unsupported protocol %d\n",`
308			`ntohs(skb->protocol));`
309			`break;`
310			`}`
311
312			`return skb;`
313			`}`
314
315			`static int dsmark_requeue(struct sk_buff skb,struct Qdisc sch)`
316			`{`
317			`struct dsmark_qdisc_data *p = PRIV(sch);`
318			`int err;`
319
320			`D2PRINTK("dsmark_requeue(skb %p,sch %p,[qdisc %p])\n", skb, sch, p);`
321
322			`err = p->q->ops->requeue(skb, p->q);`
323			`if (err != NET_XMIT_SUCCESS) {`
324			`sch->qstats.drops++;`
325			`return err;`
326			`}`
327
328			`sch->q.qlen++;`
329			`sch->qstats.requeues++;`
330
331			`return NET_XMIT_SUCCESS;`
332			`}`
333
334			`static unsigned int dsmark_drop(struct Qdisc *sch)`
335			`{`
336			`struct dsmark_qdisc_data *p = PRIV(sch);`
337			`unsigned int len;`
338
339			`DPRINTK("dsmark_reset(sch %p,[qdisc %p])\n", sch, p);`
340
341			`if (p->q->ops->drop == NULL)`
342			`return 0;`
343
344			`len = p->q->ops->drop(p->q);`
345			`if (len)`
346			`sch->q.qlen--;`
347
348			`return len;`
349			`}`
350
351			`static int dsmark_init(struct Qdisc sch, struct rtattr opt)`
352			`{`
353			`struct dsmark_qdisc_data *p = PRIV(sch);`
354			`struct rtattr *tb[TCA_DSMARK_MAX];`
355			`int err = -EINVAL;`
356			`u32 default_index = NO_DEFAULT_INDEX;`
357			`u16 indices;`
358			`u8 *mask;`
359
360			`DPRINTK("dsmark_init(sch %p,[qdisc %p],opt %p)\n", sch, p, opt);`
361
362			`if (!opt \|\| rtattr_parse_nested(tb, TCA_DSMARK_MAX, opt) < 0)`
363			`goto errout;`
364
365			`indices = RTA_GET_U16(tb[TCA_DSMARK_INDICES-1]);`
366			`if (!indices \|\| !dsmark_valid_indices(indices))`
367			`goto errout;`
368
369			`if (tb[TCA_DSMARK_DEFAULT_INDEX-1])`
370			`default_index = RTA_GET_U16(tb[TCA_DSMARK_DEFAULT_INDEX-1]);`
371
372			`mask = kmalloc(indices * 2, GFP_KERNEL);`
373			`if (mask == NULL) {`
374			`err = -ENOMEM;`
375			`goto errout;`
376			`}`
377
378			`p->mask = mask;`
379			`memset(p->mask, 0xff, indices);`
380
381			`p->value = p->mask + indices;`
382			`memset(p->value, 0, indices);`
383
384			`p->indices = indices;`
385			`p->default_index = default_index;`
386			`p->set_tc_index = RTA_GET_FLAG(tb[TCA_DSMARK_SET_TC_INDEX-1]);`
387
388			`p->q = qdisc_create_dflt(sch->dev, &pfifo_qdisc_ops, sch->handle);`
389			`if (p->q == NULL)`
390			`p->q = &noop_qdisc;`
391
392			`DPRINTK("dsmark_init: qdisc %p\n", p->q);`
393
394			`err = 0;`
395			`errout:`
396			`rtattr_failure:`
397			`return err;`
398			`}`
399
400			`static void dsmark_reset(struct Qdisc *sch)`
401			`{`
402			`struct dsmark_qdisc_data *p = PRIV(sch);`
403
404			`DPRINTK("dsmark_reset(sch %p,[qdisc %p])\n", sch, p);`
405			`qdisc_reset(p->q);`
406			`sch->q.qlen = 0;`
407			`}`
408
409			`static void dsmark_destroy(struct Qdisc *sch)`
410			`{`
411			`struct dsmark_qdisc_data *p = PRIV(sch);`
412
413			`DPRINTK("dsmark_destroy(sch %p,[qdisc %p])\n", sch, p);`
414
415			`tcf_destroy_chain(p->filter_list);`
416			`qdisc_destroy(p->q);`
417			`kfree(p->mask);`
418			`}`
419
420			`static int dsmark_dump_class(struct Qdisc *sch, unsigned long cl,`
421			`struct sk_buff skb, struct tcmsg tcm)`
422			`{`
423			`struct dsmark_qdisc_data *p = PRIV(sch);`
424			`struct rtattr *opts = NULL;`
425
426			`DPRINTK("dsmark_dump_class(sch %p,[qdisc %p],class %ld\n", sch, p, cl);`
427
428			`if (!dsmark_valid_index(p, cl))`
429			`return -EINVAL;`
430
431			`tcm->tcm_handle = TC_H_MAKE(TC_H_MAJ(sch->handle), cl-1);`
432			`tcm->tcm_info = p->q->handle;`
433
434			`opts = RTA_NEST(skb, TCA_OPTIONS);`
435			`RTA_PUT_U8(skb,TCA_DSMARK_MASK, p->mask[cl-1]);`
436			`RTA_PUT_U8(skb,TCA_DSMARK_VALUE, p->value[cl-1]);`
437
438			`return RTA_NEST_END(skb, opts);`
439
440			`rtattr_failure:`
441			`return RTA_NEST_CANCEL(skb, opts);`
442			`}`
443
444			`static int dsmark_dump(struct Qdisc sch, struct sk_buff skb)`
445			`{`
446			`struct dsmark_qdisc_data *p = PRIV(sch);`
447			`struct rtattr *opts = NULL;`
448
449			`opts = RTA_NEST(skb, TCA_OPTIONS);`
450			`RTA_PUT_U16(skb, TCA_DSMARK_INDICES, p->indices);`
451
452			`if (p->default_index != NO_DEFAULT_INDEX)`
453			`RTA_PUT_U16(skb, TCA_DSMARK_DEFAULT_INDEX, p->default_index);`
454
455			`if (p->set_tc_index)`
456			`RTA_PUT_FLAG(skb, TCA_DSMARK_SET_TC_INDEX);`
457
458			`return RTA_NEST_END(skb, opts);`
459
460			`rtattr_failure:`
461			`return RTA_NEST_CANCEL(skb, opts);`
462			`}`
463
464			`static struct Qdisc_class_ops dsmark_class_ops = {`
465			`.graft = dsmark_graft,`
466			`.leaf = dsmark_leaf,`
467			`.get = dsmark_get,`
468			`.put = dsmark_put,`
469			`.change = dsmark_change,`
470			`.delete = dsmark_delete,`
471			`.walk = dsmark_walk,`
472			`.tcf_chain = dsmark_find_tcf,`
473			`.bind_tcf = dsmark_bind_filter,`
474			`.unbind_tcf = dsmark_put,`
475			`.dump = dsmark_dump_class,`
476			`};`
477
478			`static struct Qdisc_ops dsmark_qdisc_ops = {`
479			`.next = NULL,`
480			`.cl_ops = &dsmark_class_ops,`
481			`.id = "dsmark",`
482			`.priv_size = sizeof(struct dsmark_qdisc_data),`
483			`.enqueue = dsmark_enqueue,`
484			`.dequeue = dsmark_dequeue,`
485			`.requeue = dsmark_requeue,`
486			`.drop = dsmark_drop,`
487			`.init = dsmark_init,`
488			`.reset = dsmark_reset,`
489			`.destroy = dsmark_destroy,`
490			`.change = NULL,`
491			`.dump = dsmark_dump,`
492			`.owner = THIS_MODULE,`
493			`};`
494
495			`static int __init dsmark_module_init(void)`
496			`{`
497			`return register_qdisc(&dsmark_qdisc_ops);`
498			`}`
499
500			`static void __exit dsmark_module_exit(void)`
501			`{`
502			`unregister_qdisc(&dsmark_qdisc_ops);`
503			`}`
504
505			`module_init(dsmark_module_init)`
506			`module_exit(dsmark_module_exit)`
507
508			`MODULE_LICENSE("GPL");`