Linux 3.10.32-rt31-rc1
Subsystems (6)
cover Linux 3.10.32-rt31-rc1
Dear RT Folks,
This is the RT stable review cycle of patch 3.10.32-rt31-rc1.
Please scream at me if I messed something up. Please test the patches too.
The -rc release will be uploaded to kernel.org and will be deleted when the final release is out. This is just a review release (or release candidate).
The pre-releases will not be pushed to the git repository, only the final release is.
If all goes well, this patch will be converted to the next main release on 3/3/2014.
Enjoy,
-- Steve
To build 3.10.32-rt31-rc1 directly, the following patches should be applied:
http://www.kernel.org/pub/linux/kernel/v3.x/linux-3.10.tar.xz
http://www.kernel.org/pub/linux/kernel/v3.x/patch-3.10.32.xz
http://www.kernel.org/pub/linux/kernel/projects/rt/3.10/patch-3.10.32-rt31-rc1.patch.xz
You can also build from 3.10.32-rt30 by applying the incremental patch:
http://www.kernel.org/pub/linux/kernel/projects/rt/3.10/incr/patch-3.10.32-rt30-rt31-rc1.patch.xz
Changes from 3.10.32-rt30:
---
Nicholas Mc Guire (1):
net: ip_send_unicast_reply: add missing local serialization
Sebastian Andrzej Siewior (4):
Revert "x86: Disable IST stacks for debug/int 3/stack fault for PREEMPT_RT" kernel/hrtimer: be non-freezeable in cpu_chill()
arm/unwind: use a raw_spin_lock
leds: trigger: disable CPU trigger on -RT
Steven Rostedt (3):
timer: Raise softirq if there's irq_work
timer/rt: Always raise the softirq if there's irq_work to be done
rt: Make cpu_chill() use hrtimer instead of msleep()
Steven Rostedt (Red Hat) (1):
Linux 3.10.32-rt31-rc1
Thomas Gleixner (1):
timers: do not raise softirq unconditionally
Tiejun Chen (1):
rcutree/rcu_bh_qs: disable irq while calling rcu_preempt_qs()
----
arch/arm/kernel/unwind.c | 14 +++++----- arch/x86/include/asm/page_64_types.h | 21 +++++---------- arch/x86/kernel/cpu/common.c | 2 -- arch/x86/kernel/dumpstack_64.c | 4 --- drivers/leds/trigger/Kconfig | 2 +- include/linux/delay.h | 2 +- include/linux/hrtimer.h | 3 +-- kernel/hrtimer.c | 50 +++++++++++++++++++----------------- kernel/rcutree.c | 5 ++++ kernel/timer.c | 35 ++++++++++++++++++++++--- localversion-rt | 2 +- net/ipv4/ip_output.c | 9 ++++--- 12 files changed, 86 insertions(+), 63 deletions(-)
PATCH 1/11 timers: do not raise softirq unconditionally
3.10.32-rt31-rc1 stable review patch.
If anyone has any objections, please let me know.
------------------
From: Thomas Gleixner <[email protected]>
Mike,
Quoted 6 lines · Mike Galbraith
Quoted 5 lines · Mike Galbraith
Quoted 2 lines · Thomas Gleixner
I bet you are trying to work around some of the side effects of the occasional tick which is still necessary despite of full nohz, right?
Quoted 8 lines
Quoted 4 lines
Nope, I wanted to check out cost of
nohz_fullfor rt, and found that it doesn't work at all instead, looked, and found that the sole running task has just awakened ksoftirqd when it wants to shut the tick down, so that shutdown never happens.Like so in virgin 3.10-rt. Box is x3550 M3 booted nowatchdog rcu_nocbs=1-3 nohz_full=1-3, and CPUs1-3 are completely isolated via cpusets as well.
well, that very same problem is in mainline if you add "threadirqs" to the command line. But we can be smart about this. The untested patch below should address that issue. If that works on mainline we can adapt it for RT (needs a trylock(&base->lock) there).
Though it's not a full solution. It needs some thought versus the softirq code of timers. Assume we have only one timer queued 1000 ticks into the future. So this change will cause the timer softirq not to be called until that timer expires and then the timer softirq is going to do 1000 loops until it catches up with jiffies. That's anything but pretty ...
What worries me more is this one:
pert-5229 [003] d..h1.. 684.482618: softirq_raise: vec=9 [action=RCU]
The CPU has no callbacks as you shoved them over to cpu 0, so why is the RCU softirq raised?
Thanks,
tglx
------------------
Message-id: <[email protected]> |CONFIG_NO_HZ_FULL + CONFIG_PREEMPT_RT_FULL = nogo
--- include/linux/hrtimer.h | 3 +-- kernel/hrtimer.c | 31 +++++++------------------------ kernel/timer.c | 28 +++++++++++++++++++++++++--- 3 files changed, 33 insertions(+), 29 deletions(-)
include/linux/hrtimer.h +1 -2
@@ -461,9 +461,8 @@ extern int schedule_hrtimeout_range_clock(ktime_t *expires, unsigned long delta, const enum hrtimer_mode mode, int clock);extern int schedule_hrtimeout (ktime_t *expires,const enum hrtimer_mode mode); -/* Soft interrupt function to run the hrtimer queues: */ +/* Called from the periodic timer tick */ extern void hrtimer_run_queues (void ); -extern void hrtimer_run_pending (void );/* Bootup initialization: */ extern void __init hrtimers_init (void );
kernel/hrtimer.c +7 -24
@@ -1691,30 +1691,6 @@ static void run_hrtimer_softirq(struct softirq_action *h) }/* -* Called from timer softirq every jiffy, expire hrtimers: -* -* For HRT its the fall back code to run the softirq in the timer -* softirq context in case the hrtimer initialization failed or has -* not been done yet. -*/ -void hrtimer_run_pending (void ) -{ -if (hrtimer_hres_active ()) -return ; - -/* -* This _is_ ugly: We have to check in the softirq context, -* whether we can switch to highres and / or nohz mode. The -* clocksource switch happens in the timer interrupt with -* xtime_lock held. Notification from there only sets the -* check bit in the tick_oneshot code, otherwise we might -* deadlock vs. xtime_lock. -*/ -if (tick_check_oneshot_change (!hrtimer_is_hres_enabled ())) -hrtimer_switch_to_hres (); -} - -/* * Called from hardirq context every jiffy */ void hrtimer_run_queues (void )
@@ -1727,6 +1703,13 @@ void hrtimer_run_queues(void)if (hrtimer_hres_active ())return ; +/* +* Check whether we can switch to highres mode. +*/ +if (tick_check_oneshot_change (!hrtimer_is_hres_enabled ()) + &&hrtimer_switch_to_hres ()) +return ; +for (index =0 ; index <HRTIMER_MAX_CLOCK_BASES ; index++) { base = &cpu_base->clock_base[index];if (!timerqueue_getnext (&base->active))
kernel/timer.c +25 -3
@@ -1443,8 +1443,6 @@ static void run_timer_softirq(struct softirq_action *h)irq_work_run ();#endif -hrtimer_run_pending (); -if (time_after_eq (jiffies, base->timer_jiffies))__run_timers (base); }
@@ -1454,8 +1452,32 @@ static void run_timer_softirq(struct softirq_action *h)*/ void run_local_timers (void ) { +struct tvec_base *base =__this_cpu_read (tvec_bases); +hrtimer_run_queues (); -raise_softirq (TIMER_SOFTIRQ ); +/* +* We can access this lockless as we are in the timer +* interrupt. If there are no timers queued, nothing to do in +* the timer softirq. +*/ +#ifdef CONFIG_PREEMPT_RT_FULL +if (!spin_do_trylock (&base->lock)) { +raise_softirq (TIMER_SOFTIRQ ); +return ; + } +#endif +if (!base->active_timers) + goto out; + +/* Check whether the next pending timer has expired */ +if (time_before_eq (base->next_timer, jiffies)) +raise_softirq (TIMER_SOFTIRQ ); +out: +#ifdef CONFIG_PREEMPT_RT_FULL +rt_spin_unlock_after_trylock_in_irq (&base->lock); +#endif +/* The ; ensures that gcc won't complain in the !RT case */ + ; }#ifdef __ARCH_WANT_SYS_ALARM
Signature · 1 line
1.8.5.3
PATCH 2/11 timer: Raise softirq if theres irq_work
In reply to Steven Rostedt3.10.32-rt31-rc1 stable review patch.
If anyone has any objections, please let me know.
------------------
From: Steven Rostedt <[email protected]>
[ Talking with Sebastian on IRC, it seems that doing the irq_work_run()
from the interrupt in -rt is a bad thing. Here we simply raise the softirq if there's irq work to do. This too boots on my i7 ]
After trying hard to figure out why my i7 box was locking up with the new active_timers code, that does not run the timer softirq if there are no active timers, I took an extra look at the softirq handler and noticed that it doesn't just run timer softirqs, it also runs irq work.
This was the bug that was locking up the system. It wasn't missing a timer, it was missing irq work. By always doing the irq work callbacks, the system boots fine. The missing irq work callback was the RCU's sp_wakeup() function.
No need to check for defined(CONFIG_IRQ_WORK). When that's not set the "irq_work_needs_cpu()" is a static inline that returns false.
--- kernel/timer.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
kernel/timer.c +7 -2
@@ -1466,8 +1466,13 @@ void run_local_timers(void)return ; }#endif -if (!base->active_timers) - goto out; +if (!base->active_timers) { +#ifdef CONFIG_PREEMPT_RT_FULL +/* On RT, irq work runs from softirq */ + if (!irq_work_needs_cpu()) +#endif + goto out; + }/* Check whether the next pending timer has expired */ if (time_before_eq (base->next_timer, jiffies))
Signature · 1 line
1.8.5.3
PATCH 3/11 timer/rt: Always raise the softirq if theres irq_work to be done
In reply to Steven Rostedt3.10.32-rt31-rc1 stable review patch.
If anyone has any objections, please let me know.
------------------
From: Steven Rostedt <[email protected]>
It was previously discovered that some systems would hang on boot up with a previous version of 3.12-rt. This was due to RCU using irq_work, and RT defers the irq_work to a softirq. But if there's no active timers, the softirq will not be raised, and RCU work will not get done, causing the system to hang. The fix was to check that if there was no active timers but irq_work to be done, then we should raise the softirq.
But this fix was not 100% correct. It left out the case that there were active timers that were not expired yet. This would have the softirq not get raised even if there was irq work to be done.
If there is irq_work to be done, then we must raise the timer softirq regardless of if there is active timers or whether they are expired or not. The softirq can handle those cases. But we can never ignore irq_work.
As it is only PREEMPT_RT_FULL that requires irq_work to be done in the softirq, we can pull out the check in the active_timers condition, and make the code a bit cleaner by having the irq_work check separate, and put the code in with the other #ifdef PREEMPT_RT. If there is irq_work to be done, there's no need to check the active timers or if they are expired. Just raise the time softirq and be done with it. Otherwise, we can do the timer checks just like we do with non -rt.
--- kernel/timer.c | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-)
kernel/timer.c +9 -7
@@ -1461,18 +1461,20 @@ void run_local_timers(void)* the timer softirq. */ #ifdef CONFIG_PREEMPT_RT_FULL +/* On RT, irq work runs from softirq */ +if (irq_work_needs_cpu ()) { +raise_softirq (TIMER_SOFTIRQ ); +return ; + } +if (!spin_do_trylock (&base->lock)) {raise_softirq (TIMER_SOFTIRQ );return ; }#endif -if (!base->active_timers) { -#ifdef CONFIG_PREEMPT_RT_FULL -/* On RT, irq work runs from softirq */ - if (!irq_work_needs_cpu()) -#endif - goto out; - } + +if (!base->active_timers) + goto out;/* Check whether the next pending timer has expired */ if (time_before_eq (base->next_timer, jiffies))
Signature · 1 line
1.8.5.3
PATCH 4/11 rcutree/rcu_bh_qs: disable irq while calling rcu_preempt_qs()
In reply to Steven Rostedt3.10.32-rt31-rc1 stable review patch.
If anyone has any objections, please let me know.
------------------
From: Tiejun Chen <[email protected]>
Any callers to the function rcu_preempt_qs() must disable irqs in order to protect the assignment to ->rcu_read_unlock_special. In RT case, rcu_bh_qs() as the wrapper of rcu_preempt_qs() is called in some scenarios where irq is enabled, like this path,
do_single_softirq()
|
+ local_irq_enable();
+ handle_softirq()
| |
| + rcu_bh_qs()
| |
| + rcu_preempt_qs()
|
+ local_irq_disable()
So here we'd better disable irq directly inside of rcu_bh_qs() to fix this, otherwise the kernel may be freezable sometimes as observed. And especially this way is also kind and safe for the potential rcu_bh_qs() usage elsewhere in the future.
--- kernel/rcutree.c | 5 +++++ 1 file changed, 5 insertions(+)
kernel/rcutree.c +5 -0
@@ -187,7 +187,12 @@ static void rcu_preempt_qs(int cpu);void rcu_bh_qs (int cpu) { +unsigned long flags; + +/* Callers to this function, rcu_preempt_qs(), must disable irqs. */ +local_irq_save (flags);rcu_preempt_qs (cpu); +local_irq_restore (flags); }#else void rcu_bh_qs (int cpu)
Signature · 1 line
1.8.5.3
PATCH 5/11 Revert "x86: Disable IST stacks for debug/int 3/stack fault for PREEMPT_RT"
In reply to Steven Rostedt3.10.32-rt31-rc1 stable review patch.
If anyone has any objections, please let me know.
------------------
From: Sebastian Andrzej Siewior <[email protected]>
where do I start. Let me explain what is going on here. The code sequence
| pushf | pop %edx | or $0x1,%dh | push %edx | mov $0xe0,%eax | popf | sysenter
triggers the bug. On 64bit kernel we see the double fault (with 32bit and 64bit userland) and on 32bit kernel there is no problem. The reporter said that double fault does not happen on 64bit kernel with 64bit userland and this is because in that case the VDSO uses the "syscall" interface instead of "sysenter".
The bug. "popf" loads the flags with the TF bit set which enables "single stepping" and this leads to a debug exception. Usually on 64bit we have a special IST stack for the debug exception. Due to patch [0] we do not use the IST stack but the kernel stack instead. On 64bit the sysenter instruction starts in kernel with the stack address NULL. The code sequence above enters the debug exception (TF flag) after the sysenter instruction was executed which sets the stack pointer to NULL and we have a fault (it seems that the debug exception saves some bytes on the stack).
To fix the double fault I'm going to drop patch [0]. It is completely pointless. In do_debug() and do_stack_segment() we disable preemption which means the task can't leave the CPU. So it does not matter if we run on IST or on kernel stack.
There is a patch [1] which drops preempt_disable() call for a 32bit kernel but not for 64bit so there should be no regression. And [1] seems valid even for this code sequence. We enter the debug exception with a 256bytes long per cpu stack and migrate to the kernel stack before calling do_debug().
[0] x86-disable-debug-stack.patch
[1] fix-rt-int3-x86_32-3.2-rt.patch
--- arch/x86/include/asm/page_64_types.h | 21 ++++++--------------- arch/x86/kernel/cpu/common.c | 2 -- arch/x86/kernel/dumpstack_64.c | 4 ---- 3 files changed, 6 insertions(+), 21 deletions(-)
arch/x86/include/asm/page_64_types.h +6 -15
@@ -14,21 +14,12 @@#define IRQ_STACK_ORDER 2#define IRQ_STACK_SIZE (PAGE_SIZE << IRQ_STACK_ORDER) -#ifdef CONFIG_PREEMPT_RT_FULL -# define STACKFAULT_STACK 0 -# define DOUBLEFAULT_STACK 1 -# define NMI_STACK 2 -# define DEBUG_STACK 0 -# define MCE_STACK 3 -# define N_EXCEPTION_STACKS 3/* hw limit: 7 */ -#else -# define STACKFAULT_STACK 1 -# define DOUBLEFAULT_STACK 2 -# define NMI_STACK 3 -# define DEBUG_STACK 4 -# define MCE_STACK 5 -# define N_EXCEPTION_STACKS 5/* hw limit: 7 */ -#endif +#define STACKFAULT_STACK 1 +#define DOUBLEFAULT_STACK 2 +#define NMI_STACK 3 +#define DEBUG_STACK 4 +#define MCE_STACK 5 +#define N_EXCEPTION_STACKS 5/* hw limit: 7 */ #define PUD_PAGE_SIZE (_AC(1, UL) << PUD_SHIFT)#define PUD_PAGE_MASK (~(PUD_PAGE_SIZE-1))
arch/x86/kernel/cpu/common.c +0 -2
@@ -1109,9 +1109,7 @@ DEFINE_PER_CPU(struct task_struct *, fpu_owner_task);*/ static const unsigned int exception_stack_sizes[N_EXCEPTION_STACKS ] = { [0 ...N_EXCEPTION_STACKS -1 ] =EXCEPTION_STKSZ , -#if DEBUG_STACK > 0 [DEBUG_STACK -1 ] =DEBUG_STKSZ -#endif }; static DEFINE_PER_CPU_PAGE_ALIGNED(char, exception_stacks
arch/x86/kernel/dumpstack_64.c +0 -4
@@ -21,14 +21,10 @@ (N_EXCEPTION_STACKS + DEBUG_STKSZ/EXCEPTION_STKSZ - 2)static char x86_stack_ids[][8 ] = { -#if DEBUG_STACK > 0 [DEBUG_STACK -1 ] ="#DB" , -#endif [NMI_STACK -1 ] ="NMI" , [DOUBLEFAULT_STACK -1 ] ="#DF" , -#if STACKFAULT_STACK > 0 [STACKFAULT_STACK -1 ] ="#SS" , -#endif [MCE_STACK -1 ] ="#MC" , #if DEBUG_STKSZ > EXCEPTION_STKSZ [ N_EXCEPTION_STACKS ...
Signature · 1 line
1.8.5.3
PATCH 6/11 rt: Make cpu_chill() use hrtimer instead of msleep()
In reply to Steven Rostedt3.10.32-rt31-rc1 stable review patch.
If anyone has any objections, please let me know.
------------------
From: Steven Rostedt <[email protected]>
Ulrich Obergfell pointed out that cpu_chill() calls msleep() which is woken up by the ksoftirqd running the TIMER softirq. But as the cpu_chill() is called from softirq context, it may block the ksoftirqd() from running, in which case, it may never wake up the msleep() causing the deadlock.
I checked the vmcore, and irq/74-qla2xxx is stuck in the msleep() call, running on CPU 8. The one ksoftirqd that is stuck, happens to be the one that runs on CPU 8, and it is blocked on a lock held by irq/74-qla2xxx. As that ksoftirqd is the one that will wake up irq/74-qla2xxx, and it happens to be blocked on a lock that irq/74-qla2xxx holds, we have our deadlock.
The solution is not to convert the cpu_chill() back to a cpu_relax() as that will re-create a possible live lock that the cpu_chill() fixed earlier, and may also leave this bug open on other softirqs. The fix is to remove the dependency on ksoftirqd from cpu_chill(). That is, instead of calling msleep() that requires ksoftirqd to wake it up, use the hrtimer_nanosleep() code that does the wakeup from hard irq context.
|Looks to be the lock of the block softirq. I don't have the core dump |anymore, but from what I could tell the ksoftirqd was blocked on the |block softirq lock, where the block softirq handler did a msleep |(called by the qla2xxx interrupt handler). | |Looking at trigger_softirq() in block/blk-softirq.c, it can do a |smp_callfunction() to another cpu to run the block softirq. If that |happens to be the cpu where the qla2xx irq handler is doing the block |softirq and is in a middle of a msleep(), I believe the ksoftirqd will |try to run the softirq. If it does that, then BOOM, it's deadlocked |because the ksoftirqd will never run the timer softirq either.
|I should have also stated that it was only one lock that was involved. |But the lock owner was doing a msleep() that requires a wakeup by |ksoftirqd to continue. If ksoftirqd happens to be blocked on a lock |held by the msleep() caller, then you have your deadlock. | |It's best not to have any softirqs going to sleep requiring another |softirq to wake it up. Note, if we ever require a timer softirq to do a |cpu_chill() it will most definitely hit this deadlock.
--- include/linux/delay.h | 2 +- kernel/hrtimer.c | 15 +++++++++++++++ 2 files changed, 16 insertions(+), 1 deletion(-)
include/linux/delay.h +1 -1
@@ -53,7 +53,7 @@ static inline void ssleep(unsigned int seconds) }#ifdef CONFIG_PREEMPT_RT_FULL -# define cpu_chill () msleep(1) +extern void cpu_chill (void );#else # define cpu_chill () cpu_relax()#endif
kernel/hrtimer.c +15 -0
@@ -1887,6 +1887,21 @@ SYSCALL_DEFINE2(nanosleep, struct timespec __user *, rqtp,return hrtimer_nanosleep (&tu, rmtp,HRTIMER_MODE_REL ,CLOCK_MONOTONIC ); } +#ifdef CONFIG_PREEMPT_RT_FULL +/* +* Sleep for 1 ms in hope whoever holds what we want will let it go. +*/ +void cpu_chill (void ) +{ +struct timespec tu = { + .tv_nsec =NSEC_PER_MSEC , + }; + +hrtimer_nanosleep (&tu,NULL ,HRTIMER_MODE_REL ,CLOCK_MONOTONIC ); +} +EXPORT_SYMBOL (cpu_chill); +#endif +/* * Functions related to boot-time initialization: */
Signature · 1 line
1.8.5.3
PATCH 7/11 kernel/hrtimer: be non-freezeable in cpu_chill()
In reply to Steven Rostedt3.10.32-rt31-rc1 stable review patch.
If anyone has any objections, please let me know.
------------------
From: Sebastian Andrzej Siewior <[email protected]>
Since we replaced msleep() by hrtimer I see now and then (rarely) this:
| [....] Waiting for /dev to be fully populated...
| =====================================
| [ BUG: udevd/229 still has locks held! ]
| 3.12.11-rt17 #23 Not tainted
| -------------------------------------
| 1 lock held by udevd/229:
| #0: (&type->i_mutex_dir_key#2){+.+.+.}, at: lookup_slow+0x28/0x98
|
| stack backtrace:
| CPU: 0 PID: 229 Comm: udevd Not tainted 3.12.11-rt17 #23
| (unwind_backtrace+0x0/0xf8) from (show_stack+0x10/0x14)
| (show_stack+0x10/0x14) from (dump_stack+0x74/0xbc)
| (dump_stack+0x74/0xbc) from (do_nanosleep+0x120/0x160)
| (do_nanosleep+0x120/0x160) from (hrtimer_nanosleep+0x90/0x110)
| (hrtimer_nanosleep+0x90/0x110) from (cpu_chill+0x30/0x38)
| (cpu_chill+0x30/0x38) from (dentry_kill+0x158/0x1ec)
| (dentry_kill+0x158/0x1ec) from (dput+0x74/0x15c)
| (dput+0x74/0x15c) from (lookup_real+0x4c/0x50)
| (lookup_real+0x4c/0x50) from (__lookup_hash+0x34/0x44)
| (__lookup_hash+0x34/0x44) from (lookup_slow+0x38/0x98)
| (lookup_slow+0x38/0x98) from (path_lookupat+0x208/0x7fc)
| (path_lookupat+0x208/0x7fc) from (filename_lookup+0x20/0x60)
| (filename_lookup+0x20/0x60) from (user_path_at_empty+0x50/0x7c)
| (user_path_at_empty+0x50/0x7c) from (user_path_at+0x14/0x1c)
| (user_path_at+0x14/0x1c) from (vfs_fstatat+0x48/0x94)
| (vfs_fstatat+0x48/0x94) from (SyS_stat64+0x14/0x30)
| (SyS_stat64+0x14/0x30) from (ret_fast_syscall+0x0/0x48)For now I see no better way but to disable the freezer the sleep the period.
--- kernel/hrtimer.c | 4 ++++ 1 file changed, 4 insertions(+)
kernel/hrtimer.c +4 -0
@@ -1896,8 +1896,12 @@ void cpu_chill(void)struct timespec tu = { .tv_nsec =NSEC_PER_MSEC , }; +unsigned int freeze_flag = current->flags &PF_NOFREEZE ; + current->flags |=PF_NOFREEZE ;hrtimer_nanosleep (&tu,NULL ,HRTIMER_MODE_REL ,CLOCK_MONOTONIC ); +if (!freeze_flag) + current->flags &= ~PF_NOFREEZE; }EXPORT_SYMBOL (cpu_chill);#endif
Signature · 1 line
1.8.5.3
PATCH 8/11 arm/unwind: use a raw_spin_lock
In reply to Steven Rostedt3.10.32-rt31-rc1 stable review patch.
If anyone has any objections, please let me know.
------------------
From: Sebastian Andrzej Siewior <[email protected]>
Mostly unwind is done with irqs enabled however SLUB may call it with irqs disabled while creating a new SLUB cache.
I had system freeze while loading a module which called kmem_cache_create() on init. That means SLUB's __slab_alloc() disabled interrupts and then
->new_slab_objects()
->new_slab()
->setup_object()
->setup_object_debug()
->init_tracking()
->set_track()
->save_stack_trace()
->save_stack_trace_tsk()
->walk_stackframe()
->unwind_frame()
->unwind_find_idx()
=>spin_lock_irqsave(&unwind_lock);--- arch/arm/kernel/unwind.c | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-)
arch/arm/kernel/unwind.c +7 -7
@@ -87,7 +87,7 @@ extern const struct unwind_idx __start_unwind_idx[];static const struct unwind_idx *__origin_unwind_idx;extern const struct unwind_idx __stop_unwind_idx[]; -static DEFINE_SPINLOCK (unwind_lock); +static DEFINE_RAW_SPINLOCK (unwind_lock);static LIST_HEAD (unwind_tables);/* Convert a prel31 symbol to an absolute address */
@@ -195,7 +195,7 @@ static const struct unwind_idx *unwind_find_idx(unsigned long addr)/* module unwind tables */ struct unwind_table *table; -spin_lock_irqsave (&unwind_lock, flags); +raw_spin_lock_irqsave (&unwind_lock, flags);list_for_each_entry (table, &unwind_tables, list) {if (addr >= table->begin_addr && addr < table->end_addr) {
@@ -207,7 +207,7 @@ static const struct unwind_idx *unwind_find_idx(unsigned long addr)break ; } } -spin_unlock_irqrestore (&unwind_lock, flags); +raw_spin_unlock_irqrestore (&unwind_lock, flags); }pr_debug ("%s: idx = %p\n" , __func__, idx);
@@ -469,9 +469,9 @@ struct unwind_table *unwind_table_add(unsigned long start, unsigned long size, tab->begin_addr = text_addr; tab->end_addr = text_addr + text_size; -spin_lock_irqsave (&unwind_lock, flags); +raw_spin_lock_irqsave (&unwind_lock, flags);list_add_tail (&tab->list, &unwind_tables); -spin_unlock_irqrestore (&unwind_lock, flags); +raw_spin_unlock_irqrestore (&unwind_lock, flags);return tab; }
@@ -483,9 +483,9 @@ void unwind_table_del(struct unwind_table *tab)if (!tab)return ; -spin_lock_irqsave (&unwind_lock, flags); +raw_spin_lock_irqsave (&unwind_lock, flags);list_del (&tab->list); -spin_unlock_irqrestore (&unwind_lock, flags); +raw_spin_unlock_irqrestore (&unwind_lock, flags);kfree (tab); }
Signature · 1 line
1.8.5.3
PATCH 9/11 net: ip_send_unicast_reply: add missing local serialization
In reply to Steven Rostedt3.10.32-rt31-rc1 stable review patch.
If anyone has any objections, please let me know.
------------------
From: Nicholas Mc Guire <[email protected]>
in response to the oops in ip_output.c:ip_send_unicast_reply under high network load with CONFIG_PREEMPT_RT_FULL=y, reported by Sami Pietikainen <[email protected]>, this patch adds local serialization in ip_send_unicast_reply.
from ip_output.c:
/*
* Generic function to send a packet as reply to another packet.
* Used to send some TCP resets/acks so far.
*
* Use a fake percpu inet socket to avoid false sharing and contention.
*/
static DEFINE_PER_CPU(struct inet_sock, unicast_sock) = {
...
which was added in commit be9f4a44 in linux-stable. The git log, wich introduced the PER_CPU unicast_sock, states:
<snip>
commit be9f4a44e7d41cee50ddb5f038fc2391cbbb4046
Author: Eric Dumazet <[email protected]> Date: Thu Jul 19 07:34:03 2012 +0000
ipv4: tcp: remove per net tcp_sock
tcp_v4_send_reset() and tcp_v4_send_ack() use a single socket per network namespace.
This leads to bad behavior on multiqueue NICS, because many cpus contend for the socket lock and once socket lock is acquired, extra false sharing on various socket fields slow down the operations.
To better resist to attacks, we use a percpu socket. Each cpu can run without contention, using appropriate memory (local node)
<snip>
The per-cpu here thus is assuming exclusivity serializing per cpu - so the use of get_cpu_ligh introduced in net-use-cpu-light-in-ip-send-unicast-reply.patch, which droped the preempt_disable in favor of a migrate_disable is probably wrong as this only handles the referencial consistency but not the serialization. To evade a preempt_disable here a local lock would be needed.
Therapie:
* add local lock:
* and re-introduce local serialization:
Tested on x86 with high network load using the testcase from Sami Pietikainen
while : ; do wget -O - ftp://LOCAL_SERVER/empty_file > /dev/null 2>&1; done
--- net/ipv4/ip_output.c | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-)
net/ipv4/ip_output.c +6 -3
@@ -79,6 +79,7 @@#include <linux/mroute.h> #include <linux/netlink.h> #include <linux/tcp.h> +#include <linux/locallock.h> int sysctl_ip_default_ttl__read_mostly =IPDEFTTL ;EXPORT_SYMBOL (sysctl_ip_default_ttl);
@@ -1471,6 +1472,9 @@ static DEFINE_PER_CPU(struct inet_sock, unicast_sock) = { .uc_ttl = -1, }; +/* serialize concurrent calls on the same CPU to ip_send_unicast_reply */ +static DEFINE_LOCAL_IRQ_LOCK (unicast_lock); +void ip_send_unicast_reply (struct net *net,struct sk_buff *skb,__be32 daddr,__be32 saddr,const struct ip_reply_arg *arg,unsigned int len)
@@ -1508,8 +1512,7 @@ void ip_send_unicast_reply(struct net *net, struct sk_buff *skb, __be32 daddr,if (IS_ERR (rt))return ; -get_cpu_light (); - inet = &__get_cpu_var (unicast_sock); + inet = &get_locked_var (unicast_lock, unicast_sock); inet->tos = arg->tos; sk = &inet->sk;
@@ -1533,7 +1536,7 @@ void ip_send_unicast_reply(struct net *net, struct sk_buff *skb, __be32 daddr,ip_push_pending_frames (sk, &fl4); } -put_cpu_light (); +put_locked_var (unicast_lock, unicast_sock);ip_rt_put (rt); }
Signature · 1 line
1.8.5.3
PATCH 10/11 leds: trigger: disable CPU trigger on -RT
In reply to Steven Rostedt3.10.32-rt31-rc1 stable review patch.
If anyone has any objections, please let me know.
------------------
From: Sebastian Andrzej Siewior <[email protected]>
as it triggers:
|CPU: 0 PID: 0 Comm: swapper Not tainted 3.12.8-rt10 #141 |[<c0014aa4>] (unwind_backtrace+0x0/0xf8) from [<c0012788>] (show_stack+0x1c/0x20) |[<c0012788>] (show_stack+0x1c/0x20) from [<c043c8dc>] (dump_stack+0x20/0x2c) |[<c043c8dc>] (dump_stack+0x20/0x2c) from [<c004c5e8>] (__might_sleep+0x13c/0x170) |[<c004c5e8>] (__might_sleep+0x13c/0x170) from [<c043f270>] (__rt_spin_lock+0x28/0x38) |[<c043f270>] (__rt_spin_lock+0x28/0x38) from [<c043fa00>] (rt_read_lock+0x68/0x7c) |[<c043fa00>] (rt_read_lock+0x68/0x7c) from [<c036cf74>] (led_trigger_event+0x2c/0x5c) |[<c036cf74>] (led_trigger_event+0x2c/0x5c) from [<c036e0bc>] (ledtrig_cpu+0x54/0x5c) |[<c036e0bc>] (ledtrig_cpu+0x54/0x5c) from [<c000ffd8>] (arch_cpu_idle_exit+0x18/0x1c) |[<c000ffd8>] (arch_cpu_idle_exit+0x18/0x1c) from [<c00590b8>] (cpu_startup_entry+0xa8/0x234) |[<c00590b8>] (cpu_startup_entry+0xa8/0x234) from [<c043b2cc>] (rest_init+0xb8/0xe0) |[<c043b2cc>] (rest_init+0xb8/0xe0) from [<c061ebe0>] (start_kernel+0x2c4/0x380)
--- drivers/leds/trigger/Kconfig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/leds/trigger/Kconfig +1 -1
@@ -61,7 +61,7 @@ config LEDS_TRIGGER_BACKLIGHT config LEDS_TRIGGER_CPU bool "LED CPU Trigger" - depends on LEDS_TRIGGERS + depends on LEDS_TRIGGERS && !PREEMPT_RT_BASE help This allows LEDs to be controlled by active CPUs. This shows the active CPUs across an array of LEDs so you can see which
Signature · 1 line
1.8.5.3
PATCH 11/11 Linux 3.10.32-rt31-rc1
In reply to Steven Rostedt3.10.32-rt31-rc1 stable review patch.
If anyone has any objections, please let me know.
------------------
From: "Steven Rostedt (Red Hat)" <[email protected]>
--- localversion-rt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
localversion-rt +1 -1
@@ -1 +1 @@ --rt30 +-rt31-rc1
Signature · 1 line
1.8.5.3