LKML Archive on lore.kernel.org
 help / color / Atom feed
From: Thomas Gleixner <tglx@linutronix.de>
To: LKML <linux-kernel@vger.kernel.org>
Cc: Oleg Nesterov <oleg@redhat.com>, Ingo Molnar <mingo@kernel.org>,
	Peter Zijlstra <peterz@infradead.org>,
	John Stultz <john.stultz@linaro.org>,
	Frederic Weisbecker <frederic@kernel.org>,
	Anna-Maria Behnsen <anna-maria@linutronix.de>,
	Christoph Hellwig <hch@lst.de>
Subject: [patch V2 37/38] posix-cpu-timers: Move state tracking to struct posix_cputimers
Date: Wed, 21 Aug 2019 21:09:24 +0200
Message-ID: <20190821192922.743229404@linutronix.de> (raw)
In-Reply-To: <20190821190847.665673890@linutronix.de>

Put it where it belongs and clean up the ifdeffery in fork completely.

Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
---
V2: Adopt to the per clock base struct
---
 include/linux/posix-timers.h   |    8 ++++
 include/linux/sched/cputime.h  |    9 +++--
 include/linux/sched/signal.h   |    6 ---
 init/init_task.c               |    2 -
 kernel/fork.c                  |    6 ---
 kernel/time/posix-cpu-timers.c |   73 ++++++++++++++++++++++-------------------
 6 files changed, 54 insertions(+), 50 deletions(-)

--- a/include/linux/posix-timers.h
+++ b/include/linux/posix-timers.h
@@ -77,15 +77,23 @@ struct posix_cputimer_base {
 /**
  * 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)
 {
+	pct->timers_active = 0;
+	pct->expiry_active = 0;
 	pct->bases[0].nextevt = U64_MAX;
 	pct->bases[1].nextevt = U64_MAX;
 	pct->bases[2].nextevt = U64_MAX;
--- a/include/linux/sched/cputime.h
+++ b/include/linux/sched/cputime.h
@@ -70,7 +70,7 @@ void thread_group_sample_cputime(struct
  */
 
 /**
- * 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.
  */
@@ -80,8 +80,11 @@ struct thread_group_cputimer *get_runnin
 {
 	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;
 
 	/*
--- a/include/linux/sched/signal.h
+++ b/include/linux/sched/signal.h
@@ -57,18 +57,12 @@ struct task_cputime_atomic {
 /**
  * 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 {
--- a/init/init_task.c
+++ b/init/init_task.c
@@ -30,8 +30,6 @@ static struct signal_struct init_signals
 	.posix_timers = LIST_HEAD_INIT(init_signals.posix_timers),
 	.cputimer	= {
 		.cputime_atomic	= INIT_CPUTIME_ATOMIC,
-		.running	= false,
-		.checking_timer = false,
 	},
 #endif
 	INIT_CPU_TIMERS(init_signals)
--- a/kernel/fork.c
+++ b/kernel/fork.c
@@ -1517,7 +1517,6 @@ void __cleanup_sighand(struct sighand_st
 	}
 }
 
-#ifdef CONFIG_POSIX_TIMERS
 /*
  * Initialize POSIX timer handling for a thread group.
  */
@@ -1528,12 +1527,7 @@ static void posix_cpu_timers_init_group(
 
 	cpu_limit = READ_ONCE(sig->rlim[RLIMIT_CPU].rlim_cur);
 	posix_cputimers_group_init(pct, cpu_limit);
-	if (cpu_limit != RLIM_INFINITY)
-		sig->cputimer.running = true;
 }
-#else
-static inline void posix_cpu_timers_init_group(struct signal_struct *sig) { }
-#endif
 
 static int copy_signal(unsigned long clone_flags, struct task_struct *tsk)
 {
--- a/kernel/time/posix-cpu-timers.c
+++ b/kernel/time/posix-cpu-timers.c
@@ -23,8 +23,10 @@ static void posix_cpu_timer_rearm(struct
 void posix_cputimers_group_init(struct posix_cputimers *pct, u64 cpu_limit)
 {
 	posix_cputimers_init(pct);
-	if (cpu_limit != RLIM_INFINITY)
+	if (cpu_limit != RLIM_INFINITY) {
 		pct->bases[CPUCLOCK_PROF].nextevt = cpu_limit * NSEC_PER_SEC;
+		pct->timers_active = true;
+	}
 }
 
 /*
@@ -248,8 +250,9 @@ static void update_gt_cputime(struct tas
 void thread_group_sample_cputime(struct task_struct *tsk, u64 *samples)
 {
 	struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;
+	struct posix_cputimers *pct = &tsk->signal->posix_cputimers;
 
-	WARN_ON_ONCE(!cputimer->running);
+	WARN_ON_ONCE(!pct->timers_active);
 
 	proc_sample_cputime_atomic(&cputimer->cputime_atomic, samples);
 }
@@ -269,9 +272,10 @@ void thread_group_sample_cputime(struct
 static void thread_group_start_cputime(struct task_struct *tsk, u64 *samples)
 {
 	struct thread_group_cputimer *cputimer = &tsk->signal->cputimer;
+	struct posix_cputimers *pct = &tsk->signal->posix_cputimers;
 
 	/* Check if cputimer isn't running. This is accessed without locking. */
-	if (!READ_ONCE(cputimer->running)) {
+	if (!READ_ONCE(pct->timers_active)) {
 		struct task_cputime sum;
 
 		/*
@@ -283,13 +287,13 @@ static void thread_group_start_cputime(s
 		update_gt_cputime(&cputimer->cputime_atomic, &sum);
 
 		/*
-		 * We're setting cputimer->running without a lock. Ensure
-		 * this only gets written to in one operation. We set
-		 * running after update_gt_cputime() as a small optimization,
-		 * but barriers are not required because update_gt_cputime()
+		 * We're setting timers_active without a lock. Ensure this
+		 * only gets written to in one operation. We set it after
+		 * update_gt_cputime() as a small optimization, but
+		 * barriers are not required because update_gt_cputime()
 		 * can handle concurrent updates.
 		 */
-		WRITE_ONCE(cputimer->running, true);
+		WRITE_ONCE(pct->timers_active, true);
 	}
 	proc_sample_cputime_atomic(&cputimer->cputime_atomic, samples);
 }
@@ -313,9 +317,10 @@ static u64 cpu_clock_sample_group(const
 				  bool start)
 {
 	struct thread_group_cputimer *cputimer = &p->signal->cputimer;
+	struct posix_cputimers *pct = &p->signal->posix_cputimers;
 	u64 samples[CPUCLOCK_MAX];
 
-	if (!READ_ONCE(cputimer->running)) {
+	if (!READ_ONCE(pct->timers_active)) {
 		if (start)
 			thread_group_start_cputime(p, samples);
 		else
@@ -834,10 +839,10 @@ static void check_thread_timers(struct t
 
 static inline void stop_process_timers(struct signal_struct *sig)
 {
-	struct thread_group_cputimer *cputimer = &sig->cputimer;
+	struct posix_cputimers *pct = &sig->posix_cputimers;
 
-	/* Turn off cputimer->running. This is done without locking. */
-	WRITE_ONCE(cputimer->running, false);
+	/* Turn off the active flag. This is done without locking. */
+	WRITE_ONCE(pct->timers_active, false);
 	tick_dep_clear_signal(sig, TICK_DEP_BIT_POSIX_TIMER);
 }
 
@@ -877,17 +882,17 @@ static void check_process_timers(struct
 	unsigned long soft;
 
 	/*
-	 * If cputimer is not running, then there are no active
-	 * process wide timers (POSIX 1.b, itimers, RLIMIT_CPU).
+	 * If there are no active process wide timers (POSIX 1.b, itimers,
+	 * RLIMIT_CPU) nothing to check.
 	 */
-	if (!READ_ONCE(sig->cputimer.running))
+	if (!READ_ONCE(pct->timers_active))
 		return;
 
        /*
 	 * Signify that a thread is checking for process timers.
 	 * Write access to this field is protected by the sighand lock.
 	 */
-	sig->cputimer.checking_timer = true;
+	pct->timers_active = true;
 
 	/*
 	 * Collect the current process totals. Group accounting is active
@@ -933,7 +938,7 @@ static void check_process_timers(struct
 	if (expiry_cache_is_inactive(pct))
 		stop_process_timers(sig);
 
-	sig->cputimer.checking_timer = false;
+	pct->expiry_active = false;
 }
 
 /*
@@ -1027,39 +1032,41 @@ task_cputimers_expired(const u64 *sample
  */
 static inline bool fastpath_timer_check(struct task_struct *tsk)
 {
+	struct posix_cputimers *pct = &tsk->posix_cputimers;
 	struct signal_struct *sig;
 
-	if (!expiry_cache_is_inactive(&tsk->posix_cputimers)) {
+	if (!expiry_cache_is_inactive(pct)) {
 		u64 samples[CPUCLOCK_MAX];
 
 		task_sample_cputime(tsk, samples);
-		if (task_cputimers_expired(samples, &tsk->posix_cputimers))
+		if (task_cputimers_expired(samples, pct))
 			return true;
 	}
 
 	sig = tsk->signal;
+	pct = &sig->posix_cputimers;
 	/*
-	 * Check if thread group timers expired when the cputimer is
-	 * running and no other thread in the group is already checking
-	 * for thread group cputimers. These fields are read without the
-	 * sighand lock. However, this is fine because this is meant to
-	 * be a fastpath heuristic to determine whether we should try to
-	 * acquire the sighand lock to check/handle timers.
+	 * Check if thread group timers expired when timers are active and
+	 * no other thread in the group is already handling expiry for
+	 * thread group cputimers. These fields are read without the
+	 * sighand lock. However, this is fine because this is meant to be
+	 * a fastpath heuristic to determine whether we should try to
+	 * acquire the sighand lock to handle timer expiry.
 	 *
-	 * In the worst case scenario, if 'running' or 'checking_timer' gets
-	 * set but the current thread doesn't see the change yet, we'll wait
-	 * until the next thread in the group gets a scheduler interrupt to
-	 * handle the timer. This isn't an issue in practice because these
-	 * types of delays with signals actually getting sent are expected.
+	 * In the worst case scenario, if concurrently timers_active is set
+	 * or expiry_active is cleared, but the current thread doesn't see
+	 * the change yet, the timer checks are delayed until the next
+	 * thread in the group gets a scheduler interrupt to handle the
+	 * timer. This isn't an issue in practice because these types of
+	 * delays with signals actually getting sent are expected.
 	 */
-	if (READ_ONCE(sig->cputimer.running) &&
-	    !READ_ONCE(sig->cputimer.checking_timer)) {
+	if (READ_ONCE(pct->timers_active) && !READ_ONCE(pct->expiry_active)) {
 		u64 samples[CPUCLOCK_MAX];
 
 		proc_sample_cputime_atomic(&sig->cputimer.cputime_atomic,
 					   samples);
 
-		if (task_cputimers_expired(samples, &sig->posix_cputimers))
+		if (task_cputimers_expired(samples, pct))
 			return true;
 	}
 



  parent reply index

Thread overview: 137+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2019-08-21 19:08 [patch V2 00/38] posix-cpu-timers: Cleanup and consolidation Thomas Gleixner
2019-08-21 19:08 ` [patch V2 01/38] posix-cpu-timers: Provide task validation functions Thomas Gleixner
2019-08-21 22:33   ` Frederic Weisbecker
2019-08-21 23:03     ` Frederic Weisbecker
2019-08-23 15:33       ` Thomas Gleixner
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:08 ` [patch V2 02/38] posix-cpu-timers: Use common permission check in posix_cpu_clock_get() Thomas Gleixner
2019-08-21 23:40   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-29 11:00     ` kbuild test robot
2019-08-29 11:21       ` Thomas Gleixner
2019-08-30  1:08         ` [kbuild-all] " Philip Li
2019-08-29 11:23     ` kbuild test robot
2019-08-21 19:08 ` [patch V2 03/38] posix-cpu-timers: Use common permission check in posix_cpu_timer_create() Thomas Gleixner
2019-08-21 23:49   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:08 ` [patch V2 04/38] posix-cpu-timers: Provide quick sample function for itimer Thomas Gleixner
2019-08-22 12:13   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:08 ` [patch V2 05/38] itimers: Use quick sample function Thomas Gleixner
2019-08-22 12:15   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-29 23:47     ` kbuild test robot
2019-08-30  6:01       ` Thomas Gleixner
2019-08-21 19:08 ` [patch V2 06/38] posix-cpu-timers: Sample directly in timer check Thomas Gleixner
2019-08-22 12:30   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:08 ` [patch V2 07/38] posix-cpu-timers: Rename thread_group_cputimer() and make it static Thomas Gleixner
2019-08-22 12:41   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:08 ` [patch V2 08/38] posix-cpu-timers: Consolidate thread group sample code Thomas Gleixner
2019-08-22 13:49   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:08 ` [patch V2 09/38] posix-cpu-timers: Use clock ID in posix_cpu_timer_set() Thomas Gleixner
2019-08-22 13:58   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:08 ` [patch V2 10/38] posix-cpu-timers: Use clock ID in posix_cpu_timer_get() Thomas Gleixner
2019-08-22 14:07   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:08 ` [patch V2 11/38] posix-cpu-timers: Use clock ID in posix_cpu_timer_rearm() Thomas Gleixner
2019-08-22 14:12   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:08 ` [patch V2 12/38] posix-cpu-timers: Remove pointless return value check Thomas Gleixner
2019-08-22 14:15   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 13/38] posix-cpu-timers: Simplify sample functions Thomas Gleixner
2019-08-22 14:20   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 14/38] posix-cpu-timers: Get rid of pointer indirection Thomas Gleixner
2019-08-22 14:41   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 15/38] posix-cpu-timers: Sample task times once in expiry check Thomas Gleixner
2019-08-22 15:00   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 16/38] posix-cpu-timers: Move prof/virt_ticks into caller Thomas Gleixner
2019-08-22 15:05   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 17/38] posix-cpu-timers: Create a container struct Thomas Gleixner
2019-08-22 15:32   ` Frederic Weisbecker
2019-08-23 15:34     ` Thomas Gleixner
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 19/38] posix-cpu-timers: Move expiry cache into struct posix_cputimers Thomas Gleixner
2019-08-22 16:29   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 20/38] posix-cpu-timers: Provide array based access to expiry cache Thomas Gleixner
2019-08-23 17:33   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 21/38] posix-cpu-timers: Simplify timer queueing Thomas Gleixner
2019-08-23 17:51   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 22/38] posix-cpu-timers: Simplify set_process_cpu_timer() Thomas Gleixner
2019-08-23 18:00   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 23/38] posix-cpu-timers: Switch check_*_timers() to array cache Thomas Gleixner
2019-08-23 18:13   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 24/38] posix-cpu-timers: Remove the odd field rename defines Thomas Gleixner
2019-08-23 18:36   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 25/38] posix-cpu-timers: Provide array based sample functions Thomas Gleixner
2019-08-23 22:08   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 26/38] posix-cpu-timers: Make expiry checks array based Thomas Gleixner
2019-08-23 22:44   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 27/38] posix-cpu-timers: Remove cputime_expires Thomas Gleixner
2019-08-23 22:50   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 28/38] posix-cpu-timers: Restructure expiry array Thomas Gleixner
2019-08-26 16:32   ` Frederic Weisbecker
2019-08-26 18:16     ` Thomas Gleixner
2019-08-26 18:22       ` [patch V3 " Thomas Gleixner
2019-08-26 19:45         ` Frederic Weisbecker
2019-08-28 10:16         ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-26 21:06   ` [patch V2 28/38] " Frederic Weisbecker
2019-08-26 21:46     ` Thomas Gleixner
2019-08-21 19:09 ` [patch V2 29/38] posix-cpu-timers: Switch thread group sampling to array Thomas Gleixner
2019-08-26 21:12   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 30/38] posix-cpu-timers: Respect INFINITY for hard RTTIME limit Thomas Gleixner
2019-08-26 21:19   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 31/38] rlimit: Rewrite non-sensical RLIMIT_CPU comment Thomas Gleixner
2019-08-26 21:41   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 32/38] posix-cpu-timers: Get rid of zero checks Thomas Gleixner
2019-08-26 21:57   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 33/38] posix-cpu-timers: Consolidate timer expiry further Thomas Gleixner
2019-08-26 22:29   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 34/38] posix-cpu-timers: Get rid of 64bit divisions Thomas Gleixner
2019-08-26 22:51   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 35/38] posix-cpu-timers: Remove pointless comparisons Thomas Gleixner
2019-08-26 22:59   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 36/38] posix-cpu-timers: Deduplicate rlimit handling Thomas Gleixner
2019-08-26 23:13   ` Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` Thomas Gleixner [this message]
2019-08-26 23:28   ` [patch V2 37/38] posix-cpu-timers: Move state tracking to struct posix_cputimers Frederic Weisbecker
2019-08-26 23:33     ` Thomas Gleixner
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-21 19:09 ` [patch V2 38/38] posix-cpu-timers: Utilize timerqueue for storage Thomas Gleixner
2019-08-27  0:48   ` Frederic Weisbecker
2019-08-27  6:08     ` Thomas Gleixner
2019-08-27 13:17       ` Frederic Weisbecker
2019-08-27 13:46         ` Thomas Gleixner
2019-08-27 19:31           ` [patch V3 " Thomas Gleixner
2019-08-27 22:23             ` Frederic Weisbecker
2019-08-28 10:16             ` [tip: timers/core] " tip-bot2 for Thomas Gleixner
2019-08-22  0:54 ` [patch V2 00/38] posix-cpu-timers: Cleanup and consolidation Christoph Hellwig
2019-08-22  1:02   ` Frederic Weisbecker
2019-08-22  1:02     ` Christoph Hellwig
     [not found] ` <20190821192920.909530418@linutronix.de>
2019-08-22 16:06   ` [patch V2 18/38] sched: Move struct task_cputime to types.h Frederic Weisbecker
2019-08-28 10:16   ` [tip: timers/core] " tip-bot2 for Thomas Gleixner

Reply instructions:

You may reply publically to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20190821192922.743229404@linutronix.de \
    --to=tglx@linutronix.de \
    --cc=anna-maria@linutronix.de \
    --cc=frederic@kernel.org \
    --cc=hch@lst.de \
    --cc=john.stultz@linaro.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=mingo@kernel.org \
    --cc=oleg@redhat.com \
    --cc=peterz@infradead.org \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link

LKML Archive on lore.kernel.org

Archives are clonable:
	git clone --mirror https://lore.kernel.org/lkml/0 lkml/git/0.git
	git clone --mirror https://lore.kernel.org/lkml/1 lkml/git/1.git
	git clone --mirror https://lore.kernel.org/lkml/2 lkml/git/2.git
	git clone --mirror https://lore.kernel.org/lkml/3 lkml/git/3.git
	git clone --mirror https://lore.kernel.org/lkml/4 lkml/git/4.git
	git clone --mirror https://lore.kernel.org/lkml/5 lkml/git/5.git
	git clone --mirror https://lore.kernel.org/lkml/6 lkml/git/6.git
	git clone --mirror https://lore.kernel.org/lkml/7 lkml/git/7.git
	git clone --mirror https://lore.kernel.org/lkml/8 lkml/git/8.git

	# If you have public-inbox 1.1+ installed, you may
	# initialize and index your mirror using the following commands:
	public-inbox-init -V2 lkml lkml/ https://lore.kernel.org/lkml \
		linux-kernel@vger.kernel.org
	public-inbox-index lkml

Example config snippet for mirrors

Newsgroup available over NNTP:
	nntp://nntp.lore.kernel.org/org.kernel.vger.linux-kernel


AGPL code for this site: git clone https://public-inbox.org/public-inbox.git