4 files changed, 63 insertions, 2 deletions

diff --git a/include/asm-generic/resource.h b/include/asm-generic/resource.h
index a4a22cc35898..587566f95f6c 100644
--- a/include/asm-generic/resource.h
+++ b/include/asm-generic/resource.h
@@ -44,8 +44,8 @@
 #define RLIMIT_NICE             13      /* max nice prio allowed to raise to
                                            0-39 for nice level 19 .. -20 */
 #define RLIMIT_RTPRIO           14      /* maximum realtime priority */
-
-#define RLIM_NLIMITS            15
+#define RLIMIT_RTTIME           15      /* timeout for RT tasks in us */
+#define RLIM_NLIMITS            16
 
 /*
  * SuS says limits have to be unsigned.
@@ -86,6 +86,7 @@
         [RLIMIT_MSGQUEUE]       = {   MQ_BYTES_MAX,   MQ_BYTES_MAX },   \
         [RLIMIT_NICE]           = { 0, 0 },                             \
         [RLIMIT_RTPRIO]         = { 0, 0 },                             \
+        [RLIMIT_RTTIME]         = {  RLIM_INFINITY,  RLIM_INFINITY },   \
 }
 
 #endif  /* __KERNEL__ */
diff --git a/include/linux/sched.h b/include/linux/sched.h
index a06d09ebd5c6..fe3f8fbc614e 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -932,6 +932,7 @@ struct sched_entity {
 struct sched_rt_entity {
         struct list_head run_list;
         unsigned int time_slice;
+        unsigned long timeout;
 };
 
 struct task_struct {
diff --git a/kernel/posix-cpu-timers.c b/kernel/posix-cpu-timers.c
index 68c96376e84a..2c076b36c4f6 100644
--- a/kernel/posix-cpu-timers.c
+++ b/kernel/posix-cpu-timers.c
@@ -967,6 +967,7 @@ static void check_thread_timers(struct task_struct *tsk,
 {
         int maxfire;
         struct list_head *timers = tsk->cpu_timers;
+        struct signal_struct *const sig = tsk->signal;
 
         maxfire = 20;
         tsk->it_prof_expires = cputime_zero;
@@ -1011,6 +1012,34 @@ static void check_thread_timers(struct task_struct *tsk,
                 t->firing = 1;
                 list_move_tail(&t->entry, firing);
         }
+
+        /*
+         * Check for the special case thread timers.
+         */
+        if (sig->rlim[RLIMIT_RTTIME].rlim_cur != RLIM_INFINITY) {
+                unsigned long hard = sig->rlim[RLIMIT_RTTIME].rlim_max;
+                unsigned long *soft = &sig->rlim[RLIMIT_RTTIME].rlim_cur;
+
+                if (tsk->rt.timeout > DIV_ROUND_UP(hard, USEC_PER_SEC/HZ)) {
+                        /*
+                         * At the hard limit, we just die.
+                         * No need to calculate anything else now.
+                         */
+                        __group_send_sig_info(SIGKILL, SEND_SIG_PRIV, tsk);
+                        return;
+                }
+                if (tsk->rt.timeout > DIV_ROUND_UP(*soft, USEC_PER_SEC/HZ)) {
+                        /*
+                         * At the soft limit, send a SIGXCPU every second.
+                         */
+                        if (sig->rlim[RLIMIT_RTTIME].rlim_cur
+                            < sig->rlim[RLIMIT_RTTIME].rlim_max) {
+                                sig->rlim[RLIMIT_RTTIME].rlim_cur +=
+                                                                USEC_PER_SEC;
+                        }
+                        __group_send_sig_info(SIGXCPU, SEND_SIG_PRIV, tsk);
+                }
+        }
 }
 
 /*
diff --git a/kernel/sched_rt.c b/kernel/sched_rt.c
index 29963af782ae..f350f7b15158 100644
--- a/kernel/sched_rt.c
+++ b/kernel/sched_rt.c
@@ -116,6 +116,9 @@ static void enqueue_task_rt(struct rq *rq, struct task_struct *p, int wakeup)
         inc_cpu_load(rq, p->se.load.weight);
 
         inc_rt_tasks(p, rq);
+
+        if (wakeup)
+                p->rt.timeout = 0;
 }
 
 /*
@@ -834,11 +837,38 @@ static void prio_changed_rt(struct rq *rq, struct task_struct *p,
         }
 }
 
+static void watchdog(struct rq *rq, struct task_struct *p)
+{
+        unsigned long soft, hard;
+
+        if (!p->signal)
+                return;
+
+        soft = p->signal->rlim[RLIMIT_RTTIME].rlim_cur;
+        hard = p->signal->rlim[RLIMIT_RTTIME].rlim_max;
+
+        if (soft != RLIM_INFINITY) {
+                unsigned long next;
+
+                p->rt.timeout++;
+                next = DIV_ROUND_UP(min(soft, hard), USEC_PER_SEC/HZ);
+                if (next > p->rt.timeout) {
+                        u64 next_time = p->se.sum_exec_runtime;
+
+                        next_time += next * (NSEC_PER_SEC/HZ);
+                        if (p->it_sched_expires > next_time)
+                                p->it_sched_expires = next_time;
+                } else
+                        p->it_sched_expires = p->se.sum_exec_runtime;
+        }
+}
 
 static void task_tick_rt(struct rq *rq, struct task_struct *p)
 {
         update_curr_rt(rq);
 
+        watchdog(rq, p);
+
         /*
          * RR tasks need a special form of timeslice management.
          * FIFO tasks have no timeslices.