From: Krzysztof Kozlowski <k.kozlowski@samsung.com> To: Russell King <linux@arm.linux.org.uk>, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Cc: paulmck@linux.vnet.ibm.com, Arnd Bergmann <arnd@arndb.de>, Mark Rutland <mark.rutland@arm.com>, Bartlomiej Zolnierkiewicz <b.zolnierkie@samsung.com>, Marek Szyprowski <m.szyprowski@samsung.com>, Stephen Boyd <sboyd@codeaurora.org>, Catalin Marinas <catalin.marinas@arm.com>, Will Deacon <will.deacon@arm.com>, Krzysztof Kozlowski <k.kozlowski@samsung.com> Subject: [PATCH v2] ARM: Don't use complete() during __cpu_die Date: Thu, 05 Feb 2015 11:14:30 +0100 [thread overview] Message-ID: <1423131270-24047-1-git-send-email-k.kozlowski@samsung.com> (raw) The complete() should not be used on offlined CPU. Rewrite the wait-complete mechanism with wait_on_bit_timeout(). The CPU triggering hot unplug (e.g. CPU0) will loop until some bit is cleared. In each iteration schedule_timeout() is used with initial sleep time of 1 ms. Later it is increased to 10 ms. The dying CPU will clear the bit which is safe in that context. This fixes following RCU warning on ARMv8 (Exynos 4412, Trats2) during suspend to RAM: [ 31.113925] =============================== [ 31.113928] [ INFO: suspicious RCU usage. ] [ 31.113935] 3.19.0-rc7-next-20150203 #1914 Not tainted [ 31.113938] ------------------------------- [ 31.113943] kernel/sched/fair.c:4740 suspicious rcu_dereference_check() usage! [ 31.113946] [ 31.113946] other info that might help us debug this: [ 31.113946] [ 31.113952] [ 31.113952] RCU used illegally from offline CPU! [ 31.113952] rcu_scheduler_active = 1, debug_locks = 0 [ 31.113957] 3 locks held by swapper/1/0: [ 31.113988] #0: ((cpu_died).wait.lock){......}, at: [<c005a114>] complete+0x14/0x44 [ 31.114012] #1: (&p->pi_lock){-.-.-.}, at: [<c004a790>] try_to_wake_up+0x28/0x300 [ 31.114035] #2: (rcu_read_lock){......}, at: [<c004f1b8>] select_task_rq_fair+0x5c/0xa04 [ 31.114038] [ 31.114038] stack backtrace: [ 31.114046] CPU: 1 PID: 0 Comm: swapper/1 Not tainted 3.19.0-rc7-next-20150203 #1914 [ 31.114050] Hardware name: SAMSUNG EXYNOS (Flattened Device Tree) [ 31.114076] [<c0014ce4>] (unwind_backtrace) from [<c0011c30>] (show_stack+0x10/0x14) [ 31.114091] [<c0011c30>] (show_stack) from [<c04dc048>] (dump_stack+0x70/0xbc) [ 31.114105] [<c04dc048>] (dump_stack) from [<c004f83c>] (select_task_rq_fair+0x6e0/0xa04) [ 31.114118] [<c004f83c>] (select_task_rq_fair) from [<c004a83c>] (try_to_wake_up+0xd4/0x300) [ 31.114129] [<c004a83c>] (try_to_wake_up) from [<c00598a0>] (__wake_up_common+0x4c/0x80) [ 31.114140] [<c00598a0>] (__wake_up_common) from [<c00598e8>] (__wake_up_locked+0x14/0x1c) [ 31.114150] [<c00598e8>] (__wake_up_locked) from [<c005a134>] (complete+0x34/0x44) [ 31.114167] [<c005a134>] (complete) from [<c04d6ca4>] (cpu_die+0x24/0x84) [ 31.114179] [<c04d6ca4>] (cpu_die) from [<c005a508>] (cpu_startup_entry+0x328/0x358) [ 31.114189] [<c005a508>] (cpu_startup_entry) from [<40008784>] (0x40008784) [ 31.114226] CPU1: shutdown Signed-off-by: Krzysztof Kozlowski <k.kozlowski@samsung.com> --- Changes since v1: 1. Use adaptive sleep time when waiting for CPU die (idea and code from Paul E. McKenney). Paul also acked the patch but I made evem more changes. 2. Add another bit (CPU_DIE_TIMEOUT_BIT) for synchronizing power down failure in case: CPU0 (killing) CPUx (killed) wait_for_cpu_die timeout cpu_die() clear_bit() self power down In this case the bit would be cleared and CPU would be powered down introducing wrong behavior in next power down sequence (CPU0 would see the bit cleared). I think that such race is still possible but was narrowed to very short time frame. Any CPU up will reset the bit to proper values. 3. Remove pre-test for bit in wait_for_cpu_die(). Suggested by Stephen Boyd. This leads to more simplification in wait_for_cpu_die() loop. 4. Update comment for second flush_cache_louis() in dying CPU. Suggested by Stephen Boyd. --- arch/arm/kernel/smp.c | 81 +++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 75 insertions(+), 6 deletions(-) diff --git a/arch/arm/kernel/smp.c b/arch/arm/kernel/smp.c index 86ef244c5a24..0f6f1371739d 100644 --- a/arch/arm/kernel/smp.c +++ b/arch/arm/kernel/smp.c @@ -26,6 +26,7 @@ #include <linux/completion.h> #include <linux/cpufreq.h> #include <linux/irq_work.h> +#include <linux/wait.h> #include <linux/atomic.h> #include <asm/smp.h> @@ -76,6 +77,10 @@ enum ipi_msg_type { static DECLARE_COMPLETION(cpu_running); +#define CPU_DIE_WAIT_BIT 0 +#define CPU_DIE_TIMEOUT_BIT 1 +static unsigned long wait_cpu_die; + static struct smp_operations smp_ops; void __init smp_set_ops(struct smp_operations *ops) @@ -133,6 +138,9 @@ int __cpu_up(unsigned int cpu, struct task_struct *idle) pr_err("CPU%u: failed to boot: %d\n", cpu, ret); } + set_bit(CPU_DIE_WAIT_BIT, &wait_cpu_die); + clear_bit(CPU_DIE_TIMEOUT_BIT, &wait_cpu_die); + smp_mb__after_atomic(); memset(&secondary_data, 0, sizeof(secondary_data)); return ret; @@ -213,7 +221,40 @@ int __cpu_disable(void) return 0; } -static DECLARE_COMPLETION(cpu_died); +static inline int wait_on_die_bit_timeout(int sleep_ms) +{ + smp_mb__before_atomic(); + + return out_of_line_wait_on_bit_timeout(&wait_cpu_die, + CPU_DIE_WAIT_BIT, bit_wait_timeout, + TASK_UNINTERRUPTIBLE, + msecs_to_jiffies(sleep_ms)); +} + +/* + * Wait for 5000 ms for 'wait_cpu_die' bit to be cleared. + * Actually the real wait time may be longer because bit_wait_timeout + * calls schedule() in each iteration. + * + * Returns 0 if bit was cleared (CPU died) or non-zero + * otherwise (1 or negative ERRNO). + */ +static int wait_for_cpu_die(void) +{ + int ms_left = 5000, sleep_ms = 1, ret; + + might_sleep(); + + while ((ret = wait_on_die_bit_timeout(sleep_ms))) { + ms_left -= sleep_ms; + if (!ret || (ms_left <= 0)) + break; + + sleep_ms = DIV_ROUND_UP(sleep_ms * 11, 10); + } + + return ret; +} /* * called on the thread which is asking for a CPU to be shutdown - @@ -221,7 +262,9 @@ static DECLARE_COMPLETION(cpu_died); */ void __cpu_die(unsigned int cpu) { - if (!wait_for_completion_timeout(&cpu_died, msecs_to_jiffies(5000))) { + if (wait_for_cpu_die()) { + set_bit(CPU_DIE_TIMEOUT_BIT, &wait_cpu_die); + smp_mb__after_atomic(); pr_err("CPU%u: cpu didn't die\n", cpu); return; } @@ -236,6 +279,11 @@ void __cpu_die(unsigned int cpu) */ if (!platform_cpu_kill(cpu)) pr_err("CPU%u: unable to kill\n", cpu); + + /* Prepare the bit for some next CPU die */ + set_bit(CPU_DIE_WAIT_BIT, &wait_cpu_die); + clear_bit(CPU_DIE_TIMEOUT_BIT, &wait_cpu_die); + smp_mb__after_atomic(); } /* @@ -250,6 +298,8 @@ void __ref cpu_die(void) { unsigned int cpu = smp_processor_id(); + WARN_ON(!test_bit(CPU_DIE_WAIT_BIT, &wait_cpu_die)); + idle_task_exit(); local_irq_disable(); @@ -267,12 +317,23 @@ void __ref cpu_die(void) * this returns, power and/or clocks can be removed at any point * from this CPU and its cache by platform_cpu_kill(). */ - complete(&cpu_died); + clear_bit(CPU_DIE_WAIT_BIT, &wait_cpu_die); + smp_mb__after_atomic(); + + /* + * If killing CPU reached timeout than this thread must set dying bit + * for next power down sequence. + */ + if (test_bit(CPU_DIE_TIMEOUT_BIT, &wait_cpu_die)) { + clear_bit(CPU_DIE_TIMEOUT_BIT, &wait_cpu_die); + set_bit(CPU_DIE_WAIT_BIT, &wait_cpu_die); + smp_mb__after_atomic(); + } /* - * Ensure that the cache lines associated with that completion are - * written out. This covers the case where _this_ CPU is doing the - * powering down, to ensure that the completion is visible to the + * Ensure that the cache lines associated with clearing 'wait_cpu_die' + * bit are written out. This covers the case where _this_ CPU is doing + * the powering down, to ensure that the bit clearing is visible to the * CPU waiting for this one. */ flush_cache_louis(); @@ -296,6 +357,14 @@ void __ref cpu_die(void) cpu); /* + * There is a chance that the killing CPU reached time out in + * __cpu_die() so set the bit for next power down sequence. + */ + set_bit(CPU_DIE_WAIT_BIT, &wait_cpu_die); + clear_bit(CPU_DIE_TIMEOUT_BIT, &wait_cpu_die); + smp_mb__after_atomic(); + + /* * Do not return to the idle loop - jump back to the secondary * cpu initialisation. There's some initialisation which needs * to be repeated to undo the effects of taking the CPU offline. -- 1.9.1
WARNING: multiple messages have this Message-ID (diff)
From: k.kozlowski@samsung.com (Krzysztof Kozlowski) To: linux-arm-kernel@lists.infradead.org Subject: [PATCH v2] ARM: Don't use complete() during __cpu_die Date: Thu, 05 Feb 2015 11:14:30 +0100 [thread overview] Message-ID: <1423131270-24047-1-git-send-email-k.kozlowski@samsung.com> (raw) The complete() should not be used on offlined CPU. Rewrite the wait-complete mechanism with wait_on_bit_timeout(). The CPU triggering hot unplug (e.g. CPU0) will loop until some bit is cleared. In each iteration schedule_timeout() is used with initial sleep time of 1 ms. Later it is increased to 10 ms. The dying CPU will clear the bit which is safe in that context. This fixes following RCU warning on ARMv8 (Exynos 4412, Trats2) during suspend to RAM: [ 31.113925] =============================== [ 31.113928] [ INFO: suspicious RCU usage. ] [ 31.113935] 3.19.0-rc7-next-20150203 #1914 Not tainted [ 31.113938] ------------------------------- [ 31.113943] kernel/sched/fair.c:4740 suspicious rcu_dereference_check() usage! [ 31.113946] [ 31.113946] other info that might help us debug this: [ 31.113946] [ 31.113952] [ 31.113952] RCU used illegally from offline CPU! [ 31.113952] rcu_scheduler_active = 1, debug_locks = 0 [ 31.113957] 3 locks held by swapper/1/0: [ 31.113988] #0: ((cpu_died).wait.lock){......}, at: [<c005a114>] complete+0x14/0x44 [ 31.114012] #1: (&p->pi_lock){-.-.-.}, at: [<c004a790>] try_to_wake_up+0x28/0x300 [ 31.114035] #2: (rcu_read_lock){......}, at: [<c004f1b8>] select_task_rq_fair+0x5c/0xa04 [ 31.114038] [ 31.114038] stack backtrace: [ 31.114046] CPU: 1 PID: 0 Comm: swapper/1 Not tainted 3.19.0-rc7-next-20150203 #1914 [ 31.114050] Hardware name: SAMSUNG EXYNOS (Flattened Device Tree) [ 31.114076] [<c0014ce4>] (unwind_backtrace) from [<c0011c30>] (show_stack+0x10/0x14) [ 31.114091] [<c0011c30>] (show_stack) from [<c04dc048>] (dump_stack+0x70/0xbc) [ 31.114105] [<c04dc048>] (dump_stack) from [<c004f83c>] (select_task_rq_fair+0x6e0/0xa04) [ 31.114118] [<c004f83c>] (select_task_rq_fair) from [<c004a83c>] (try_to_wake_up+0xd4/0x300) [ 31.114129] [<c004a83c>] (try_to_wake_up) from [<c00598a0>] (__wake_up_common+0x4c/0x80) [ 31.114140] [<c00598a0>] (__wake_up_common) from [<c00598e8>] (__wake_up_locked+0x14/0x1c) [ 31.114150] [<c00598e8>] (__wake_up_locked) from [<c005a134>] (complete+0x34/0x44) [ 31.114167] [<c005a134>] (complete) from [<c04d6ca4>] (cpu_die+0x24/0x84) [ 31.114179] [<c04d6ca4>] (cpu_die) from [<c005a508>] (cpu_startup_entry+0x328/0x358) [ 31.114189] [<c005a508>] (cpu_startup_entry) from [<40008784>] (0x40008784) [ 31.114226] CPU1: shutdown Signed-off-by: Krzysztof Kozlowski <k.kozlowski@samsung.com> --- Changes since v1: 1. Use adaptive sleep time when waiting for CPU die (idea and code from Paul E. McKenney). Paul also acked the patch but I made evem more changes. 2. Add another bit (CPU_DIE_TIMEOUT_BIT) for synchronizing power down failure in case: CPU0 (killing) CPUx (killed) wait_for_cpu_die timeout cpu_die() clear_bit() self power down In this case the bit would be cleared and CPU would be powered down introducing wrong behavior in next power down sequence (CPU0 would see the bit cleared). I think that such race is still possible but was narrowed to very short time frame. Any CPU up will reset the bit to proper values. 3. Remove pre-test for bit in wait_for_cpu_die(). Suggested by Stephen Boyd. This leads to more simplification in wait_for_cpu_die() loop. 4. Update comment for second flush_cache_louis() in dying CPU. Suggested by Stephen Boyd. --- arch/arm/kernel/smp.c | 81 +++++++++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 75 insertions(+), 6 deletions(-) diff --git a/arch/arm/kernel/smp.c b/arch/arm/kernel/smp.c index 86ef244c5a24..0f6f1371739d 100644 --- a/arch/arm/kernel/smp.c +++ b/arch/arm/kernel/smp.c @@ -26,6 +26,7 @@ #include <linux/completion.h> #include <linux/cpufreq.h> #include <linux/irq_work.h> +#include <linux/wait.h> #include <linux/atomic.h> #include <asm/smp.h> @@ -76,6 +77,10 @@ enum ipi_msg_type { static DECLARE_COMPLETION(cpu_running); +#define CPU_DIE_WAIT_BIT 0 +#define CPU_DIE_TIMEOUT_BIT 1 +static unsigned long wait_cpu_die; + static struct smp_operations smp_ops; void __init smp_set_ops(struct smp_operations *ops) @@ -133,6 +138,9 @@ int __cpu_up(unsigned int cpu, struct task_struct *idle) pr_err("CPU%u: failed to boot: %d\n", cpu, ret); } + set_bit(CPU_DIE_WAIT_BIT, &wait_cpu_die); + clear_bit(CPU_DIE_TIMEOUT_BIT, &wait_cpu_die); + smp_mb__after_atomic(); memset(&secondary_data, 0, sizeof(secondary_data)); return ret; @@ -213,7 +221,40 @@ int __cpu_disable(void) return 0; } -static DECLARE_COMPLETION(cpu_died); +static inline int wait_on_die_bit_timeout(int sleep_ms) +{ + smp_mb__before_atomic(); + + return out_of_line_wait_on_bit_timeout(&wait_cpu_die, + CPU_DIE_WAIT_BIT, bit_wait_timeout, + TASK_UNINTERRUPTIBLE, + msecs_to_jiffies(sleep_ms)); +} + +/* + * Wait for 5000 ms for 'wait_cpu_die' bit to be cleared. + * Actually the real wait time may be longer because bit_wait_timeout + * calls schedule() in each iteration. + * + * Returns 0 if bit was cleared (CPU died) or non-zero + * otherwise (1 or negative ERRNO). + */ +static int wait_for_cpu_die(void) +{ + int ms_left = 5000, sleep_ms = 1, ret; + + might_sleep(); + + while ((ret = wait_on_die_bit_timeout(sleep_ms))) { + ms_left -= sleep_ms; + if (!ret || (ms_left <= 0)) + break; + + sleep_ms = DIV_ROUND_UP(sleep_ms * 11, 10); + } + + return ret; +} /* * called on the thread which is asking for a CPU to be shutdown - @@ -221,7 +262,9 @@ static DECLARE_COMPLETION(cpu_died); */ void __cpu_die(unsigned int cpu) { - if (!wait_for_completion_timeout(&cpu_died, msecs_to_jiffies(5000))) { + if (wait_for_cpu_die()) { + set_bit(CPU_DIE_TIMEOUT_BIT, &wait_cpu_die); + smp_mb__after_atomic(); pr_err("CPU%u: cpu didn't die\n", cpu); return; } @@ -236,6 +279,11 @@ void __cpu_die(unsigned int cpu) */ if (!platform_cpu_kill(cpu)) pr_err("CPU%u: unable to kill\n", cpu); + + /* Prepare the bit for some next CPU die */ + set_bit(CPU_DIE_WAIT_BIT, &wait_cpu_die); + clear_bit(CPU_DIE_TIMEOUT_BIT, &wait_cpu_die); + smp_mb__after_atomic(); } /* @@ -250,6 +298,8 @@ void __ref cpu_die(void) { unsigned int cpu = smp_processor_id(); + WARN_ON(!test_bit(CPU_DIE_WAIT_BIT, &wait_cpu_die)); + idle_task_exit(); local_irq_disable(); @@ -267,12 +317,23 @@ void __ref cpu_die(void) * this returns, power and/or clocks can be removed@any point * from this CPU and its cache by platform_cpu_kill(). */ - complete(&cpu_died); + clear_bit(CPU_DIE_WAIT_BIT, &wait_cpu_die); + smp_mb__after_atomic(); + + /* + * If killing CPU reached timeout than this thread must set dying bit + * for next power down sequence. + */ + if (test_bit(CPU_DIE_TIMEOUT_BIT, &wait_cpu_die)) { + clear_bit(CPU_DIE_TIMEOUT_BIT, &wait_cpu_die); + set_bit(CPU_DIE_WAIT_BIT, &wait_cpu_die); + smp_mb__after_atomic(); + } /* - * Ensure that the cache lines associated with that completion are - * written out. This covers the case where _this_ CPU is doing the - * powering down, to ensure that the completion is visible to the + * Ensure that the cache lines associated with clearing 'wait_cpu_die' + * bit are written out. This covers the case where _this_ CPU is doing + * the powering down, to ensure that the bit clearing is visible to the * CPU waiting for this one. */ flush_cache_louis(); @@ -296,6 +357,14 @@ void __ref cpu_die(void) cpu); /* + * There is a chance that the killing CPU reached time out in + * __cpu_die() so set the bit for next power down sequence. + */ + set_bit(CPU_DIE_WAIT_BIT, &wait_cpu_die); + clear_bit(CPU_DIE_TIMEOUT_BIT, &wait_cpu_die); + smp_mb__after_atomic(); + + /* * Do not return to the idle loop - jump back to the secondary * cpu initialisation. There's some initialisation which needs * to be repeated to undo the effects of taking the CPU offline. -- 1.9.1
next reply other threads:[~2015-02-05 10:14 UTC|newest] Thread overview: 92+ messages / expand[flat|nested] mbox.gz Atom feed top 2015-02-05 10:14 Krzysztof Kozlowski [this message] 2015-02-05 10:14 ` [PATCH v2] ARM: Don't use complete() during __cpu_die Krzysztof Kozlowski 2015-02-05 10:50 ` Russell King - ARM Linux 2015-02-05 10:50 ` Russell King - ARM Linux 2015-02-05 11:00 ` Krzysztof Kozlowski 2015-02-05 11:00 ` Krzysztof Kozlowski 2015-02-05 11:08 ` Russell King - ARM Linux 2015-02-05 11:08 ` Russell King - ARM Linux 2015-02-05 11:28 ` Mark Rutland 2015-02-05 11:28 ` Mark Rutland 2015-02-05 11:30 ` Russell King - ARM Linux 2015-02-05 11:30 ` Russell King - ARM Linux 2015-02-05 14:29 ` Paul E. McKenney 2015-02-05 14:29 ` Paul E. McKenney 2015-02-05 16:11 ` Russell King - ARM Linux 2015-02-05 16:11 ` Russell King - ARM Linux 2015-02-05 17:02 ` Paul E. McKenney 2015-02-05 17:02 ` Paul E. McKenney 2015-02-05 17:34 ` Russell King - ARM Linux 2015-02-05 17:34 ` Russell King - ARM Linux 2015-02-05 17:54 ` Paul E. McKenney 2015-02-05 17:54 ` Paul E. McKenney 2015-02-10 1:24 ` Stephen Boyd 2015-02-10 1:24 ` Stephen Boyd 2015-02-10 1:37 ` Paul E. McKenney 2015-02-10 1:37 ` Paul E. McKenney 2015-02-10 2:05 ` Stephen Boyd 2015-02-10 2:05 ` Stephen Boyd 2015-02-10 3:05 ` Paul E. McKenney 2015-02-10 3:05 ` Paul E. McKenney 2015-02-10 15:14 ` Mark Rutland 2015-02-10 15:14 ` Mark Rutland 2015-02-10 20:48 ` Stephen Boyd 2015-02-10 20:48 ` Stephen Boyd 2015-02-10 21:04 ` Stephen Boyd 2015-02-10 21:04 ` Stephen Boyd 2015-02-10 21:15 ` Russell King - ARM Linux 2015-02-10 21:15 ` Russell King - ARM Linux 2015-02-10 21:49 ` Stephen Boyd 2015-02-10 21:49 ` Stephen Boyd 2015-02-10 22:05 ` Stephen Boyd 2015-02-10 22:05 ` Stephen Boyd 2015-02-13 15:52 ` Mark Rutland 2015-02-13 15:52 ` Mark Rutland 2015-02-13 16:27 ` Russell King - ARM Linux 2015-02-13 16:27 ` Russell King - ARM Linux 2015-02-13 17:21 ` Mark Rutland 2015-02-13 17:21 ` Mark Rutland 2015-02-13 17:30 ` Russell King - ARM Linux 2015-02-13 17:30 ` Russell King - ARM Linux 2015-02-13 16:28 ` Stephen Boyd 2015-02-13 16:28 ` Stephen Boyd 2015-02-13 15:38 ` Mark Rutland 2015-02-13 15:38 ` Mark Rutland 2015-02-10 20:58 ` Russell King - ARM Linux 2015-02-10 20:58 ` Russell King - ARM Linux 2015-02-10 15:41 ` Russell King - ARM Linux 2015-02-10 15:41 ` Russell King - ARM Linux 2015-02-10 18:33 ` Stephen Boyd 2015-02-10 18:33 ` Stephen Boyd 2015-02-25 12:56 ` Russell King - ARM Linux 2015-02-25 12:56 ` Russell King - ARM Linux 2015-02-25 16:47 ` Nicolas Pitre 2015-02-25 16:47 ` Nicolas Pitre 2015-02-25 17:00 ` Russell King - ARM Linux 2015-02-25 17:00 ` Russell King - ARM Linux 2015-02-25 18:13 ` Nicolas Pitre 2015-02-25 18:13 ` Nicolas Pitre 2015-02-25 20:16 ` Nicolas Pitre 2015-02-25 20:16 ` Nicolas Pitre 2015-02-26 1:05 ` Paul E. McKenney 2015-02-26 1:05 ` Paul E. McKenney 2015-03-22 23:30 ` Paul E. McKenney 2015-03-22 23:30 ` Paul E. McKenney 2015-03-23 12:55 ` Russell King - ARM Linux 2015-03-23 12:55 ` Russell King - ARM Linux 2015-03-23 13:21 ` Paul E. McKenney 2015-03-23 13:21 ` Paul E. McKenney 2015-03-23 14:00 ` Russell King - ARM Linux 2015-03-23 14:00 ` Russell King - ARM Linux 2015-03-23 15:37 ` Paul E. McKenney 2015-03-23 15:37 ` Paul E. McKenney 2015-03-23 16:56 ` Paul E. McKenney 2015-03-23 16:56 ` Paul E. McKenney 2015-02-26 19:14 ` Daniel Thompson 2015-02-26 19:14 ` Daniel Thompson 2015-02-26 19:47 ` Nicolas Pitre 2015-02-26 19:47 ` Nicolas Pitre 2015-02-05 10:53 ` Mark Rutland 2015-02-05 10:53 ` Mark Rutland 2015-02-05 10:59 ` Krzysztof Kozlowski 2015-02-05 10:59 ` Krzysztof Kozlowski
Reply instructions: You may reply publicly 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=1423131270-24047-1-git-send-email-k.kozlowski@samsung.com \ --to=k.kozlowski@samsung.com \ --cc=arnd@arndb.de \ --cc=b.zolnierkie@samsung.com \ --cc=catalin.marinas@arm.com \ --cc=linux-arm-kernel@lists.infradead.org \ --cc=linux-kernel@vger.kernel.org \ --cc=linux@arm.linux.org.uk \ --cc=m.szyprowski@samsung.com \ --cc=mark.rutland@arm.com \ --cc=paulmck@linux.vnet.ibm.com \ --cc=sboyd@codeaurora.org \ --cc=will.deacon@arm.com \ /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: linkBe sure your reply has a Subject: header at the top and a blank line before the message body.
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.