tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1#ifndef __NET_PKT_SCHED_H
2#define __NET_PKT_SCHED_H
3
4#include <net/sch_generic.h>
5
6struct qdisc_walker
7{
8 int stop;
9 int skip;
10 int count;
11 int (*fn)(struct Qdisc *, unsigned long cl, struct qdisc_walker *);
12};
13
14extern rwlock_t qdisc_tree_lock;
15
16#define QDISC_ALIGNTO 32
17#define QDISC_ALIGN(len) (((len) + QDISC_ALIGNTO-1) & ~(QDISC_ALIGNTO-1))
18
19static inline void *qdisc_priv(struct Qdisc *q)
20{
21 return (char *) q + QDISC_ALIGN(sizeof(struct Qdisc));
22}
23
24/*
25 Timer resolution MUST BE < 10% of min_schedulable_packet_size/bandwidth
26
27 Normal IP packet size ~ 512byte, hence:
28
29 0.5Kbyte/1Mbyte/sec = 0.5msec, so that we need 50usec timer for
30 10Mbit ethernet.
31
32 10msec resolution -> <50Kbit/sec.
33
34 The result: [34]86 is not good choice for QoS router :-(
35
36 The things are not so bad, because we may use artifical
37 clock evaluated by integration of network data flow
38 in the most critical places.
39
40 Note: we do not use fastgettimeofday.
41 The reason is that, when it is not the same thing as
42 gettimeofday, it returns invalid timestamp, which is
43 not updated, when net_bh is active.
44 */
45
46/* General note about internal clock.
47
48 Any clock source returns time intervals, measured in units
49 close to 1usec. With source CONFIG_NET_SCH_CLK_GETTIMEOFDAY it is precisely
50 microseconds, otherwise something close but different chosen to minimize
51 arithmetic cost. Ratio usec/internal untis in form nominator/denominator
52 may be read from /proc/net/psched.
53 */
54
55
56#ifdef CONFIG_NET_SCH_CLK_GETTIMEOFDAY
57
58typedef struct timeval psched_time_t;
59typedef long psched_tdiff_t;
60
61#define PSCHED_GET_TIME(stamp) do_gettimeofday(&(stamp))
62#define PSCHED_US2JIFFIE(usecs) (((usecs)+(1000000/HZ-1))/(1000000/HZ))
63#define PSCHED_JIFFIE2US(delay) ((delay)*(1000000/HZ))
64
65#else /* !CONFIG_NET_SCH_CLK_GETTIMEOFDAY */
66
67typedef u64 psched_time_t;
68typedef long psched_tdiff_t;
69
70#ifdef CONFIG_NET_SCH_CLK_JIFFIES
71
72#if HZ < 96
73#define PSCHED_JSCALE 14
74#elif HZ >= 96 && HZ < 192
75#define PSCHED_JSCALE 13
76#elif HZ >= 192 && HZ < 384
77#define PSCHED_JSCALE 12
78#elif HZ >= 384 && HZ < 768
79#define PSCHED_JSCALE 11
80#elif HZ >= 768
81#define PSCHED_JSCALE 10
82#endif
83
84#define PSCHED_GET_TIME(stamp) ((stamp) = (get_jiffies_64()<<PSCHED_JSCALE))
85#define PSCHED_US2JIFFIE(delay) (((delay)+(1<<PSCHED_JSCALE)-1)>>PSCHED_JSCALE)
86#define PSCHED_JIFFIE2US(delay) ((delay)<<PSCHED_JSCALE)
87
88#endif /* CONFIG_NET_SCH_CLK_JIFFIES */
89#ifdef CONFIG_NET_SCH_CLK_CPU
90#include <asm/timex.h>
91
92extern psched_tdiff_t psched_clock_per_hz;
93extern int psched_clock_scale;
94extern psched_time_t psched_time_base;
95extern cycles_t psched_time_mark;
96
97#define PSCHED_GET_TIME(stamp) \
98do { \
99 cycles_t cur = get_cycles(); \
100 if (sizeof(cycles_t) == sizeof(u32)) { \
101 if (cur <= psched_time_mark) \
102 psched_time_base += 0x100000000ULL; \
103 psched_time_mark = cur; \
104 (stamp) = (psched_time_base + cur)>>psched_clock_scale; \
105 } else { \
106 (stamp) = cur>>psched_clock_scale; \
107 } \
108} while (0)
109#define PSCHED_US2JIFFIE(delay) (((delay)+psched_clock_per_hz-1)/psched_clock_per_hz)
110#define PSCHED_JIFFIE2US(delay) ((delay)*psched_clock_per_hz)
111
112#endif /* CONFIG_NET_SCH_CLK_CPU */
113
114#endif /* !CONFIG_NET_SCH_CLK_GETTIMEOFDAY */
115
116#ifdef CONFIG_NET_SCH_CLK_GETTIMEOFDAY
117#define PSCHED_TDIFF(tv1, tv2) \
118({ \
119 int __delta_sec = (tv1).tv_sec - (tv2).tv_sec; \
120 int __delta = (tv1).tv_usec - (tv2).tv_usec; \
121 if (__delta_sec) { \
122 switch (__delta_sec) { \
123 default: \
124 __delta = 0; \
125 case 2: \
126 __delta += 1000000; \
127 case 1: \
128 __delta += 1000000; \
129 } \
130 } \
131 __delta; \
132})
133
134static inline int
135psched_tod_diff(int delta_sec, int bound)
136{
137 int delta;
138
139 if (bound <= 1000000 || delta_sec > (0x7FFFFFFF/1000000)-1)
140 return bound;
141 delta = delta_sec * 1000000;
142 if (delta > bound || delta < 0)
143 delta = bound;
144 return delta;
145}
146
147#define PSCHED_TDIFF_SAFE(tv1, tv2, bound) \
148({ \
149 int __delta_sec = (tv1).tv_sec - (tv2).tv_sec; \
150 int __delta = (tv1).tv_usec - (tv2).tv_usec; \
151 switch (__delta_sec) { \
152 default: \
153 __delta = psched_tod_diff(__delta_sec, bound); break; \
154 case 2: \
155 __delta += 1000000; \
156 case 1: \
157 __delta += 1000000; \
158 case 0: \
159 if (__delta > bound || __delta < 0) \
160 __delta = bound; \
161 } \
162 __delta; \
163})
164
165#define PSCHED_TLESS(tv1, tv2) (((tv1).tv_usec < (tv2).tv_usec && \
166 (tv1).tv_sec <= (tv2).tv_sec) || \
167 (tv1).tv_sec < (tv2).tv_sec)
168
169#define PSCHED_TADD2(tv, delta, tv_res) \
170({ \
171 int __delta = (tv).tv_usec + (delta); \
172 (tv_res).tv_sec = (tv).tv_sec; \
173 if (__delta > 1000000) { (tv_res).tv_sec++; __delta -= 1000000; } \
174 (tv_res).tv_usec = __delta; \
175})
176
177#define PSCHED_TADD(tv, delta) \
178({ \
179 (tv).tv_usec += (delta); \
180 if ((tv).tv_usec > 1000000) { (tv).tv_sec++; \
181 (tv).tv_usec -= 1000000; } \
182})
183
184/* Set/check that time is in the "past perfect";
185 it depends on concrete representation of system time
186 */
187
188#define PSCHED_SET_PASTPERFECT(t) ((t).tv_sec = 0)
189#define PSCHED_IS_PASTPERFECT(t) ((t).tv_sec == 0)
190
191#define PSCHED_AUDIT_TDIFF(t) ({ if ((t) > 2000000) (t) = 2000000; })
192
193#else /* !CONFIG_NET_SCH_CLK_GETTIMEOFDAY */
194
195#define PSCHED_TDIFF(tv1, tv2) (long)((tv1) - (tv2))
196#define PSCHED_TDIFF_SAFE(tv1, tv2, bound) \
197 min_t(long long, (tv1) - (tv2), bound)
198
199
200#define PSCHED_TLESS(tv1, tv2) ((tv1) < (tv2))
201#define PSCHED_TADD2(tv, delta, tv_res) ((tv_res) = (tv) + (delta))
202#define PSCHED_TADD(tv, delta) ((tv) += (delta))
203#define PSCHED_SET_PASTPERFECT(t) ((t) = 0)
204#define PSCHED_IS_PASTPERFECT(t) ((t) == 0)
205#define PSCHED_AUDIT_TDIFF(t)
206
207#endif /* !CONFIG_NET_SCH_CLK_GETTIMEOFDAY */
208
209extern struct Qdisc_ops pfifo_qdisc_ops;
210extern struct Qdisc_ops bfifo_qdisc_ops;
211
212extern int register_qdisc(struct Qdisc_ops *qops);
213extern int unregister_qdisc(struct Qdisc_ops *qops);
214extern struct Qdisc *qdisc_lookup(struct net_device *dev, u32 handle);
215extern struct Qdisc *qdisc_lookup_class(struct net_device *dev, u32 handle);
216extern struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r,
217 struct rtattr *tab);
218extern void qdisc_put_rtab(struct qdisc_rate_table *tab);
219
220extern int qdisc_restart(struct net_device *dev);
221
222static inline void qdisc_run(struct net_device *dev)
223{
224 while (!netif_queue_stopped(dev) && qdisc_restart(dev) < 0)
225 /* NOTHING */;
226}
227
228extern int tc_classify(struct sk_buff *skb, struct tcf_proto *tp,
229 struct tcf_result *res);
230
231/* Calculate maximal size of packet seen by hard_start_xmit
232 routine of this device.
233 */
234static inline unsigned psched_mtu(struct net_device *dev)
235{
236 unsigned mtu = dev->mtu;
237 return dev->hard_header ? mtu + dev->hard_header_len : mtu;
238}
239
240#endif