From: Sebastian Andrzej Siewior <bigeasy@linutronix.de>

Date: Tue, 5 Sep 2017 16:22:16 +0200

Subject: Add Anna-Maria's "Provide softirq context hrtimers" + RT fixups

Git-repo: git://git.kernel.org/pub/scm/linux/kernel/git/rt/linux-rt-devel.git

Git-commit: 3e71e14ef8bfec5651a13d6eeaec76b57e9eaf9a

Patch-mainline: Queued in subsystem maintainer repository

References: SLE12 Realtime Extension

The "Provide softirq context hrtimers" includes the following patches:

  0001-hrtimer-Use-predefined-function-for-updating-next_ti.patch

  0002-hrtimer-Correct-blantanly-wrong-comment.patch

  0003-hrtimer-Fix-kerneldoc-for-struct-hrtimer_cpu_base.patch

  0004-hrtimer-Cleanup-clock-argument-in-schedule_hrtimeout.patch

  0005-hrtimer-Switch-for-loop-to-_ffs-evaluation.patch

  0006-hrtimer-Store-running-timer-in-hrtimer_clock_base.patch

  0007-hrtimer-Reduce-conditional-code-hres_active.patch

  0008-hrtimer-Reduce-conditional-code-expires_next-next_ti.patch

  0009-hrtimer-Reduce-conditional-code-hrtimer_reprogram.patch

  0010-hrtimer-Make-handling-of-hrtimer-reprogramming-and-e.patch

  0011-hrtimer-Allow-remote-hrtimer-enqueue-with-expires_ne.patch

  0012-hrtimer-Simplify-hrtimer_reprogram-call.patch

  0013-hrtimer-Split-out-code-from-hrtimer_start_range_ns-f.patch

  0014-hrtimer-Split-out-code-from-__hrtimer_get_next_event.patch

  0015-hrtimer-Add-clock-bases-for-soft-irq-context.patch

  0016-hrtimer-Allow-function-reuse-for-softirq-based-hrtim.patch

  0017-hrtimer-Implementation-of-softirq-hrtimer-handling.patch

  0018-hrtimer-Enable-soft-and-hard-hrtimer.patch

  0019-can-bcm-Replace-hrtimer_tasklet-with-softirq-based-h.patch

  0020-mac80211_hwsim-Replace-hrtimer-tasklet-with-softirq-.patch

  0021-xfrm-Replace-hrtimer-tasklet-with-softirq-hrtimer.patch

  0022-softirq-Remove-tasklet_hrtimer.patch

The interation of those resulted in the removal of the old "irqsafe"

member and the custom softirq infrastrucure which resulted in the

removal of the following patches:

  KVM-lapic-mark-LAPIC-timer-handler-as-irqsafe.patch

  kernel-perf-mark-perf_cpu_context-s-timer-as-irqsafe.patch

  perf-make-swevent-hrtimer-irqsafe.patch

  sched-deadline-dl_task_timer-has-to-be-irqsafe.patch

  tick-broadcast--Make-hrtimer-irqsafe.patch

  hrtimer-enfore-64byte-alignment.patch

  hrtimer-fixup-hrtimer-callback-changes-for-preempt-r.patch

  kernel-hrtimer-don-t-wakeup-a-process-while-holding-.patch

  kernel-hrtimer-hotplug-don-t-wake-ktimersoftd-while-.patch

  kernel-hrtimer-migrate-deferred-timer-on-CPU-down.patch

  timer-hrtimer-check-properly-for-a-running-timer.patch

The "old" functionality where all timers were most hrtimers are moved

into softirq context is preserved by

  hrtimer-consolidate-hrtimer_init-hrtimer_init_sleepe.patch

  hrtimer-by-timers-by-default-into-the-softirq-context.patch

and updating

  hrtimers-prepare-full-preemption.patch

Signed-off-by: Sebastian Andrzej Siewior <bigeasy@linutronix.de>

Signed-off-by: Mike Galbraith <mgalbraith@suse.de>

---

 arch/x86/kvm/lapic.c                  |    3 

 block/blk-mq.c                        |    3 

 drivers/net/wireless/mac80211_hwsim.c |   44 --

 include/linux/hrtimer.h               |  116 +++--

 include/linux/interrupt.h             |   25 -

 include/linux/wait.h                  |    4 

 include/net/xfrm.h                    |    2 

 kernel/events/core.c                  |    6 

 kernel/futex.c                        |   19 

 kernel/sched/core.c                   |    3 

 kernel/sched/deadline.c               |    3 

 kernel/sched/rt.c                     |    5 

 kernel/softirq.c                      |   51 --

 kernel/time/hrtimer.c                 |  740 ++++++++++++++++++----------------

 kernel/time/tick-broadcast-hrtimer.c  |    3 

 kernel/time/tick-sched.c              |    3 

 kernel/watchdog.c                     |    3 

 net/can/bcm.c                         |  150 ++----

 net/core/pktgen.c                     |    4 

 net/xfrm/xfrm_state.c                 |   29 -

 20 files changed, 573 insertions(+), 643 deletions(-)

--- a/arch/x86/kvm/lapic.c

+++ b/arch/x86/kvm/lapic.c

@@ -2184,10 +2184,9 @@ int kvm_create_lapic(struct kvm_vcpu *vc

 	}

 	apic->vcpu = vcpu;

-	hrtimer_init(&apic->lapic_timer.timer, CLOCK_MONOTONIC,

+	hrtimer_init(&apic->lapic_timer.timer, CLOCK_MONOTONIC_HARD,

 		     HRTIMER_MODE_ABS_PINNED);

 	apic->lapic_timer.timer.function = apic_timer_fn;

-	apic->lapic_timer.timer.irqsafe = 1;

 	/*

 	 * APIC is created enabled. This will prevent kvm_lapic_set_base from

--- a/block/blk-mq.c

+++ b/block/blk-mq.c

@@ -3230,10 +3230,9 @@ static bool blk_mq_poll_hybrid_sleep(str

 	kt = nsecs;

 	mode = HRTIMER_MODE_REL;

-	hrtimer_init_on_stack(&hs.timer, CLOCK_MONOTONIC, mode);

+	hrtimer_init_sleeper_on_stack(&hs, CLOCK_MONOTONIC, mode, current);

 	hrtimer_set_expires(&hs.timer, kt);

-	hrtimer_init_sleeper(&hs, current);

 	do {

 		if (blk_mq_rq_state(rq) == MQ_RQ_COMPLETE)

 			break;

--- a/drivers/net/wireless/mac80211_hwsim.c

+++ b/drivers/net/wireless/mac80211_hwsim.c

@@ -545,7 +545,7 @@ struct mac80211_hwsim_data {

 	unsigned int rx_filter;

 	bool started, idle, scanning;

 	struct mutex mutex;

-	struct tasklet_hrtimer beacon_timer;

+	struct hrtimer beacon_timer;

 	enum ps_mode {

 		PS_DISABLED, PS_ENABLED, PS_AUTO_POLL, PS_MANUAL_POLL

 	} ps;

@@ -1479,7 +1479,7 @@ static void mac80211_hwsim_stop(struct i

 {

 	struct mac80211_hwsim_data *data = hw->priv;

 	data->started = false;

-	tasklet_hrtimer_cancel(&data->beacon_timer);

+	hrtimer_cancel(&data->beacon_timer);

 	wiphy_dbg(hw->wiphy, "%s\n", __func__);

 }

@@ -1602,14 +1602,12 @@ static enum hrtimer_restart

 mac80211_hwsim_beacon(struct hrtimer *timer)

 {

 	struct mac80211_hwsim_data *data =

-		container_of(timer, struct mac80211_hwsim_data,

-			     beacon_timer.timer);

+		container_of(timer, struct mac80211_hwsim_data, beacon_timer);

 	struct ieee80211_hw *hw = data->hw;

 	u64 bcn_int = data->beacon_int;

-	ktime_t next_bcn;

 	if (!data->started)

-		goto out;

+		return HRTIMER_NORESTART;

 	ieee80211_iterate_active_interfaces_atomic(

 		hw, IEEE80211_IFACE_ITER_NORMAL,

@@ -1621,11 +1619,9 @@ mac80211_hwsim_beacon(struct hrtimer *ti

 		data->bcn_delta = 0;

 	}

-	next_bcn = ktime_add(hrtimer_get_expires(timer),

-			     ns_to_ktime(bcn_int * 1000));

-	tasklet_hrtimer_start(&data->beacon_timer, next_bcn, HRTIMER_MODE_ABS);

-out:

-	return HRTIMER_NORESTART;

+	hrtimer_forward(&data->beacon_timer, hrtimer_get_expires(timer),

+			ns_to_ktime(bcn_int * NSEC_PER_USEC));

+	return HRTIMER_RESTART;

 }

 static const char * const hwsim_chanwidths[] = {

@@ -1699,15 +1695,15 @@ static int mac80211_hwsim_config(struct

 	mutex_unlock(&data->mutex);

 	if (!data->started || !data->beacon_int)

-		tasklet_hrtimer_cancel(&data->beacon_timer);

-	else if (!hrtimer_is_queued(&data->beacon_timer.timer)) {

+		hrtimer_cancel(&data->beacon_timer);

+	else if (!hrtimer_is_queued(&data->beacon_timer)) {

 		u64 tsf = mac80211_hwsim_get_tsf(hw, NULL);

 		u32 bcn_int = data->beacon_int;

 		u64 until_tbtt = bcn_int - do_div(tsf, bcn_int);

-		tasklet_hrtimer_start(&data->beacon_timer,

-				      ns_to_ktime(until_tbtt * 1000),

-				      HRTIMER_MODE_REL);

+		hrtimer_start(&data->beacon_timer,

+			      ns_to_ktime(until_tbtt * 1000),

+			      HRTIMER_MODE_REL);

 	}

 	return 0;

@@ -1770,7 +1766,7 @@ static void mac80211_hwsim_bss_info_chan

 			  info->enable_beacon, info->beacon_int);

 		vp->bcn_en = info->enable_beacon;

 		if (data->started &&

-		    !hrtimer_is_queued(&data->beacon_timer.timer) &&

+		    !hrtimer_is_queued(&data->beacon_timer) &&

 		    info->enable_beacon) {

 			u64 tsf, until_tbtt;

 			u32 bcn_int;

@@ -1778,9 +1774,9 @@ static void mac80211_hwsim_bss_info_chan

 			tsf = mac80211_hwsim_get_tsf(hw, vif);

 			bcn_int = data->beacon_int;

 			until_tbtt = bcn_int - do_div(tsf, bcn_int);

-			tasklet_hrtimer_start(&data->beacon_timer,

-					      ns_to_ktime(until_tbtt * 1000),

-					      HRTIMER_MODE_REL);

+			hrtimer_start(&data->beacon_timer,

+				      ns_to_ktime(until_tbtt * 1000),

+				      HRTIMER_MODE_REL);

 		} else if (!info->enable_beacon) {

 			unsigned int count = 0;

 			ieee80211_iterate_active_interfaces_atomic(

@@ -1789,7 +1785,7 @@ static void mac80211_hwsim_bss_info_chan

 			wiphy_dbg(hw->wiphy, "  beaconing vifs remaining: %u",

 				  count);

 			if (count == 0) {

-				tasklet_hrtimer_cancel(&data->beacon_timer);

+				hrtimer_cancel(&data->beacon_timer);

 				data->beacon_int = 0;

 			}

 		}

@@ -2878,9 +2874,9 @@ static int mac80211_hwsim_new_radio(stru

 	wiphy_ext_feature_set(hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);

-	tasklet_hrtimer_init(&data->beacon_timer,

-			     mac80211_hwsim_beacon,

-			     CLOCK_MONOTONIC, HRTIMER_MODE_ABS);

+	hrtimer_init(&data->beacon_timer, CLOCK_MONOTONIC_SOFT,

+		     HRTIMER_MODE_ABS);

+	data->beacon_timer.function = mac80211_hwsim_beacon;

 	err = ieee80211_register_hw(hw);

 	if (err < 0) {

--- a/include/linux/hrtimer.h

+++ b/include/linux/hrtimer.h

@@ -24,6 +24,23 @@

 #include <linux/timerqueue.h>

 #include <linux/wait.h>

+/*

+ * Clock ids for hrtimers which expire in softirq context. These clock ids

+ * are kernel internal and never exported to user space.

+ */

+#define HRTIMER_BASE_SOFT_MASK	MAX_CLOCKS

+#define HRTIMER_BASE_HARD_MASK	(MAX_CLOCKS << 1)

+

+#define CLOCK_REALTIME_SOFT	(CLOCK_REALTIME	 | HRTIMER_BASE_SOFT_MASK)

+#define CLOCK_MONOTONIC_SOFT	(CLOCK_MONOTONIC | HRTIMER_BASE_SOFT_MASK)

+#define CLOCK_BOOTTIME_SOFT	(CLOCK_BOOTTIME	 | HRTIMER_BASE_SOFT_MASK)

+#define CLOCK_TAI_SOFT		(CLOCK_TAI	 | HRTIMER_BASE_SOFT_MASK)

+

+#define CLOCK_REALTIME_HARD	(CLOCK_REALTIME	 | HRTIMER_BASE_HARD_MASK)

+#define CLOCK_MONOTONIC_HARD	(CLOCK_MONOTONIC | HRTIMER_BASE_HARD_MASK)

+#define CLOCK_BOOTTIME_HARD	(CLOCK_BOOTTIME	 | HRTIMER_BASE_HARD_MASK)

+#define CLOCK_TAI_HARD		(CLOCK_TAI	 | HRTIMER_BASE_HARD_MASK)

+

 struct hrtimer_clock_base;

 struct hrtimer_cpu_base;

@@ -86,8 +103,6 @@ enum hrtimer_restart {

  *		was armed.

  * @function:	timer expiry callback function

  * @base:	pointer to the timer base (per cpu and per clock)

- * @cb_entry:	list entry to defer timers from hardirq context

- * @irqsafe:	timer can run in hardirq context

  * @state:	state information (See bit values above)

  * @is_rel:	Set if the timer was armed relative

  *

@@ -98,8 +113,6 @@ struct hrtimer {

 	ktime_t				_softexpires;

 	enum hrtimer_restart		(*function)(struct hrtimer *);

 	struct hrtimer_clock_base	*base;

-	struct list_head		cb_entry;

-	int				irqsafe;

 	u8				state;

 	u8				is_rel;

 };

@@ -116,7 +129,11 @@ struct hrtimer_sleeper {

 	struct task_struct *task;

 };

-# define HRTIMER_CLOCK_BASE_ALIGN	64

+#ifdef CONFIG_64BIT

+# define __hrtimer_clock_base_align	____cacheline_aligned

+#else

+# define __hrtimer_clock_base_align

+#endif

 /**

  * struct hrtimer_clock_base - the timer base for a specific clock

@@ -124,43 +141,46 @@ struct hrtimer_sleeper {

  * @index:		clock type index for per_cpu support when moving a

  *			timer to a base on another cpu.

  * @clockid:		clock id for per_cpu support

+ * @seq:		seqcount around __run_hrtimer

+ * @running:		pointer to the currently running hrtimer

  * @active:		red black tree root node for the active timers

- * @expired:		list head for deferred timers.

  * @get_time:		function to retrieve the current time of the clock

  * @offset:		offset of this clock to the monotonic base

  */

 struct hrtimer_clock_base {

 	struct hrtimer_cpu_base	*cpu_base;

-	int			index;

+	unsigned int		index;

 	clockid_t		clockid;

+	seqcount_t		seq;

+	struct hrtimer		*running;

 	struct timerqueue_head	active;

-	struct list_head	expired;

 	ktime_t			(*get_time)(void);

 	ktime_t			offset;

-} __attribute__((__aligned__(HRTIMER_CLOCK_BASE_ALIGN)));

+} __hrtimer_clock_base_align;

 enum  hrtimer_base_type {

 	HRTIMER_BASE_MONOTONIC,

 	HRTIMER_BASE_REALTIME,

 	HRTIMER_BASE_BOOTTIME,

 	HRTIMER_BASE_TAI,

+	HRTIMER_BASE_MONOTONIC_SOFT,

+	HRTIMER_BASE_REALTIME_SOFT,

+	HRTIMER_BASE_BOOTTIME_SOFT,

+	HRTIMER_BASE_TAI_SOFT,

 	HRTIMER_MAX_CLOCK_BASES,

 };

-/*

+/**

  * struct hrtimer_cpu_base - the per cpu clock bases

  * @lock:		lock protecting the base and associated clock bases

  *			and timers

- * @seq:		seqcount around __run_hrtimer

- * @running:		pointer to the currently running hrtimer

  * @cpu:		cpu number

  * @active_bases:	Bitfield to mark bases with active timers

  * @clock_was_set_seq:	Sequence counter of clock was set events

  * @migration_enabled:	The migration of hrtimers to other cpus is enabled

  * @nohz_active:	The nohz functionality is enabled

- * @expires_next:	absolute time of the next event which was scheduled

- *			via clock_set_next_event()

- * @next_timer:		Pointer to the first expiring timer

+ * @softirq_activated:	displays, if the softirq is raised - update of softirq

+ *			related settings is not required then.

  * @in_hrtirq:		hrtimer_interrupt() is currently executing

  * @hres_active:	State of high resolution mode

  * @hang_detected:	The last hrtimer interrupt detected a hang

@@ -168,6 +188,11 @@ enum  hrtimer_base_type {

  * @nr_retries:		Total number of hrtimer interrupt retries

  * @nr_hangs:		Total number of hrtimer interrupt hangs

  * @max_hang_time:	Maximum time spent in hrtimer_interrupt

+ * @expires_next:	absolute time of the next event, is required for remote

+ *			hrtimer enqueue; it is the total first expiry time (hard

+ *			and soft hrtimer are taken into account)

+ * @next_timer:		Pointer to the first expiring timer

+ * @softirq_expires_next: Time to check, if soft queues needs also to be expired

  * @clock_base:		array of clock bases for this cpu

  *

  * Note: next_timer is just an optimization for __remove_hrtimer().

@@ -176,25 +201,24 @@ enum  hrtimer_base_type {

  */

 struct hrtimer_cpu_base {

 	raw_spinlock_t			lock;

-	seqcount_t			seq;

-	struct hrtimer			*running;

-	struct hrtimer			*running_soft;

 	unsigned int			cpu;

 	unsigned int			active_bases;

 	unsigned int			clock_was_set_seq;

 	bool				migration_enabled;

 	bool				nohz_active;

-#ifdef CONFIG_HIGH_RES_TIMERS

-	unsigned int			in_hrtirq	: 1,

-					hres_active	: 1,

+	bool				softirq_activated;

+	unsigned int			hres_active	: 1,

+					in_hrtirq	: 1,

 					hang_detected	: 1;

-	ktime_t				expires_next;

-	struct hrtimer			*next_timer;

+#ifdef CONFIG_HIGH_RES_TIMERS

 	unsigned int			nr_events;

 	unsigned int			nr_retries;

 	unsigned int			nr_hangs;

 	unsigned int			max_hang_time;

 #endif

+	ktime_t				expires_next;

+	struct hrtimer			*next_timer;

+	ktime_t				softirq_expires_next;

 #ifdef CONFIG_PREEMPT_RT_BASE

 	wait_queue_head_t		wait;

 #endif

@@ -203,8 +227,6 @@ struct hrtimer_cpu_base {

 static inline void hrtimer_set_expires(struct hrtimer *timer, ktime_t time)

 {

-	BUILD_BUG_ON(sizeof(struct hrtimer_clock_base) > HRTIMER_CLOCK_BASE_ALIGN);

-

 	timer->node.expires = time;

 	timer->_softexpires = time;

 }

@@ -273,16 +295,16 @@ static inline ktime_t hrtimer_cb_get_tim

 	return timer->base->get_time();

 }

-#ifdef CONFIG_HIGH_RES_TIMERS

-struct clock_event_device;

-

-extern void hrtimer_interrupt(struct clock_event_device *dev);

-

 static inline int hrtimer_is_hres_active(struct hrtimer *timer)

 {

 	return timer->base->cpu_base->hres_active;

 }

+#ifdef CONFIG_HIGH_RES_TIMERS

+struct clock_event_device;

+

+extern void hrtimer_interrupt(struct clock_event_device *dev);

+

 /*

  * The resolution of the clocks. The resolution value is returned in

  * the clock_getres() system call to give application programmers an

@@ -305,11 +327,6 @@ extern unsigned int hrtimer_resolution;

 #define hrtimer_resolution	(unsigned int)LOW_RES_NSEC

-static inline int hrtimer_is_hres_active(struct hrtimer *timer)

-{

-	return 0;

-}

-

 static inline void clock_was_set_delayed(void) { }

 #endif

@@ -351,10 +368,17 @@ DECLARE_PER_CPU(struct tick_device, tick

 /* Initialize timers: */

 extern void hrtimer_init(struct hrtimer *timer, clockid_t which_clock,

 			 enum hrtimer_mode mode);

+extern void hrtimer_init_sleeper(struct hrtimer_sleeper *sl, clockid_t clock_id,

+				 enum hrtimer_mode mode,

+				 struct task_struct *task);

 #ifdef CONFIG_DEBUG_OBJECTS_TIMERS

 extern void hrtimer_init_on_stack(struct hrtimer *timer, clockid_t which_clock,

 				  enum hrtimer_mode mode);

+extern void hrtimer_init_sleeper_on_stack(struct hrtimer_sleeper *sl,

+					  clockid_t clock_id,

+					  enum hrtimer_mode mode,

+					  struct task_struct *task);

 extern void destroy_hrtimer_on_stack(struct hrtimer *timer);

 #else

@@ -364,6 +388,15 @@ static inline void hrtimer_init_on_stack

 {

 	hrtimer_init(timer, which_clock, mode);

 }

+

+static inline void hrtimer_init_sleeper_on_stack(struct hrtimer_sleeper *sl,

+					    clockid_t clock_id,

+					    enum hrtimer_mode mode,

+					    struct task_struct *task)

+{

+	hrtimer_init_sleeper(sl, clock_id, mode, task);

+}

+

 static inline void destroy_hrtimer_on_stack(struct hrtimer *timer) { }

 #endif

@@ -442,13 +475,7 @@ static inline bool hrtimer_is_queued(str

  */

 static inline int hrtimer_callback_running(const struct hrtimer *timer)

 {

-	if (timer->base->cpu_base->running == timer)

-		return 1;

-#ifdef CONFIG_PREEMPT_RT_BASE

-	if (timer->base->cpu_base->running_soft == timer)

-		return 1;

-#endif

-	return 0;

+	return timer->base->running == timer;

 }

 /* Forward a hrtimer so it expires after now: */

@@ -484,15 +511,12 @@ extern long hrtimer_nanosleep(struct tim

 			      const clockid_t clockid);

 extern long hrtimer_nanosleep_restart(struct restart_block *restart_block);

-extern void hrtimer_init_sleeper(struct hrtimer_sleeper *sl,

-				 struct task_struct *tsk);

-

 extern int schedule_hrtimeout_range(ktime_t *expires, u64 delta,

 						const enum hrtimer_mode mode);

 extern int schedule_hrtimeout_range_clock(ktime_t *expires,

 					  u64 delta,

 					  const enum hrtimer_mode mode,

-					  int clock);

+					  clockid_t clock_id);

 extern int schedule_hrtimeout(ktime_t *expires, const enum hrtimer_mode mode);

 /* Soft interrupt function to run the hrtimer queues: */

--- a/include/linux/interrupt.h

+++ b/include/linux/interrupt.h

@@ -653,31 +653,6 @@ extern void tasklet_kill_immediate(struc

 extern void tasklet_init(struct tasklet_struct *t,

 			 void (*func)(unsigned long), unsigned long data);

-struct tasklet_hrtimer {

-	struct hrtimer		timer;

-	struct tasklet_struct	tasklet;

-	enum hrtimer_restart	(*function)(struct hrtimer *);

-};

-

-extern void

-tasklet_hrtimer_init(struct tasklet_hrtimer *ttimer,

-		     enum hrtimer_restart (*function)(struct hrtimer *),

-		     clockid_t which_clock, enum hrtimer_mode mode);

-

-static inline

-void tasklet_hrtimer_start(struct tasklet_hrtimer *ttimer, ktime_t time,

-			   const enum hrtimer_mode mode)

-{

-	hrtimer_start(&ttimer->timer, time, mode);

-}

-

-static inline

-void tasklet_hrtimer_cancel(struct tasklet_hrtimer *ttimer)

-{

-	hrtimer_cancel(&ttimer->timer);

-	tasklet_kill(&ttimer->tasklet);

-}

-

 #ifdef CONFIG_PREEMPT_RT_FULL

 extern void softirq_early_init(void);

 #else

--- a/include/linux/wait.h

+++ b/include/linux/wait.h

@@ -486,8 +486,8 @@ do {										\

 	int __ret = 0;								\

 	struct hrtimer_sleeper __t;						\

 										\

-	hrtimer_init_on_stack(&__t.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);	\

-	hrtimer_init_sleeper(&__t, current);					\

+	hrtimer_init_sleeper_on_stack(&__t, CLOCK_MONOTONIC,			\

+				      HRTIMER_MODE_REL, current);		\

 	if ((timeout) != KTIME_MAX)						\

 		hrtimer_start_range_ns(&__t.timer, timeout,			\

 				       current->timer_slack_ns,			\

--- a/include/net/xfrm.h

+++ b/include/net/xfrm.h

@@ -214,7 +214,7 @@ struct xfrm_state {

 	struct xfrm_stats	stats;

 	struct xfrm_lifetime_cur curlft;

-	struct tasklet_hrtimer	mtimer;

+	struct hrtimer		mtimer;

 	struct xfrm_state_offload xso;

--- a/kernel/events/core.c

+++ b/kernel/events/core.c

@@ -1084,9 +1084,8 @@ static void __perf_mux_hrtimer_init(stru

 	cpuctx->hrtimer_interval = ns_to_ktime(NSEC_PER_MSEC * interval);

 	raw_spin_lock_init(&cpuctx->hrtimer_lock);

-	hrtimer_init(timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS_PINNED);

+	hrtimer_init(timer, CLOCK_MONOTONIC_HARD, HRTIMER_MODE_ABS_PINNED);

 	timer->function = perf_mux_hrtimer_handler;

-	timer->irqsafe = 1;

 }

 static int perf_mux_hrtimer_restart(struct perf_cpu_context *cpuctx)

@@ -9122,9 +9121,8 @@ static void perf_swevent_init_hrtimer(st

 	if (!is_sampling_event(event))

 		return;

-	hrtimer_init(&hwc->hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);

+	hrtimer_init(&hwc->hrtimer, CLOCK_MONOTONIC_HARD, HRTIMER_MODE_REL);

 	hwc->hrtimer.function = perf_swevent_hrtimer;

-	hwc->hrtimer.irqsafe = 1;

 	/*

 	 * Since hrtimers have a fixed rate, we can do a static freq->period

--- a/kernel/futex.c

+++ b/kernel/futex.c

@@ -2677,10 +2677,9 @@ static int futex_wait(u32 __user *uaddr,

 	if (abs_time) {

 		to = &timeout;

-		hrtimer_init_on_stack(&to->timer, (flags & FLAGS_CLOCKRT) ?

-				      CLOCK_REALTIME : CLOCK_MONOTONIC,

-				      HRTIMER_MODE_ABS);

-		hrtimer_init_sleeper(to, current);

+		hrtimer_init_sleeper_on_stack(to, (flags & FLAGS_CLOCKRT) ?

+					      CLOCK_REALTIME : CLOCK_MONOTONIC,

+					      HRTIMER_MODE_ABS, current);

 		hrtimer_set_expires_range_ns(&to->timer, *abs_time,

 					     current->timer_slack_ns);

 	}

@@ -2776,9 +2775,8 @@ static int futex_lock_pi(u32 __user *uad

 	if (time) {

 		to = &timeout;

-		hrtimer_init_on_stack(&to->timer, CLOCK_REALTIME,

-				      HRTIMER_MODE_ABS);

-		hrtimer_init_sleeper(to, current);

+		hrtimer_init_sleeper_on_stack(to, CLOCK_REALTIME,

+					      HRTIMER_MODE_ABS, current);

 		hrtimer_set_expires(&to->timer, *time);

 	}

@@ -3196,10 +3194,9 @@ static int futex_wait_requeue_pi(u32 __u

 	if (abs_time) {

 		to = &timeout;

-		hrtimer_init_on_stack(&to->timer, (flags & FLAGS_CLOCKRT) ?

-				      CLOCK_REALTIME : CLOCK_MONOTONIC,

-				      HRTIMER_MODE_ABS);

-		hrtimer_init_sleeper(to, current);

+		hrtimer_init_sleeper_on_stack(to, (flags & FLAGS_CLOCKRT) ?

+					      CLOCK_REALTIME : CLOCK_MONOTONIC,

+					      HRTIMER_MODE_ABS, current);

 		hrtimer_set_expires_range_ns(&to->timer, *abs_time,

 					     current->timer_slack_ns);

 	}

--- a/kernel/sched/core.c

+++ b/kernel/sched/core.c

@@ -344,9 +344,8 @@ static void init_rq_hrtick(struct rq *rq

 	rq->hrtick_csd.info = rq;

 #endif

-	hrtimer_init(&rq->hrtick_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);

+	hrtimer_init(&rq->hrtick_timer, CLOCK_MONOTONIC_HARD, HRTIMER_MODE_REL);

 	rq->hrtick_timer.function = hrtick;

-	rq->hrtick_timer.irqsafe = 1;

 }

 #else	/* CONFIG_SCHED_HRTICK */

 static inline void hrtick_clear(struct rq *rq)

--- a/kernel/sched/deadline.c

+++ b/kernel/sched/deadline.c

@@ -689,9 +689,8 @@ void init_dl_task_timer(struct sched_dl_

 {

 	struct hrtimer *timer = &dl_se->dl_timer;

-	hrtimer_init(timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);

+	hrtimer_init(timer, CLOCK_MONOTONIC_HARD, HRTIMER_MODE_REL);

 	timer->function = dl_task_timer;

-	timer->irqsafe = 1;

 }

 /*

--- a/kernel/sched/rt.c

+++ b/kernel/sched/rt.c

@@ -46,9 +46,8 @@ void init_rt_bandwidth(struct rt_bandwid

 	raw_spin_lock_init(&rt_b->rt_runtime_lock);

-	hrtimer_init(&rt_b->rt_period_timer,

-			CLOCK_MONOTONIC, HRTIMER_MODE_REL);

-	rt_b->rt_period_timer.irqsafe = 1;

+	hrtimer_init(&rt_b->rt_period_timer, CLOCK_MONOTONIC_HARD,

+		     HRTIMER_MODE_REL);

 	rt_b->rt_period_timer.function = sched_rt_period_timer;

 }

--- a/kernel/softirq.c

+++ b/kernel/softirq.c

@@ -1095,57 +1095,6 @@ void tasklet_kill(struct tasklet_struct

 }

 EXPORT_SYMBOL(tasklet_kill);

-/*

- * tasklet_hrtimer

- */

-

-/*

- * The trampoline is called when the hrtimer expires. It schedules a tasklet

- * to run __tasklet_hrtimer_trampoline() which in turn will call the intended

- * hrtimer callback, but from softirq context.

- */

-static enum hrtimer_restart __hrtimer_tasklet_trampoline(struct hrtimer *timer)

-{

-	struct tasklet_hrtimer *ttimer =

-		container_of(timer, struct tasklet_hrtimer, timer);

-

-	tasklet_hi_schedule(&ttimer->tasklet);

-	return HRTIMER_NORESTART;

-}

-

-/*

- * Helper function which calls the hrtimer callback from

- * tasklet/softirq context

- */

-static void __tasklet_hrtimer_trampoline(unsigned long data)

-{

-	struct tasklet_hrtimer *ttimer = (void *)data;

-	enum hrtimer_restart restart;

-

-	restart = ttimer->function(&ttimer->timer);

-	if (restart != HRTIMER_NORESTART)

-		hrtimer_restart(&ttimer->timer);

-}

-

-/**

- * tasklet_hrtimer_init - Init a tasklet/hrtimer combo for softirq callbacks

- * @ttimer:	 tasklet_hrtimer which is initialized

- * @function:	 hrtimer callback function which gets called from softirq context

- * @which_clock: clock id (CLOCK_MONOTONIC/CLOCK_REALTIME)

- * @mode:	 hrtimer mode (HRTIMER_MODE_ABS/HRTIMER_MODE_REL)

- */

-void tasklet_hrtimer_init(struct tasklet_hrtimer *ttimer,

-			  enum hrtimer_restart (*function)(struct hrtimer *),

-			  clockid_t which_clock, enum hrtimer_mode mode)

-{

-	hrtimer_init(&ttimer->timer, which_clock, mode);

-	ttimer->timer.function = __hrtimer_tasklet_trampoline;

-	tasklet_init(&ttimer->tasklet, __tasklet_hrtimer_trampoline,

-		     (unsigned long)ttimer);

-	ttimer->function = function;

-}

-EXPORT_SYMBOL_GPL(tasklet_hrtimer_init);

-

 void __init softirq_init(void)

 {

 	int cpu;

--- a/kernel/time/hrtimer.c

+++ b/kernel/time/hrtimer.c

@@ -59,6 +59,14 @@

 #include "tick-internal.h"

 /*

+ * Masks for selecting the soft and hard context timers from

+ * cpu_base->active

+ */

+#define MASK_SHIFT		(HRTIMER_BASE_MONOTONIC_SOFT)

+#define HRTIMER_ACTIVE_HARD	((1U << MASK_SHIFT) - 1)

+#define HRTIMER_ACTIVE_SOFT	(HRTIMER_ACTIVE_HARD << MASK_SHIFT)

+

+/*

  * The timer bases:

  *

  * There are more clockids than hrtimer bases. Thus, we index

@@ -69,7 +77,6 @@

 DEFINE_PER_CPU(struct hrtimer_cpu_base, hrtimer_bases) =

 {

 	.lock = __RAW_SPIN_LOCK_UNLOCKED(hrtimer_bases.lock),

-	.seq = SEQCNT_ZERO(hrtimer_bases.seq),

 	.clock_base =

 	{

 		{

@@ -92,17 +99,55 @@ DEFINE_PER_CPU(struct hrtimer_cpu_base,

 			.clockid = CLOCK_TAI,

 			.get_time = &ktime_get_clocktai,

 		},

+		{

+			.index = HRTIMER_BASE_MONOTONIC_SOFT,

+			.clockid = CLOCK_MONOTONIC_SOFT,

+			.get_time = &ktime_get,

+		},

+		{

+			.index = HRTIMER_BASE_REALTIME_SOFT,

+			.clockid = CLOCK_REALTIME_SOFT,

+			.get_time = &ktime_get_real,

+		},

+		{

+			.index = HRTIMER_BASE_BOOTTIME_SOFT,

+			.clockid = CLOCK_BOOTTIME_SOFT,

+			.get_time = &ktime_get_boottime,

+		},

+		{

+			.index = HRTIMER_BASE_TAI_SOFT,

+			.clockid = CLOCK_TAI_SOFT,

+			.get_time = &ktime_get_clocktai,

+		},

 	}

 };

-static const int hrtimer_clock_to_base_table[MAX_CLOCKS] = {

+#define MAX_CLOCKS_HRT		(MAX_CLOCKS * 3)

+

+static const int hrtimer_clock_to_base_table[MAX_CLOCKS_HRT] = {

 	/* Make sure we catch unsupported clockids */

-	[0 ... MAX_CLOCKS - 1]	= HRTIMER_MAX_CLOCK_BASES,

+	[0 ... MAX_CLOCKS_HRT - 1]	= HRTIMER_MAX_CLOCK_BASES,

-	[CLOCK_REALTIME]	= HRTIMER_BASE_REALTIME,

-	[CLOCK_MONOTONIC]	= HRTIMER_BASE_MONOTONIC,

-	[CLOCK_BOOTTIME]	= HRTIMER_BASE_BOOTTIME,

-	[CLOCK_TAI]		= HRTIMER_BASE_TAI,

+#ifdef CONFIG_PREEMPT_RT_FULL

+	[CLOCK_REALTIME]		= HRTIMER_BASE_REALTIME_SOFT,

+	[CLOCK_MONOTONIC]		= HRTIMER_BASE_MONOTONIC_SOFT,

+	[CLOCK_BOOTTIME]		= HRTIMER_BASE_BOOTTIME_SOFT,

+	[CLOCK_TAI]			= HRTIMER_BASE_TAI_SOFT,

+#else

+	[CLOCK_REALTIME]		= HRTIMER_BASE_REALTIME,

+	[CLOCK_MONOTONIC]		= HRTIMER_BASE_MONOTONIC,

+	[CLOCK_BOOTTIME]		= HRTIMER_BASE_BOOTTIME,

+	[CLOCK_TAI]			= HRTIMER_BASE_TAI,

+#endif

+	[CLOCK_REALTIME_SOFT]		= HRTIMER_BASE_REALTIME_SOFT,

+	[CLOCK_MONOTONIC_SOFT]		= HRTIMER_BASE_MONOTONIC_SOFT,

+	[CLOCK_BOOTTIME_SOFT]		= HRTIMER_BASE_BOOTTIME_SOFT,

+	[CLOCK_TAI_SOFT]		= HRTIMER_BASE_TAI_SOFT,

+

+	[CLOCK_REALTIME_HARD]		= HRTIMER_BASE_REALTIME,

+	[CLOCK_MONOTONIC_HARD]		= HRTIMER_BASE_MONOTONIC,

+	[CLOCK_BOOTTIME_HARD]		= HRTIMER_BASE_BOOTTIME,

+	[CLOCK_TAI_HARD]		= HRTIMER_BASE_TAI,

 };

 /*

@@ -117,7 +162,6 @@ static const int hrtimer_clock_to_base_t

  * timer->base->cpu_base

  */

 static struct hrtimer_cpu_base migration_cpu_base = {

-	.seq = SEQCNT_ZERO(migration_cpu_base),

 	.clock_base = { { .cpu_base = &migration_cpu_base, }, },

 };

@@ -155,26 +199,21 @@ struct hrtimer_clock_base *lock_hrtimer_

 }

 /*

- * With HIGHRES=y we do not migrate the timer when it is expiring

- * before the next event on the target cpu because we cannot reprogram

- * the target cpu hardware and we would cause it to fire late.

+ * We do not migrate the timer when it is expiring before the next

+ * event on the target cpu. When high resolution is enabled, we cannot

+ * reprogram the target cpu hardware and we would cause it to fire

+ * late. To keep it simple, we handle the high resolution enabled and

+ * disabled case similar.

  *

  * Called with cpu_base->lock of target cpu held.

  */

 static int

 hrtimer_check_target(struct hrtimer *timer, struct hrtimer_clock_base *new_base)

 {

-#ifdef CONFIG_HIGH_RES_TIMERS

 	ktime_t expires;

-	if (!new_base->cpu_base->hres_active)

-		return 0;

-

 	expires = ktime_sub(hrtimer_get_expires(timer), new_base->offset);

-	return expires <= new_base->cpu_base->expires_next;

-#else

-	return 0;

-#endif

+	return expires < new_base->cpu_base->expires_next;

 }

 #ifdef CONFIG_NO_HZ_COMMON

@@ -453,28 +492,26 @@ static inline void debug_deactivate(stru

 	trace_hrtimer_cancel(timer);

 }

-#if defined(CONFIG_NO_HZ_COMMON) || defined(CONFIG_HIGH_RES_TIMERS)

 static inline void hrtimer_update_next_timer(struct hrtimer_cpu_base *cpu_base,

 					     struct hrtimer *timer)

 {

-#ifdef CONFIG_HIGH_RES_TIMERS

 	cpu_base->next_timer = timer;

-#endif

 }

-static ktime_t __hrtimer_get_next_event(struct hrtimer_cpu_base *cpu_base)

+static ktime_t __hrtimer_next_event_base(struct hrtimer_cpu_base *cpu_base,

+					 unsigned int active,

+					 ktime_t expires_next)

 {

-	struct hrtimer_clock_base *base = cpu_base->clock_base;

-	unsigned int active = cpu_base->active_bases;

-	ktime_t expires, expires_next = KTIME_MAX;

+	ktime_t expires;

-	hrtimer_update_next_timer(cpu_base, NULL);

-	for (; active; base++, active >>= 1) {

+	while (active) {

+		unsigned int id = __ffs(active);

+		struct hrtimer_clock_base *base;

 		struct timerqueue_node *next;

 		struct hrtimer *timer;

-		if (!(active & 0x01))

-			continue;