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 ...

Linus Torvalds committed 7 years ago

Commit 7f2444d2 parents c5f12fd 77b4b5461 files · +1476 −895Browse files

Showing the changes to include/linux (11 of 61 files). Show all

Unified · Split

11 files

include/linux/alarmtimer.h +2 −1
include/linux/hrtimer.h +44 −4
include/linux/init_task.h +0 −11
include/linux/posix-timers.h +117 −14
include/linux/sched.h +4 −25
include/linux/sched/cputime.h +7 −5
include/linux/sched/signal.h +3 −11
include/linux/sched/types.h +23 −0
include/linux/timer.h +1 −1
include/linux/timerqueue.h +16 −7
include/linux/wait.h +2 −2

include/linux/alarmtimer.h+2−1

@@ -5,7 +5,8 @@ · 4 unmodified lines
5	#include <linux/time.h>	5	#include <linux/time.h>
6	#include <linux/hrtimer.h>	6	#include <linux/hrtimer.h>
7	#include <linux/timerqueue.h>	7	#include <linux/timerqueue.h>
8	#include <linux/rtc.h>	8
		9	struct rtc_device;
9		10
10	enum alarmtimer_type {	11	enum alarmtimer_type {
11	ALARM_REALTIME,	12	ALARM_REALTIME,

include/linux/hrtimer.h+44−4

  *				  when starting the timer)
  * HRTIMER_MODE_SOFT		- Timer callback function will be executed in
  *				  soft irq context
+ * HRTIMER_MODE_HARD		- Timer callback function will be executed in
+ *				  hard irq context even on PREEMPT_RT.
  */
 enum hrtimer_mode {
 	HRTIMER_MODE_ABS	= 0x00,
 	HRTIMER_MODE_REL	= 0x01,
 	HRTIMER_MODE_PINNED	= 0x02,
 	HRTIMER_MODE_SOFT	= 0x04,
+	HRTIMER_MODE_HARD	= 0x08,
 	HRTIMER_MODE_ABS_PINNED = HRTIMER_MODE_ABS | HRTIMER_MODE_PINNED,
 	HRTIMER_MODE_REL_PINNED = HRTIMER_MODE_REL | HRTIMER_MODE_PINNED,
 	HRTIMER_MODE_ABS_PINNED_SOFT = HRTIMER_MODE_ABS_PINNED | HRTIMER_MODE_SOFT,
 	HRTIMER_MODE_REL_PINNED_SOFT = HRTIMER_MODE_REL_PINNED | HRTIMER_MODE_SOFT,
+	HRTIMER_MODE_ABS_HARD	= HRTIMER_MODE_ABS | HRTIMER_MODE_HARD,
+	HRTIMER_MODE_REL_HARD	= HRTIMER_MODE_REL | HRTIMER_MODE_HARD,
+	HRTIMER_MODE_ABS_PINNED_HARD = HRTIMER_MODE_ABS_PINNED | HRTIMER_MODE_HARD,
+	HRTIMER_MODE_REL_PINNED_HARD = HRTIMER_MODE_REL_PINNED | HRTIMER_MODE_HARD,
 };
 /*
  * @state:	state information (See bit values above)
  * @is_rel:	Set if the timer was armed relative
  * @is_soft:	Set if hrtimer will be expired in soft interrupt context.
+ * @is_hard:	Set if hrtimer will be expired in hard interrupt context
+ *		even on RT.
  *
  * The hrtimer structure must be initialized by hrtimer_init()
  */
 	u8				state;
 	u8				is_rel;
 	u8				is_soft;
+	u8				is_hard;
 };
 /**
  * @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
+ * @softirq_expiry_lock: Lock which is taken while softirq based hrtimer are
+ *			 expired
+ * @timer_waiters:	A hrtimer_cancel() invocation waits for the timer
+ *			callback to finish.
  * @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)
 	unsigned short			nr_retries;
 	unsigned short			nr_hangs;
 	unsigned int			max_hang_time;
+#endif
+#ifdef CONFIG_PREEMPT_RT
+	spinlock_t			softirq_expiry_lock;
+	atomic_t			timer_waiters;
 #endif
 	ktime_t				expires_next;
 	struct hrtimer			*next_timer;
 DECLARE_PER_CPU(struct tick_device, tick_cpu_device);
+#ifdef CONFIG_PREEMPT_RT
+void hrtimer_cancel_wait_running(const struct hrtimer *timer);
+#else
+static inline void hrtimer_cancel_wait_running(struct hrtimer *timer)
+{
+	cpu_relax();
+}
+#endif
 /* Exported timer functions: */
 /* 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);
 #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);
 extern void destroy_hrtimer_on_stack(struct hrtimer *timer);
 #else
 {
 	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)
+{
+	hrtimer_init_sleeper(sl, clock_id, mode);
+}
 static inline void destroy_hrtimer_on_stack(struct hrtimer *timer) { }
 #endif
 	hrtimer_start_range_ns(timer, soft, delta, mode);
 }
+void hrtimer_sleeper_start_expires(struct hrtimer_sleeper *sl,
+				   enum hrtimer_mode mode);
 static inline void hrtimer_restart(struct hrtimer *timer)
 {
 	hrtimer_start_expires(timer, HRTIMER_MODE_ABS);
 			      const enum hrtimer_mode mode,
 			      const clockid_t clockid);
-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);
+				    const enum hrtimer_mode mode);
 extern int schedule_hrtimeout_range_clock(ktime_t *expires,
 					  u64 delta,
 					  const enum hrtimer_mode mode,

include/linux/init_task.h+0−11

@@ -36,17 +36,6 @@ extern struct cred init_cred; · 35 unmodified lines
36	#define INIT_PREV_CPUTIME(x)	36	#define INIT_PREV_CPUTIME(x)
37	#endif	37	#endif
38		38
39	#ifdef CONFIG_POSIX_TIMERS
40	#define INIT_CPU_TIMERS(s) \
41	.cpu_timers = { \
42	LIST_HEAD_INIT(s.cpu_timers[0]), \
43	LIST_HEAD_INIT(s.cpu_timers[1]), \
44	LIST_HEAD_INIT(s.cpu_timers[2]), \
45	},
46	#else
47	#define INIT_CPU_TIMERS(s)
48	#endif
49
50	#define INIT_TASK_COMM "swapper"	39	#define INIT_TASK_COMM "swapper"
51		40
52	/* Attach to the init_task data structure for proper alignment */	41	/* Attach to the init_task data structure for proper alignment */

include/linux/posix-timers.h+117−14

@@ -4,18 +4,11 @@ · 3 unmodified lines
4		4
5	#include <linux/spinlock.h>	5	#include <linux/spinlock.h>
6	#include <linux/list.h>	6	#include <linux/list.h>
7	#include <linux/sched.h>
8	#include <linux/timex.h>
9	#include <linux/alarmtimer.h>	7	#include <linux/alarmtimer.h>
		8	#include <linux/timerqueue.h>
10		9
11	struct siginfo;	10	struct kernel_siginfo;
12		11	struct task_struct;
13	struct cpu_timer_list {
14	struct list_head entry;
15	u64 expires;
16	struct task_struct *task;
17	int firing;
18	};
19		12
20	/*	13	/*
21	* Bit fields within a clockid:	14	* Bit fields within a clockid:
@@ -63,6 +56,115 @@ static inline int clockid_to_fd(const clockid_t clk) · 41 unmodified lines
63	return ~(clk >> 3);	56	return ~(clk >> 3);
64	}	57	}
65		58
		59	#ifdef CONFIG_POSIX_TIMERS
		60
		61	/**
		62	* cpu_timer - Posix CPU timer representation for k_itimer
		63	* @node: timerqueue node to queue in the task/sig
		64	* @head: timerqueue head on which this timer is queued
		65	* @task: Pointer to target task
		66	* @elist: List head for the expiry list
		67	* @firing: Timer is currently firing
		68	*/
		69	struct cpu_timer {
		70	struct timerqueue_node node;
		71	struct timerqueue_head *head;
		72	struct task_struct *task;
		73	struct list_head elist;
		74	int firing;
		75	};
		76
		77	static inline bool cpu_timer_enqueue(struct timerqueue_head *head,
		78	struct cpu_timer *ctmr)
		79	{
		80	ctmr->head = head;
		81	return timerqueue_add(head, &ctmr->node);
		82	}
		83
		84	static inline void cpu_timer_dequeue(struct cpu_timer *ctmr)
		85	{
		86	if (ctmr->head) {
		87	timerqueue_del(ctmr->head, &ctmr->node);
		88	ctmr->head = NULL;
		89	}
		90	}
		91
		92	static inline u64 cpu_timer_getexpires(struct cpu_timer *ctmr)
		93	{
		94	return ctmr->node.expires;
		95	}
		96
		97	static inline void cpu_timer_setexpires(struct cpu_timer *ctmr, u64 exp)
		98	{
		99	ctmr->node.expires = exp;
		100	}
		101
		102	/**
		103	* posix_cputimer_base - Container per posix CPU clock
		104	* @nextevt: Earliest-expiration cache
		105	* @tqhead: timerqueue head for cpu_timers
		106	*/
		107	struct posix_cputimer_base {
		108	u64 nextevt;
		109	struct timerqueue_head tqhead;
		110	};
		111
		112	/**
		113	* posix_cputimers - Container for posix CPU timer related data
		114	* @bases: Base container for posix CPU clocks
		115	* @timers_active: Timers are queued.
		116	* @expiry_active: Timer expiry is active. Used for
		117	* process wide timers to avoid multiple
		118	* task trying to handle expiry concurrently
		119	*
		120	* Used in task_struct and signal_struct
		121	*/
		122	struct posix_cputimers {
		123	struct posix_cputimer_base bases[CPUCLOCK_MAX];
		124	unsigned int timers_active;
		125	unsigned int expiry_active;
		126	};
		127
		128	static inline void posix_cputimers_init(struct posix_cputimers *pct)
		129	{
		130	memset(pct, 0, sizeof(*pct));
		131	pct->bases[0].nextevt = U64_MAX;
		132	pct->bases[1].nextevt = U64_MAX;
		133	pct->bases[2].nextevt = U64_MAX;
		134	}
		135
		136	void posix_cputimers_group_init(struct posix_cputimers *pct, u64 cpu_limit);
		137
		138	static inline void posix_cputimers_rt_watchdog(struct posix_cputimers *pct,
		139	u64 runtime)
		140	{
		141	pct->bases[CPUCLOCK_SCHED].nextevt = runtime;
		142	}
		143
		144	/* Init task static initializer */
		145	#define INIT_CPU_TIMERBASE(b) { \
		146	.nextevt = U64_MAX, \
		147	}
		148
		149	#define INIT_CPU_TIMERBASES(b) { \
		150	INIT_CPU_TIMERBASE(b[0]), \
		151	INIT_CPU_TIMERBASE(b[1]), \
		152	INIT_CPU_TIMERBASE(b[2]), \
		153	}
		154
		155	#define INIT_CPU_TIMERS(s) \
		156	.posix_cputimers = { \
		157	.bases = INIT_CPU_TIMERBASES(s.posix_cputimers.bases), \
		158	},
		159	#else
		160	struct posix_cputimers { };
		161	struct cpu_timer { };
		162	#define INIT_CPU_TIMERS(s)
		163	static inline void posix_cputimers_init(struct posix_cputimers *pct) { }
		164	static inline void posix_cputimers_group_init(struct posix_cputimers *pct,
		165	u64 cpu_limit) { }
		166	#endif
		167
66	#define REQUEUE_PENDING 1	168	#define REQUEUE_PENDING 1
67		169
68	/**	170	/**
@@ -85,7 +187,8 @@ static inline int clockid_to_fd(const clockid_t clk) · 16 unmodified lines
85	* @it_process: The task to wakeup on clock_nanosleep (CPU timers)	187	* @it_process: The task to wakeup on clock_nanosleep (CPU timers)
86	* @sigq: Pointer to preallocated sigqueue	188	* @sigq: Pointer to preallocated sigqueue
87	* @it: Union representing the various posix timer type	189	* @it: Union representing the various posix timer type
88	* internals. Also used for rcu freeing the timer.	190	* internals.
		191	* @rcu: RCU head for freeing the timer.
89	*/	192	*/
90	struct k_itimer {	193	struct k_itimer {
91	struct list_head list;	194	struct list_head list;
@@ -110,15 +213,15 @@ struct k_itimer { · 18 unmodified lines
110	struct {	213	struct {
111	struct hrtimer timer;	214	struct hrtimer timer;
112	} real;	215	} real;
113	struct cpu_timer_list cpu;	216	struct cpu_timer cpu;
114	struct {	217	struct {
115	struct alarm alarmtimer;	218	struct alarm alarmtimer;
116	} alarm;	219	} alarm;
117	struct rcu_head rcu;
118	} it;	220	} it;
		221	struct rcu_head rcu;
119	};	222	};
120		223
121	void run_posix_cpu_timers(struct task_struct *task);	224	void run_posix_cpu_timers(void);
122	void posix_cpu_timers_exit(struct task_struct *task);	225	void posix_cpu_timers_exit(struct task_struct *task);
123	void posix_cpu_timers_exit_group(struct task_struct *task);	226	void posix_cpu_timers_exit_group(struct task_struct *task);
124	void set_process_cpu_timer(struct task_struct *task, unsigned int clock_idx,	227	void set_process_cpu_timer(struct task_struct *task, unsigned int clock_idx,

include/linux/sched.h+4−25

 #include <linux/resource.h>
 #include <linux/latencytop.h>
 #include <linux/sched/prio.h>
+#include <linux/sched/types.h>
 #include <linux/signal_types.h>
 #include <linux/mm_types_task.h>
 #include <linux/task_io_accounting.h>
+#include <linux/posix-timers.h>
 #include <linux/rseq.h>
 /* task_struct member predeclarations (sorted alphabetically): */
 #endif
 };
-/**
- * struct task_cputime - collected CPU time counts
- * @utime:		time spent in user mode, in nanoseconds
- * @stime:		time spent in kernel mode, in nanoseconds
- * @sum_exec_runtime:	total time spent on the CPU, in nanoseconds
- *
- * This structure groups together three kinds of CPU time that are tracked for
- * threads and thread groups.  Most things considering CPU time want to group
- * these counts together and treat all three of them in parallel.
- */
-struct task_cputime {
-	u64				utime;
-	u64				stime;
-	unsigned long long		sum_exec_runtime;
-};
-/* Alternate field names when used on cache expirations: */
-#define virt_exp			utime
-#define prof_exp			stime
-#define sched_exp			sum_exec_runtime
 enum vtime_state {
 	/* Task is sleeping or running in a CPU with VTIME inactive: */
 	VTIME_INACTIVE = 0,
 	unsigned long			min_flt;
 	unsigned long			maj_flt;
-#ifdef CONFIG_POSIX_TIMERS
+	/* Empty if CONFIG_POSIX_CPUTIMERS=n */
-	struct task_cputime		cputime_expires;
+	struct posix_cputimers		posix_cputimers;
-	struct list_head		cpu_timers[3];
-#endif
 	/* Process credentials: */

include/linux/sched/cputime.h+7−5

  * Thread group CPU time accounting.
  */
 void thread_group_cputime(struct task_struct *tsk, struct task_cputime *times);
-void thread_group_cputimer(struct task_struct *tsk, struct task_cputime *times);
+void thread_group_sample_cputime(struct task_struct *tsk, u64 *samples);
 /*
  * The following are functions that support scheduler-internal time accounting.
  */
 /**
- * get_running_cputimer - return &tsk->signal->cputimer if cputimer is running
+ * get_running_cputimer - return &tsk->signal->cputimer if cputimers are active
  *
  * @tsk:	Pointer to target task.
  */
 {
 	struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;
-	/* Check if cputimer isn't running. This is accessed without locking. */
+	/*
-	if (!READ_ONCE(cputimer->running))
+	 * Check whether posix CPU timers are active. If not the thread
+	 * group accounting is not active either. Lockless check.
+	 */
+	if (!READ_ONCE(tsk->signal->posix_cputimers.timers_active))
 		return NULL;
 	/*

include/linux/sched/signal.h+3−11

 #include <linux/sched/task.h>
 #include <linux/cred.h>
 #include <linux/refcount.h>
+#include <linux/posix-timers.h>
 /*
  * Types defining task->signal and task->sighand and APIs using them:
 /**
  * struct thread_group_cputimer - thread group interval timer counts
  * @cputime_atomic:	atomic thread group interval timers.
- * @running:		true when there are timers running and
- *			@cputime_atomic receives updates.
- * @checking_timer:	true when a thread in the group is in the
- *			process of checking for thread group timers.
  *
  * This structure contains the version of task_cputime, above, that is
  * used for thread group CPU timer calculations.
  */
 struct thread_group_cputimer {
 	struct task_cputime_atomic cputime_atomic;
-	bool running;
-	bool checking_timer;
 };
 struct multiprocess_signals {
 	 */
 	struct thread_group_cputimer cputimer;
-	/* Earliest-expiration cache. */
-	struct task_cputime cputime_expires;
-	struct list_head cpu_timers[3];
 #endif
+	/* Empty if CONFIG_POSIX_TIMERS=n */
+	struct posix_cputimers posix_cputimers;
 	/* PID/PID hash table linkage. */
 	struct pid *pids[PIDTYPE_MAX];

include/linux/sched/types.h+23−0

@@ -0,0 +1,23 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	#ifndef _LINUX_SCHED_TYPES_H
	3	#define _LINUX_SCHED_TYPES_H
	4
	5	#include <linux/types.h>
	6
	7	/**
	8	* struct task_cputime - collected CPU time counts
	9	* @stime: time spent in kernel mode, in nanoseconds
	10	* @utime: time spent in user mode, in nanoseconds
	11	* @sum_exec_runtime: total time spent on the CPU, in nanoseconds
	12	*
	13	* This structure groups together three kinds of CPU time that are tracked for
	14	* threads and thread groups. Most things considering CPU time want to group
	15	* these counts together and treat all three of them in parallel.
	16	*/
	17	struct task_cputime {
	18	u64 stime;
	19	u64 utime;
	20	unsigned long long sum_exec_runtime;
	21	};
	22
	23	#endif

include/linux/timer.h+1−1

@@ -183,7 +183,7 @@ extern void add_timer(struct timer_list *timer); · 182 unmodified lines
183		183
184	extern int try_to_del_timer_sync(struct timer_list *timer);	184	extern int try_to_del_timer_sync(struct timer_list *timer);
185		185
186	#ifdef CONFIG_SMP	186	#if defined(CONFIG_SMP) \|\| defined(CONFIG_PREEMPT_RT)
187	extern int del_timer_sync(struct timer_list *timer);	187	extern int del_timer_sync(struct timer_list *timer);
188	#else	188	#else
189	# define del_timer_sync(t) del_timer(t)	189	# define del_timer_sync(t) del_timer(t)

include/linux/timerqueue.h+16−7

 };
 struct timerqueue_head {
-	struct rb_root head;
+	struct rb_root_cached rb_root;
-	struct timerqueue_node *next;
 };
  *
  * @head: head of timerqueue
  *
- * Returns a pointer to the timer node that has the
+ * Returns a pointer to the timer node that has the earliest expiration time.
- * earliest expiration time.
  */
 static inline
 struct timerqueue_node *timerqueue_getnext(struct timerqueue_head *head)
 {
-	return head->next;
+	struct rb_node *leftmost = rb_first_cached(&head->rb_root);
+	return rb_entry(leftmost, struct timerqueue_node, node);
 }
 static inline void timerqueue_init(struct timerqueue_node *node)
 	RB_CLEAR_NODE(&node->node);
 }
+static inline bool timerqueue_node_queued(struct timerqueue_node *node)
+{
+	return !RB_EMPTY_NODE(&node->node);
+}
+static inline bool timerqueue_node_expires(struct timerqueue_node *node)
+{
+	return node->expires;
+}
 static inline void timerqueue_init_head(struct timerqueue_head *head)
 {
-	head->head = RB_ROOT;
+	head->rb_root = RB_ROOT_CACHED;
-	head->next = NULL;
 }
 #endif /* _LINUX_TIMERQUEUE_H */

include/linux/wait.h+2−2

@@ -501,8 +501,8 @@ do { \ · 500 unmodified lines
501	int __ret = 0; \	501	int __ret = 0; \
502	struct hrtimer_sleeper __t; \	502	struct hrtimer_sleeper __t; \
503	\	503	\
504	hrtimer_init_on_stack(&__t.timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); \	504	hrtimer_init_sleeper_on_stack(&__t, CLOCK_MONOTONIC, \
505	hrtimer_init_sleeper(&__t, current); \	505	HRTIMER_MODE_REL); \
506	if ((timeout) != KTIME_MAX) \	506	if ((timeout) != KTIME_MAX) \
507	hrtimer_start_range_ns(&__t.timer, timeout, \	507	hrtimer_start_range_ns(&__t.timer, timeout, \
508	current->timer_slack_ns, \	508	current->timer_slack_ns, \

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

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code