1 #ifndef __NET_PKT_SCHED_H 2 #define __NET_PKT_SCHED_H 3 4 #include <net/sch_generic.h> 5 6 struct 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 14 extern rwlock_t qdisc_tree_lock; 15 16 #define QDISC_ALIGNTO 32 17 #define QDISC_ALIGN(len) (((len) + QDISC_ALIGNTO-1) & ~(QDISC_ALIGNTO-1)) 18 19 static 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 58 typedef struct timeval psched_time_t; 59 typedef 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 67 typedef u64 psched_time_t; 68 typedef 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 92 extern psched_tdiff_t psched_clock_per_hz; 93 extern int psched_clock_scale; 94 extern psched_time_t psched_time_base; 95 extern cycles_t psched_time_mark; 96 97 #define PSCHED_GET_TIME(stamp) \ 98 do { \ 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 134 static inline int 135 psched_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 209 extern struct Qdisc_ops pfifo_qdisc_ops; 210 extern struct Qdisc_ops bfifo_qdisc_ops; 211 212 extern int register_qdisc(struct Qdisc_ops *qops); 213 extern int unregister_qdisc(struct Qdisc_ops *qops); 214 extern struct Qdisc *qdisc_lookup(struct net_device *dev, u32 handle); 215 extern struct Qdisc *qdisc_lookup_class(struct net_device *dev, u32 handle); 216 extern struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r, 217 struct rtattr *tab); 218 extern void qdisc_put_rtab(struct qdisc_rate_table *tab); 219 220 extern int qdisc_restart(struct net_device *dev); 221 222 static inline void qdisc_run(struct net_device *dev) 223 { 224 while (!netif_queue_stopped(dev) && qdisc_restart(dev) < 0) 225 /* NOTHING */; 226 } 227 228 extern 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 */ 234 static 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 241