[IPV6]: Make fib6_init to return an error code.

[linux-2.6] / include / net / pkt_sched.h

diff --git a/include/net/pkt_sched.h b/include/net/pkt_sched.h
index f6afee73235de8ca5e3ce395a2d53f1ee8c9b650..ab61809a9616af402d8d197da3fc58a89b05e69c 100644 (file)
--- a/include/net/pkt_sched.h
+++ b/include/net/pkt_sched.h
@@ -2,6 +2,7 @@
 #define __NET_PKT_SCHED_H
 
 #include <linux/jiffies.h>
 #define __NET_PKT_SCHED_H
 
 #include <linux/jiffies.h>

+#include <linux/ktime.h>

 #include <net/sch_generic.h>
 
 struct qdisc_walker
 #include <net/sch_generic.h>
 
 struct qdisc_walker


@@ -12,8 +13,6 @@ struct qdisc_walker
        int     (*fn)(struct Qdisc *, unsigned long cl, struct qdisc_walker *);
 };
 
        int     (*fn)(struct Qdisc *, unsigned long cl, struct qdisc_walker *);
 };
 

-extern rwlock_t qdisc_tree_lock;
-

 #define QDISC_ALIGNTO          32
 #define QDISC_ALIGN(len)       (((len) + QDISC_ALIGNTO-1) & ~(QDISC_ALIGNTO-1))
 
 #define QDISC_ALIGNTO          32
 #define QDISC_ALIGN(len)       (((len) + QDISC_ALIGNTO-1) & ~(QDISC_ALIGNTO-1))
 


@@ -37,175 +36,38 @@ static inline void *qdisc_priv(struct Qdisc *q)
    The things are not so bad, because we may use artifical
    clock evaluated by integration of network data flow
    in the most critical places.
    The things are not so bad, because we may use artifical
    clock evaluated by integration of network data flow
    in the most critical places.

-
-   Note: we do not use fastgettimeofday.
-   The reason is that, when it is not the same thing as
-   gettimeofday, it returns invalid timestamp, which is
-   not updated, when net_bh is active.
- */
-
-/* General note about internal clock.
-
-   Any clock source returns time intervals, measured in units
-   close to 1usec. With source CONFIG_NET_SCH_CLK_GETTIMEOFDAY it is precisely
-   microseconds, otherwise something close but different chosen to minimize
-   arithmetic cost. Ratio usec/internal untis in form nominator/denominator
-   may be read from /proc/net/psched.

  */
 
  */
 

-
-#ifdef CONFIG_NET_SCH_CLK_GETTIMEOFDAY
-
-typedef struct timeval psched_time_t;
-typedef long           psched_tdiff_t;
-
-#define PSCHED_GET_TIME(stamp) do_gettimeofday(&(stamp))
-#define PSCHED_US2JIFFIE(usecs) usecs_to_jiffies(usecs)
-#define PSCHED_JIFFIE2US(delay) jiffies_to_usecs(delay)
-
-#else /* !CONFIG_NET_SCH_CLK_GETTIMEOFDAY */
-

 typedef u64    psched_time_t;
 typedef long   psched_tdiff_t;
 
 typedef u64    psched_time_t;
 typedef long   psched_tdiff_t;
 

-#ifdef CONFIG_NET_SCH_CLK_JIFFIES
-
-#if HZ < 96
-#define PSCHED_JSCALE 14
-#elif HZ >= 96 && HZ < 192
-#define PSCHED_JSCALE 13
-#elif HZ >= 192 && HZ < 384
-#define PSCHED_JSCALE 12
-#elif HZ >= 384 && HZ < 768
-#define PSCHED_JSCALE 11
-#elif HZ >= 768
-#define PSCHED_JSCALE 10
-#endif
+/* Avoid doing 64 bit divide by 1000 */
+#define PSCHED_US2NS(x)                        ((s64)(x) << 10)
+#define PSCHED_NS2US(x)                        ((x) >> 10)

 
 

-#define PSCHED_GET_TIME(stamp) ((stamp) = (get_jiffies_64()<<PSCHED_JSCALE))
-#define PSCHED_US2JIFFIE(delay) (((delay)+(1<<PSCHED_JSCALE)-1)>>PSCHED_JSCALE)
-#define PSCHED_JIFFIE2US(delay) ((delay)<<PSCHED_JSCALE)
-
-#endif /* CONFIG_NET_SCH_CLK_JIFFIES */
-#ifdef CONFIG_NET_SCH_CLK_CPU
-#include <asm/timex.h>
-
-extern psched_tdiff_t psched_clock_per_hz;
-extern int psched_clock_scale;
-extern psched_time_t psched_time_base;
-extern cycles_t psched_time_mark;
-
-#define PSCHED_GET_TIME(stamp)                                         \
-do {                                                                   \
-       cycles_t cur = get_cycles();                                    \
-       if (sizeof(cycles_t) == sizeof(u32)) {                          \
-               if (cur <= psched_time_mark)                            \
-                       psched_time_base += 0x100000000ULL;             \
-               psched_time_mark = cur;                                 \
-               (stamp) = (psched_time_base + cur)>>psched_clock_scale; \
-       } else {                                                        \
-               (stamp) = cur>>psched_clock_scale;                      \
-       }                                                               \
-} while (0)
-#define PSCHED_US2JIFFIE(delay) (((delay)+psched_clock_per_hz-1)/psched_clock_per_hz)
-#define PSCHED_JIFFIE2US(delay) ((delay)*psched_clock_per_hz)
-
-#endif /* CONFIG_NET_SCH_CLK_CPU */
-
-#endif /* !CONFIG_NET_SCH_CLK_GETTIMEOFDAY */
-
-#ifdef CONFIG_NET_SCH_CLK_GETTIMEOFDAY
-#define PSCHED_TDIFF(tv1, tv2) \
-({ \
-          int __delta_sec = (tv1).tv_sec - (tv2).tv_sec; \
-          int __delta = (tv1).tv_usec - (tv2).tv_usec; \
-          if (__delta_sec) { \
-                  switch (__delta_sec) { \
-                  default: \
-                          __delta = 0; \
-                  case 2: \
-                          __delta += USEC_PER_SEC; \
-                  case 1: \
-                          __delta += USEC_PER_SEC; \
-                  } \
-          } \
-          __delta; \
-})
-
-static inline int
-psched_tod_diff(int delta_sec, int bound)
+#define PSCHED_TICKS_PER_SEC           PSCHED_NS2US(NSEC_PER_SEC)
+#define PSCHED_PASTPERFECT             0
+
+static inline psched_time_t psched_get_time(void)

 {
 {

-       int delta;
-
-       if (bound <= USEC_PER_SEC || delta_sec > (0x7FFFFFFF/USEC_PER_SEC)-1)
-               return bound;
-       delta = delta_sec * USEC_PER_SEC;
-       if (delta > bound || delta < 0)
-               delta = bound;
-       return delta;
+       return PSCHED_NS2US(ktime_to_ns(ktime_get()));

 }
 
 }
 

-#define PSCHED_TDIFF_SAFE(tv1, tv2, bound) \
-({ \
-          int __delta_sec = (tv1).tv_sec - (tv2).tv_sec; \
-          int __delta = (tv1).tv_usec - (tv2).tv_usec; \
-          switch (__delta_sec) { \
-          default: \
-                  __delta = psched_tod_diff(__delta_sec, bound);  break; \
-          case 2: \
-                  __delta += USEC_PER_SEC; \
-          case 1: \
-                  __delta += USEC_PER_SEC; \
-          case 0: \
-                  if (__delta > bound || __delta < 0) \
-                       __delta = bound; \
-          } \
-          __delta; \
-})
-
-#define PSCHED_TLESS(tv1, tv2) (((tv1).tv_usec < (tv2).tv_usec && \
-                               (tv1).tv_sec <= (tv2).tv_sec) || \
-                                (tv1).tv_sec < (tv2).tv_sec)
-
-#define PSCHED_TADD2(tv, delta, tv_res) \
-({ \
-          int __delta = (tv).tv_usec + (delta); \
-          (tv_res).tv_sec = (tv).tv_sec; \
-          while (__delta >= USEC_PER_SEC) { (tv_res).tv_sec++; __delta -= USEC_PER_SEC; } \
-          (tv_res).tv_usec = __delta; \
-})
-
-#define PSCHED_TADD(tv, delta) \
-({ \
-          (tv).tv_usec += (delta); \
-          while ((tv).tv_usec >= USEC_PER_SEC) { (tv).tv_sec++; \
-                (tv).tv_usec -= USEC_PER_SEC; } \
-})
-
-/* Set/check that time is in the "past perfect";
-   it depends on concrete representation of system time
- */
-
-#define PSCHED_SET_PASTPERFECT(t)      ((t).tv_sec = 0)
-#define PSCHED_IS_PASTPERFECT(t)       ((t).tv_sec == 0)
-
-#define        PSCHED_AUDIT_TDIFF(t) ({ if ((t) > 2000000) (t) = 2000000; })
-
-#else /* !CONFIG_NET_SCH_CLK_GETTIMEOFDAY */
-
-#define PSCHED_TDIFF(tv1, tv2) (long)((tv1) - (tv2))
-#define PSCHED_TDIFF_SAFE(tv1, tv2, bound) \
-       min_t(long long, (tv1) - (tv2), bound)
-
+static inline psched_tdiff_t
+psched_tdiff_bounded(psched_time_t tv1, psched_time_t tv2, psched_time_t bound)
+{
+       return min(tv1 - tv2, bound);
+}

 
 

-#define PSCHED_TLESS(tv1, tv2) ((tv1) < (tv2))
-#define PSCHED_TADD2(tv, delta, tv_res) ((tv_res) = (tv) + (delta))
-#define PSCHED_TADD(tv, delta) ((tv) += (delta))
-#define PSCHED_SET_PASTPERFECT(t)      ((t) = 0)
-#define PSCHED_IS_PASTPERFECT(t)       ((t) == 0)
-#define        PSCHED_AUDIT_TDIFF(t)
+struct qdisc_watchdog {
+       struct hrtimer  timer;
+       struct Qdisc    *qdisc;
+};

 
 

-#endif /* !CONFIG_NET_SCH_CLK_GETTIMEOFDAY */
+extern void qdisc_watchdog_init(struct qdisc_watchdog *wd, struct Qdisc *qdisc);
+extern void qdisc_watchdog_schedule(struct qdisc_watchdog *wd,
+                                   psched_time_t expires);
+extern void qdisc_watchdog_cancel(struct qdisc_watchdog *wd);

 
 extern struct Qdisc_ops pfifo_qdisc_ops;
 extern struct Qdisc_ops bfifo_qdisc_ops;
 
 extern struct Qdisc_ops pfifo_qdisc_ops;
 extern struct Qdisc_ops bfifo_qdisc_ops;


@@ -227,16 +89,17 @@ static inline void qdisc_run(struct net_device *dev)
                __qdisc_run(dev);
 }
 
                __qdisc_run(dev);
 }
 

+extern int tc_classify_compat(struct sk_buff *skb, struct tcf_proto *tp,
+                             struct tcf_result *res);

 extern int tc_classify(struct sk_buff *skb, struct tcf_proto *tp,
 extern int tc_classify(struct sk_buff *skb, struct tcf_proto *tp,

-       struct tcf_result *res);
+                      struct tcf_result *res);

 
 /* Calculate maximal size of packet seen by hard_start_xmit
    routine of this device.
  */
 
 /* Calculate maximal size of packet seen by hard_start_xmit
    routine of this device.
  */

-static inline unsigned psched_mtu(struct net_device *dev)
+static inline unsigned psched_mtu(const struct net_device *dev)

 {
 {

-       unsigned mtu = dev->mtu;
-       return dev->hard_header ? mtu + dev->hard_header_len : mtu;
+       return dev->mtu + dev->hard_header_len;

 }
 
 #endif
 }
 
 #endif