开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
pkt_sched.h
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：12k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

pkt_sched.h：源码内容
  1. #ifndef __NET_PKT_SCHED_H
  2. #define __NET_PKT_SCHED_H
  4. #define PSCHED_GETTIMEOFDAY 1
  5. #define PSCHED_JIFFIES  2
  6. #define PSCHED_CPU  3
  8. #define PSCHED_CLOCK_SOURCE PSCHED_JIFFIES
  10. #include <linux/config.h>
  11. #include <linux/pkt_sched.h>
  12. #include <net/pkt_cls.h>
  14. #ifdef CONFIG_X86_TSC
  15. #include <asm/msr.h>
  16. #endif
  18. struct rtattr;
  19. struct Qdisc;
  21. struct qdisc_walker
  22. {
  23. int stop;
  24. int skip;
  25. int count;
  26. int (*fn)(struct Qdisc *, unsigned long cl, struct qdisc_walker *);
  27. };
  29. struct Qdisc_class_ops
  30. {
  31. /* Child qdisc manipulation */
  32. int (*graft)(struct Qdisc *, unsigned long cl, struct Qdisc *, struct Qdisc **);
  33. struct Qdisc * (*leaf)(struct Qdisc *, unsigned long cl);
  35. /* Class manipulation routines */
  36. unsigned long (*get)(struct Qdisc *, u32 classid);
  37. void (*put)(struct Qdisc *, unsigned long);
  38. int (*change)(struct Qdisc *, u32, u32, struct rtattr **, unsigned long *);
  39. int (*delete)(struct Qdisc *, unsigned long);
  40. void (*walk)(struct Qdisc *, struct qdisc_walker * arg);
  42. /* Filter manipulation */
  43. struct tcf_proto ** (*tcf_chain)(struct Qdisc *, unsigned long);
  44. unsigned long (*bind_tcf)(struct Qdisc *, unsigned long, u32 classid);
  45. void (*unbind_tcf)(struct Qdisc *, unsigned long);
  47. /* rtnetlink specific */
  48. int (*dump)(struct Qdisc *, unsigned long, struct sk_buff *skb, struct tcmsg*);
  49. };
  51. struct Qdisc_ops
  52. {
  53. struct Qdisc_ops *next;
  54. struct Qdisc_class_ops *cl_ops;
  55. char id[IFNAMSIZ];
  56. int priv_size;
  58. int  (*enqueue)(struct sk_buff *, struct Qdisc *);
  59. struct sk_buff * (*dequeue)(struct Qdisc *);
  60. int  (*requeue)(struct sk_buff *, struct Qdisc *);
  61. int (*drop)(struct Qdisc *);
  63. int (*init)(struct Qdisc *, struct rtattr *arg);
  64. void (*reset)(struct Qdisc *);
  65. void (*destroy)(struct Qdisc *);
  66. int (*change)(struct Qdisc *, struct rtattr *arg);
  68. int (*dump)(struct Qdisc *, struct sk_buff *);
  69. };
  71. extern rwlock_t qdisc_tree_lock;
  73. struct Qdisc
  74. {
  75. int  (*enqueue)(struct sk_buff *skb, struct Qdisc *dev);
  76. struct sk_buff * (*dequeue)(struct Qdisc *dev);
  77. unsigned flags;
  78. #define TCQ_F_BUILTIN 1
  79. #define TCQ_F_THROTTLED 2
  80. #define TCQ_F_INGRES 4
  81. struct Qdisc_ops *ops;
  82. struct Qdisc *next;
  83. u32 handle;
  84. atomic_t refcnt;
  85. struct sk_buff_head q;
  86. struct net_device *dev;
  88. struct tc_stats stats;
  89. int (*reshape_fail)(struct sk_buff *skb, struct Qdisc *q);
  91. /* This field is deprecated, but it is still used by CBQ
  92.  * and it will live until better solution will be invented.
  93.  */
  94. struct Qdisc *__parent;
  96. char data[0];
  97. };
  99. struct qdisc_rate_table
  100. {
  101. struct tc_ratespec rate;
  102. u32 data[256];
  103. struct qdisc_rate_table *next;
  104. int refcnt;
  105. };
  107. static inline void sch_tree_lock(struct Qdisc *q)
  108. {
  109. write_lock(&qdisc_tree_lock);
  110. spin_lock_bh(&q->dev->queue_lock);
  111. }
  113. static inline void sch_tree_unlock(struct Qdisc *q)
  114. {
  115. spin_unlock_bh(&q->dev->queue_lock);
  116. write_unlock(&qdisc_tree_lock);
  117. }
  119. static inline void tcf_tree_lock(struct tcf_proto *tp)
  120. {
  121. write_lock(&qdisc_tree_lock);
  122. spin_lock_bh(&tp->q->dev->queue_lock);
  123. }
  125. static inline void tcf_tree_unlock(struct tcf_proto *tp)
  126. {
  127. spin_unlock_bh(&tp->q->dev->queue_lock);
  128. write_unlock(&qdisc_tree_lock);
  129. }
  132. static inline unsigned long
  133. cls_set_class(struct tcf_proto *tp, unsigned long *clp, unsigned long cl)
  134. {
  135. unsigned long old_cl;
  137. tcf_tree_lock(tp);
  138. old_cl = *clp;
  139. *clp = cl;
  140. tcf_tree_unlock(tp);
  141. return old_cl;
  142. }
  144. static inline unsigned long
  145. __cls_set_class(unsigned long *clp, unsigned long cl)
  146. {
  147. unsigned long old_cl;
  149. old_cl = *clp;
  150. *clp = cl;
  151. return old_cl;
  152. }
  155. /* 
  156.    Timer resolution MUST BE < 10% of min_schedulable_packet_size/bandwidth
  157.    
  158.    Normal IP packet size ~ 512byte, hence:
  160.    0.5Kbyte/1Mbyte/sec = 0.5msec, so that we need 50usec timer for
  161.    10Mbit ethernet.
  163.    10msec resolution -> <50Kbit/sec.
  164.    
  165.    The result: [34]86 is not good choice for QoS router :-(
  167.    The things are not so bad, because we may use artifical
  168.    clock evaluated by integration of network data flow
  169.    in the most critical places.
  171.    Note: we do not use fastgettimeofday.
  172.    The reason is that, when it is not the same thing as
  173.    gettimeofday, it returns invalid timestamp, which is
  174.    not updated, when net_bh is active.
  176.    So, use PSCHED_CLOCK_SOURCE = PSCHED_CPU on alpha and pentiums
  177.    with rtdsc. And PSCHED_JIFFIES on all other architectures, including [34]86
  178.    and pentiums without rtdsc.
  179.    You can use PSCHED_GETTIMEOFDAY on another architectures,
  180.    which have fast and precise clock source, but it is too expensive.
  181.  */
  183. /* General note about internal clock.
  185.    Any clock source returns time intervals, measured in units
  186.    close to 1usec. With source PSCHED_GETTIMEOFDAY it is precisely
  187.    microseconds, otherwise something close but different chosen to minimize
  188.    arithmetic cost. Ratio usec/internal untis in form nominator/denominator
  189.    may be read from /proc/net/psched.
  190.  */
  193. #if PSCHED_CLOCK_SOURCE == PSCHED_GETTIMEOFDAY
  195. typedef struct timeval psched_time_t;
  196. typedef long psched_tdiff_t;
  198. #define PSCHED_GET_TIME(stamp) do_gettimeofday(&(stamp))
  199. #define PSCHED_US2JIFFIE(usecs) (((usecs)+(1000000/HZ-1))/(1000000/HZ))
  201. #define PSCHED_EXPORTLIST EXPORT_SYMBOL(psched_tod_diff);
  203. #else /* PSCHED_CLOCK_SOURCE != PSCHED_GETTIMEOFDAY */
  205. #define PSCHED_EXPORTLIST PSCHED_EXPORTLIST_1 PSCHED_EXPORTLIST_2
  207. typedef u64 psched_time_t;
  208. typedef long psched_tdiff_t;
  210. extern psched_time_t psched_time_base;
  212. #if PSCHED_CLOCK_SOURCE == PSCHED_JIFFIES
  214. #if HZ == 100
  215. #define PSCHED_JSCALE 13
  216. #elif HZ == 1024
  217. #define PSCHED_JSCALE 10
  218. #else
  219. #define PSCHED_JSCALE 0
  220. #endif
  222. #define PSCHED_EXPORTLIST_2
  224. #if ~0UL == 0xFFFFFFFF
  226. #define PSCHED_WATCHER unsigned long
  228. extern PSCHED_WATCHER psched_time_mark;
  230. #define PSCHED_GET_TIME(stamp) ((stamp) = psched_time_base + (((unsigned long)(jiffies-psched_time_mark))<<PSCHED_JSCALE))
  232. #define PSCHED_EXPORTLIST_1 EXPORT_SYMBOL(psched_time_base); 
  233.                             EXPORT_SYMBOL(psched_time_mark);
  235. #else
  237. #define PSCHED_GET_TIME(stamp) ((stamp) = (jiffies<<PSCHED_JSCALE))
  239. #define PSCHED_EXPORTLIST_1 
  241. #endif
  243. #define PSCHED_US2JIFFIE(delay) (((delay)+(1<<PSCHED_JSCALE)-1)>>PSCHED_JSCALE)
  245. #elif PSCHED_CLOCK_SOURCE == PSCHED_CPU
  247. extern psched_tdiff_t psched_clock_per_hz;
  248. extern int psched_clock_scale;
  250. #define PSCHED_EXPORTLIST_2 EXPORT_SYMBOL(psched_clock_per_hz); 
  251.                             EXPORT_SYMBOL(psched_clock_scale);
  253. #define PSCHED_US2JIFFIE(delay) (((delay)+psched_clock_per_hz-1)/psched_clock_per_hz)
  255. #ifdef CONFIG_X86_TSC
  257. #define PSCHED_GET_TIME(stamp) 
  258. ({ u64 __cur; 
  259.    rdtscll(__cur); 
  260.    (stamp) = __cur>>psched_clock_scale; 
  261. })
  263. #define PSCHED_EXPORTLIST_1
  265. #elif defined (__alpha__)
  267. #define PSCHED_WATCHER u32
  269. extern PSCHED_WATCHER psched_time_mark;
  271. #define PSCHED_GET_TIME(stamp) 
  272. ({ u32 __res; 
  273.    __asm__ __volatile__ ("rpcc %0" : "r="(__res)); 
  274.    if (__res <= psched_time_mark) psched_time_base += 0x100000000UL; 
  275.    psched_time_mark = __res; 
  276.    (stamp) = (psched_time_base + __res)>>psched_clock_scale; 
  277. })
  279. #define PSCHED_EXPORTLIST_1 EXPORT_SYMBOL(psched_time_base); 
  280.                             EXPORT_SYMBOL(psched_time_mark);
  282. #else
  284. #error PSCHED_CLOCK_SOURCE=PSCHED_CPU is not supported on this arch.
  286. #endif /* ARCH */
  288. #endif /* PSCHED_CLOCK_SOURCE == PSCHED_JIFFIES */
  290. #endif /* PSCHED_CLOCK_SOURCE == PSCHED_GETTIMEOFDAY */
  292. #if PSCHED_CLOCK_SOURCE == PSCHED_GETTIMEOFDAY
  293. #define PSCHED_TDIFF(tv1, tv2) 
  294. ({ 
  295.    int __delta_sec = (tv1).tv_sec - (tv2).tv_sec; 
  296.    int __delta = (tv1).tv_usec - (tv2).tv_usec; 
  297.    if (__delta_sec) { 
  298.            switch (__delta_sec) { 
  299.    default: 
  300.    __delta = 0; 
  301.    case 2: 
  302.    __delta += 1000000; 
  303.    case 1: 
  304.    __delta += 1000000; 
  305.            } 
  306.    } 
  307.    __delta; 
  308. })
  310. extern int psched_tod_diff(int delta_sec, int bound);
  312. #define PSCHED_TDIFF_SAFE(tv1, tv2, bound, guard) 
  313. ({ 
  314.    int __delta_sec = (tv1).tv_sec - (tv2).tv_sec; 
  315.    int __delta = (tv1).tv_usec - (tv2).tv_usec; 
  316.    switch (__delta_sec) { 
  317.    default: 
  318.    __delta = psched_tod_diff(__delta_sec, bound); guard; break; 
  319.    case 2: 
  320.    __delta += 1000000; 
  321.    case 1: 
  322.    __delta += 1000000; 
  323.    case 0: ; 
  324.    } 
  325.    __delta; 
  326. })
  328. #define PSCHED_TLESS(tv1, tv2) (((tv1).tv_usec < (tv2).tv_usec && 
  329. (tv1).tv_sec <= (tv2).tv_sec) || 
  330.  (tv1).tv_sec < (tv2).tv_sec)
  332. #define PSCHED_TADD2(tv, delta, tv_res) 
  333. ({ 
  334.    int __delta = (tv).tv_usec + (delta); 
  335.    (tv_res).tv_sec = (tv).tv_sec; 
  336.    if (__delta > 1000000) { (tv_res).tv_sec++; __delta -= 1000000; } 
  337.    (tv_res).tv_usec = __delta; 
  338. })
  340. #define PSCHED_TADD(tv, delta) 
  341. ({ 
  342.    (tv).tv_usec += (delta); 
  343.    if ((tv).tv_usec > 1000000) { (tv).tv_sec++; 
  344.  (tv).tv_usec -= 1000000; } 
  345. })
  347. /* Set/check that time is in the "past perfect";
  348.    it depends on concrete representation of system time
  349.  */
  351. #define PSCHED_SET_PASTPERFECT(t) ((t).tv_sec = 0)
  352. #define PSCHED_IS_PASTPERFECT(t) ((t).tv_sec == 0)
  354. #define PSCHED_AUDIT_TDIFF(t) ({ if ((t) > 2000000) (t) = 2000000; })
  356. #else
  358. #define PSCHED_TDIFF(tv1, tv2) (long)((tv1) - (tv2))
  359. #define PSCHED_TDIFF_SAFE(tv1, tv2, bound, guard) 
  360. ({ 
  361.    long __delta = (tv1) - (tv2); 
  362.    if ( __delta > (bound)) {  __delta = (bound); guard; } 
  363.    __delta; 
  364. })
  367. #define PSCHED_TLESS(tv1, tv2) ((tv1) < (tv2))
  368. #define PSCHED_TADD2(tv, delta, tv_res) ((tv_res) = (tv) + (delta))
  369. #define PSCHED_TADD(tv, delta) ((tv) += (delta))
  370. #define PSCHED_SET_PASTPERFECT(t) ((t) = 0)
  371. #define PSCHED_IS_PASTPERFECT(t) ((t) == 0)
  372. #define PSCHED_AUDIT_TDIFF(t)
  374. #endif
  376. struct tcf_police
  377. {
  378. struct tcf_police *next;
  379. int refcnt;
  380. u32 index;
  382. int action;
  383. int result;
  384. u32 ewma_rate;
  385. u32 burst;
  386. u32 mtu;
  388. u32 toks;
  389. u32 ptoks;
  390. psched_time_t t_c;
  391. spinlock_t lock;
  392. struct qdisc_rate_table *R_tab;
  393. struct qdisc_rate_table *P_tab;
  395. struct tc_stats stats;
  396. };
  398. extern int qdisc_copy_stats(struct sk_buff *skb, struct tc_stats *st);
  399. extern void tcf_police_destroy(struct tcf_police *p);
  400. extern struct tcf_police * tcf_police_locate(struct rtattr *rta, struct rtattr *est);
  401. extern int tcf_police_dump(struct sk_buff *skb, struct tcf_police *p);
  402. extern int tcf_police(struct sk_buff *skb, struct tcf_police *p);
  404. static inline void tcf_police_release(struct tcf_police *p)
  405. {
  406. if (p && --p->refcnt == 0)
  407. tcf_police_destroy(p);
  408. }
  410. extern struct Qdisc noop_qdisc;
  411. extern struct Qdisc_ops noop_qdisc_ops;
  412. extern struct Qdisc_ops pfifo_qdisc_ops;
  413. extern struct Qdisc_ops bfifo_qdisc_ops;
  415. int register_qdisc(struct Qdisc_ops *qops);
  416. int unregister_qdisc(struct Qdisc_ops *qops);
  417. struct Qdisc *qdisc_lookup(struct net_device *dev, u32 handle);
  418. struct Qdisc *qdisc_lookup_class(struct net_device *dev, u32 handle);
  419. void dev_init_scheduler(struct net_device *dev);
  420. void dev_shutdown(struct net_device *dev);
  421. void dev_activate(struct net_device *dev);
  422. void dev_deactivate(struct net_device *dev);
  423. void qdisc_reset(struct Qdisc *qdisc);
  424. void qdisc_destroy(struct Qdisc *qdisc);
  425. struct Qdisc * qdisc_create_dflt(struct net_device *dev, struct Qdisc_ops *ops);
  426. int qdisc_new_estimator(struct tc_stats *stats, struct rtattr *opt);
  427. void qdisc_kill_estimator(struct tc_stats *stats);
  428. struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r, struct rtattr *tab);
  429. void qdisc_put_rtab(struct qdisc_rate_table *tab);
  430. int teql_init(void);
  431. int tc_filter_init(void);
  432. int pktsched_init(void);
  434. extern int qdisc_restart(struct net_device *dev);
  436. static inline void qdisc_run(struct net_device *dev)
  437. {
  438. while (!netif_queue_stopped(dev) &&
  439.        qdisc_restart(dev)<0)
  440. /* NOTHING */;
  441. }
  443. /* Calculate maximal size of packet seen by hard_start_xmit
  444.    routine of this device.
  445.  */
  446. static inline unsigned psched_mtu(struct net_device *dev)
  447. {
  448. unsigned mtu = dev->mtu;
  449. return dev->hard_header ? mtu + dev->hard_header_len : mtu;
  450. }
  452. #endif