I forgot about an awful lot of unsigned longs that will overflow on 32 bit now
with u64 deadlines.

-ck

---
 kernel/sched_bfs.c |   17 +++++++++--------
 1 file changed, 9 insertions(+), 8 deletions(-)

Index: linux-2.6.35.5-ck1/kernel/sched_bfs.c
===================================================================
--- linux-2.6.35.5-ck1.orig/kernel/sched_bfs.c	2010-10-03 13:42:22.390151118 +1100
+++ linux-2.6.35.5-ck1/kernel/sched_bfs.c	2010-10-03 14:00:10.713750940 +1100
@@ -193,7 +193,7 @@ struct rq {
 	struct mm_struct *prev_mm;
 
 	/* Stored data about rq->curr to work outside grq lock */
-	unsigned long rq_deadline;
+	u64 rq_deadline;
 	unsigned int rq_policy;
 	int rq_time_slice;
 	u64 rq_last_ran;
@@ -1222,7 +1222,7 @@ EXPORT_SYMBOL_GPL(kick_process);
  * prio PRIO_LIMIT so it is always preempted.
  */
 static inline int
-can_preempt(struct task_struct *p, int prio, unsigned long deadline,
+can_preempt(struct task_struct *p, int prio, u64 deadline,
 	    unsigned int policy)
 {
 	/* Better static priority RT task or better policy preemption */
@@ -1272,7 +1272,8 @@ static inline int needs_other_cpu(struct
 static void try_preempt(struct task_struct *p, struct rq *this_rq)
 {
 	struct rq *highest_prio_rq = this_rq;
-	unsigned long latest_deadline, cpu;
+	u64 latest_deadline;
+	unsigned long cpu;
 	int highest_prio;
 	cpumask_t tmp;
 
@@ -1294,7 +1295,7 @@ static void try_preempt(struct task_stru
 	highest_prio = -1;
 
 	for_each_cpu_mask(cpu, tmp) {
-		unsigned long offset_deadline;
+		u64 offset_deadline;
 		struct rq *rq;
 		int rq_prio;
 
@@ -2458,17 +2459,17 @@ EXPORT_SYMBOL(sub_preempt_count);
  * proportion works out to the square of the virtual deadline difference, so
  * this equation will give nice 19 3% CPU compared to nice 0.
  */
-static inline int prio_deadline_diff(int user_prio)
+static inline u64 prio_deadline_diff(int user_prio)
 {
 	return (prio_ratios[user_prio] * rr_interval * (MS_TO_NS(1) / 128));
 }
 
-static inline int task_deadline_diff(struct task_struct *p)
+static inline u64 task_deadline_diff(struct task_struct *p)
 {
 	return prio_deadline_diff(TASK_USER_PRIO(p));
 }
 
-static inline int static_deadline_diff(int static_prio)
+static inline u64 static_deadline_diff(int static_prio)
 {
 	return prio_deadline_diff(USER_PRIO(static_prio));
 }
@@ -2524,7 +2525,7 @@ static inline void check_deadline(struct
 static inline struct
 task_struct *earliest_deadline_task(struct rq *rq, struct task_struct *idle)
 {
-	unsigned long dl, earliest_deadline = 0; /* Initialise to silence compiler */
+	u64 dl, earliest_deadline = 0; /* Initialise to silence compiler */
 	struct task_struct *p, *edt = idle;
 	unsigned int cpu = cpu_of(rq);
 	struct list_head *queue;