Merge branch 'timers-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull core timer updates from Thomas Gleixner:
 "Timers and timekeeping updates:

   - A large overhaul of the posix CPU timer code which is a preparation
     for moving the CPU timer expiry out into task work so it can be
     properly accounted on the task/process.

     An update to the bogus permission checks will come later during the
     merge window as feedback was not complete before heading of for
     travel.

   - Switch the timerqueue code to use cached rbtrees and get rid of the
     homebrewn caching of the leftmost node.

   - Consolidate hrtimer_init() + hrtimer_init_sleeper() calls into a
     single function

   - Implement the separation of hrtimers to be forced to expire in hard
     interrupt context even when PREEMPT_RT is enabled and mark the
     affected timers accordingly.

   - Implement a mechanism for hrtimers and the timer wheel to protect
     RT against priority inversion and live lock issues when a (hr)timer
     which should be canceled is currently executing the callback.
     Instead of infinitely spinning, the task which tries to cancel the
     timer blocks on a per cpu base expiry lock which is held and
     released by the (hr)timer expiry code.

   - Enable the Hyper-V TSC page based sched_clock for Hyper-V guests
     resulting in faster access to timekeeping functions.

   - Updates to various clocksource/clockevent drivers and their device
     tree bindings.

   - The usual small improvements all over the place"

* 'timers-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (101 commits)
  posix-cpu-timers: Fix permission check regression
  posix-cpu-timers: Always clear head pointer on dequeue
  hrtimer: Add a missing bracket and hide `migration_base' on !SMP
  posix-cpu-timers: Make expiry_active check actually work correctly
  posix-timers: Unbreak CONFIG_POSIX_TIMERS=n build
  tick: Mark sched_timer to expire in hard interrupt context
  hrtimer: Add kernel doc annotation for HRTIMER_MODE_HARD
  x86/hyperv: Hide pv_ops access for CONFIG_PARAVIRT=n
  posix-cpu-timers: Utilize timerqueue for storage
  posix-cpu-timers: Move state tracking to struct posix_cputimers
  posix-cpu-timers: Deduplicate rlimit handling
  posix-cpu-timers: Remove pointless comparisons
  posix-cpu-timers: Get rid of 64bit divisions
  posix-cpu-timers: Consolidate timer expiry further
  posix-cpu-timers: Get rid of zero checks
  rlimit: Rewrite non-sensical RLIMIT_CPU comment
  posix-cpu-timers: Respect INFINITY for hard RTTIME limit
  posix-cpu-timers: Switch thread group sampling to array
  posix-cpu-timers: Restructure expiry array
  posix-cpu-timers: Remove cputime_expires
  ...

1 files changed, 117 insertions, 14 deletions

diff --git a/include/linux/posix-timers.h b/include/linux/posix-timers.h
index b20798fc5191..3d10c84a97a9 100644
--- a/include/linux/posix-timers.h
+++ b/include/linux/posix-timers.h
@@ -4,18 +4,11 @@
 
 #include <linux/spinlock.h>
 #include <linux/list.h>
-#include <linux/sched.h>
-#include <linux/timex.h>
 #include <linux/alarmtimer.h>
+#include <linux/timerqueue.h>
 
-struct siginfo;
-
-struct cpu_timer_list {
-        struct list_head entry;
-        u64 expires;
-        struct task_struct *task;
-        int firing;
-};
+struct kernel_siginfo;
+struct task_struct;
 
 /*
  * Bit fields within a clockid:
@@ -63,6 +56,115 @@ static inline int clockid_to_fd(const clockid_t clk)
         return ~(clk >> 3);
 }
 
+#ifdef CONFIG_POSIX_TIMERS
+
+/**
+ * cpu_timer - Posix CPU timer representation for k_itimer
+ * @node:       timerqueue node to queue in the task/sig
+ * @head:       timerqueue head on which this timer is queued
+ * @task:       Pointer to target task
+ * @elist:      List head for the expiry list
+ * @firing:     Timer is currently firing
+ */
+struct cpu_timer {
+        struct timerqueue_node  node;
+        struct timerqueue_head  *head;
+        struct task_struct      *task;
+        struct list_head        elist;
+        int                     firing;
+};
+
+static inline bool cpu_timer_enqueue(struct timerqueue_head *head,
+                                     struct cpu_timer *ctmr)
+{
+        ctmr->head = head;
+        return timerqueue_add(head, &ctmr->node);
+}
+
+static inline void cpu_timer_dequeue(struct cpu_timer *ctmr)
+{
+        if (ctmr->head) {
+                timerqueue_del(ctmr->head, &ctmr->node);
+                ctmr->head = NULL;
+        }
+}
+
+static inline u64 cpu_timer_getexpires(struct cpu_timer *ctmr)
+{
+        return ctmr->node.expires;
+}
+
+static inline void cpu_timer_setexpires(struct cpu_timer *ctmr, u64 exp)
+{
+        ctmr->node.expires = exp;
+}
+
+/**
+ * posix_cputimer_base - Container per posix CPU clock
+ * @nextevt:            Earliest-expiration cache
+ * @tqhead:             timerqueue head for cpu_timers
+ */
+struct posix_cputimer_base {
+        u64                     nextevt;
+        struct timerqueue_head  tqhead;
+};
+
+/**
+ * posix_cputimers - Container for posix CPU timer related data
+ * @bases:              Base container for posix CPU clocks
+ * @timers_active:      Timers are queued.
+ * @expiry_active:      Timer expiry is active. Used for
+ *                      process wide timers to avoid multiple
+ *                      task trying to handle expiry concurrently
+ *
+ * Used in task_struct and signal_struct
+ */
+struct posix_cputimers {
+        struct posix_cputimer_base      bases[CPUCLOCK_MAX];
+        unsigned int                    timers_active;
+        unsigned int                    expiry_active;
+};
+
+static inline void posix_cputimers_init(struct posix_cputimers *pct)
+{
+        memset(pct, 0, sizeof(*pct));
+        pct->bases[0].nextevt = U64_MAX;
+        pct->bases[1].nextevt = U64_MAX;
+        pct->bases[2].nextevt = U64_MAX;
+}
+
+void posix_cputimers_group_init(struct posix_cputimers *pct, u64 cpu_limit);
+
+static inline void posix_cputimers_rt_watchdog(struct posix_cputimers *pct,
+                                               u64 runtime)
+{
+        pct->bases[CPUCLOCK_SCHED].nextevt = runtime;
+}
+
+/* Init task static initializer */
+#define INIT_CPU_TIMERBASE(b) {                                         \
+        .nextevt        = U64_MAX,                                      \
+}
+
+#define INIT_CPU_TIMERBASES(b) {                                        \
+        INIT_CPU_TIMERBASE(b[0]),                                       \
+        INIT_CPU_TIMERBASE(b[1]),                                       \
+        INIT_CPU_TIMERBASE(b[2]),                                       \
+}
+
+#define INIT_CPU_TIMERS(s)                                              \
+        .posix_cputimers = {                                            \
+                .bases = INIT_CPU_TIMERBASES(s.posix_cputimers.bases),  \
+        },
+#else
+struct posix_cputimers { };
+struct cpu_timer { };
+#define INIT_CPU_TIMERS(s)
+static inline void posix_cputimers_init(struct posix_cputimers *pct) { }
+static inline void posix_cputimers_group_init(struct posix_cputimers *pct,
+                                              u64 cpu_limit) { }
+#endif
+
 #define REQUEUE_PENDING 1
 
 /**
@@ -85,7 +187,8 @@ static inline int clockid_to_fd(const clockid_t clk)
  * @it_process:         The task to wakeup on clock_nanosleep (CPU timers)
  * @sigq:               Pointer to preallocated sigqueue
  * @it:                 Union representing the various posix timer type
- *                      internals. Also used for rcu freeing the timer.
+ *                      internals.
+ * @rcu:                RCU head for freeing the timer.
  */
 struct k_itimer {
         struct list_head        list;
@@ -110,15 +213,15 @@ struct k_itimer {
                 struct {
                         struct hrtimer  timer;
                 } real;
-                struct cpu_timer_list   cpu;
+                struct cpu_timer        cpu;
                 struct {
                         struct alarm    alarmtimer;
                 } alarm;
-                struct rcu_head         rcu;
         } it;
+        struct rcu_head         rcu;
 };
 
-void run_posix_cpu_timers(struct task_struct *task);
+void run_posix_cpu_timers(void);
 void posix_cpu_timers_exit(struct task_struct *task);
 void posix_cpu_timers_exit_group(struct task_struct *task);
 void set_process_cpu_timer(struct task_struct *task, unsigned int clock_idx,