4.9.215-stable review
Subsystems (7)
Greg Kroah-Hartman
maintainerPATCH 140/165 powerpc/tm: Fix clearing MSR[TS] in current when reclaiming on signal delivery
In reply to Greg Kroah-HartmanFrom: Gustavo Luiz Duarte <[email protected]>
[ Upstream commit 2464cc4c345699adea52c7aef75707207cb8a2f6 ]
After a treclaim, we expect to be in non-transactional state. If we don't clear the current thread's MSR[TS] before we get preempted, then tm_recheckpoint_new_task() will recheckpoint and we get rescheduled in suspended transaction state.
When handling a signal caught in transactional state, handle_rt_signal64() calls get_tm_stackpointer() that treclaims the transaction using tm_reclaim_current() but without clearing the thread's MSR[TS]. This can cause the TM Bad Thing exception below if later we pagefault and get preempted trying to access the user's sigframe, using __put_user(). Afterwards, when we are rescheduled back into do_page_fault() (but now in suspended state since the thread's MSR[TS] was not cleared), upon executing 'rfid' after completion of the page fault handling, the exception is raised because a transition from suspended to non-transactional state is invalid.
Unexpected TM Bad Thing exception at c00000000000de44 (msr 0x8000000302a03031) tm_scratch=800000010280b033
Oops: Unrecoverable exception, sig: 6 [#1] LE PAGE_SIZE=64K MMU=Hash SMP NR_CPUS=2048 NUMA pSeries CPU: 25 PID: 15547 Comm: a.out Not tainted 5.4.0-rc2 #32 NIP: c00000000000de44 LR: c000000000034728 CTR: 0000000000000000 REGS: c00000003fe7bd70 TRAP: 0700 Not tainted (5.4.0-rc2) MSR: 8000000302a03031 <SF,VEC,VSX,FP,ME,IR,DR,LE,TM[SE]> CR: 44000884 XER: 00000000 CFAR: c00000000000dda4 IRQMASK: 0 PACATMSCRATCH: 800000010280b033 GPR00: c000000000034728 c000000f65a17c80 c000000001662800 00007fffacf3fd78 GPR04: 0000000000001000 0000000000001000 0000000000000000 c000000f611f8af0 GPR08: 0000000000000000 0000000078006001 0000000000000000 000c000000000000 GPR12: c000000f611f84b0 c00000003ffcb200 0000000000000000 0000000000000000 GPR16: 0000000000000000 0000000000000000 0000000000000000 0000000000000000 GPR20: 0000000000000000 0000000000000000 0000000000000000 c000000f611f8140 GPR24: 0000000000000000 00007fffacf3fd68 c000000f65a17d90 c000000f611f7800 GPR28: c000000f65a17e90 c000000f65a17e90 c000000001685e18 00007fffacf3f000 NIP [c00000000000de44] fast_exception_return+0xf4/0x1b0 LR [c000000000034728] handle_rt_signal64+0x78/0xc50 Call Trace: [c000000f65a17c80] [c000000000034710] handle_rt_signal64+0x60/0xc50 (unreliable) [c000000f65a17d30] [c000000000023640] do_notify_resume+0x330/0x460 [c000000f65a17e20] [c00000000000dcc4] ret_from_except_lite+0x70/0x74 Instruction dump: 7c4ff120 e8410170 7c5a03a6 38400000 f8410060 e8010070 e8410080 e8610088 60000000 60000000 e8810090 e8210078 <4c000024> 48000000 e8610178 88ed0989 ---[ end trace 93094aa44b442f87 ]---
The simplified sequence of events that triggers the above exception is:
... # userspace in NON-TRANSACTIONAL state
tbegin # userspace in TRANSACTIONAL state
signal delivery # kernelspace in SUSPENDED state
handle_rt_signal64()
get_tm_stackpointer()
treclaim # kernelspace in NON-TRANSACTIONAL state
__put_user()
page fault happens. We will never get back here because of the TM Bad Thing exception.
page fault handling kicks in and we voluntarily preempt ourselves do_page_fault()
__schedule()
__switch_to(other_task) our task is rescheduled and we recheckpoint because the thread's MSR[TS] was not cleared __switch_to(our_task)
switch_to_tm()
tm_recheckpoint_new_task()
trechkpt # kernelspace in SUSPENDED state
The page fault handling resumes, but now we are in suspended transaction state
do_page_fault() completes
rfid <----- trying to get back where the page fault happened (we were non-transactional back then)
TM Bad Thing # illegal transition from suspended to non-transactional
This patch fixes that issue by clearing the current thread's MSR[TS] just after treclaim in get_tm_stackpointer() so that we stay in non-transactional state in case we are preempted. In order to make treclaim and clearing the thread's MSR[TS] atomic from a preemption perspective when CONFIG_PREEMPT is set, preempt_disable/enable() is used. It's also necessary to save the previous value of the thread's MSR before get_tm_stackpointer() is called so that it can be exposed to the signal handler later in setup_tm_sigcontexts() to inform the userspace MSR at the moment of the signal delivery.
Found with tm-signal-context-force-tm kernel selftest.
--- arch/powerpc/kernel/signal.c | 17 +++++++++++++++-- arch/powerpc/kernel/signal_32.c | 28 ++++++++++++++-------------- arch/powerpc/kernel/signal_64.c | 22 ++++++++++------------ 3 files changed, 39 insertions(+), 28 deletions(-)
arch/powerpc/kernel/signal.c +15 -2
@@ -189,14 +189,27 @@ unsigned long get_tm_stackpointer(struct task_struct *tsk)* normal/non-checkpointed stack pointer. */ +unsigned long ret = tsk->thread.regs->gpr[1 ]; +#ifdef CONFIG_PPC_TRANSACTIONAL_MEM BUG_ON (tsk != current);if (MSR_TM_ACTIVE (tsk->thread.regs->msr)) { +preempt_disable ();tm_reclaim_current (TM_CAUSE_SIGNAL );if (MSR_TM_TRANSACTIONAL (tsk->thread.regs->msr)) -return tsk->thread.ckpt_regs.gpr[1 ]; + ret = tsk->thread.ckpt_regs.gpr[1 ]; + +/* +* If we treclaim, we must clear the current thread's TM bits +* before re-enabling preemption. Otherwise we might be +* preempted and have the live MSR[TS] changed behind our back +* (tm_recheckpoint_new_task() would recheckpoint). Besides, we +* enter the signal handler in non-transactional state. +*/ + tsk->thread.regs->msr &= ~MSR_TS_MASK ; +preempt_enable (); }#endif -return tsk->thread.regs->gpr[1 ]; +return ret; }
arch/powerpc/kernel/signal_32.c +14 -14
@@ -515,19 +515,11 @@ static int save_user_regs(struct pt_regs *regs, struct mcontext __user *frame,*/ static int save_tm_user_regs (struct pt_regs *regs,struct mcontext __user *frame, -struct mcontext __user *tm_frame,int sigret) +struct mcontext __user *tm_frame,int sigret, +unsigned long msr) { -unsigned long msr = regs->msr; -WARN_ON (tm_suspend_disabled); -/* Remove TM bits from thread's MSR. The MSR in the sigcontext -* just indicates to userland that we were doing a transaction, but we -* don't want to return in transactional state. This also ensures -* that flush_fp_to_thread won't set TIF_RESTORE_TM again. -*/ - regs->msr &= ~MSR_TS_MASK ; -/* Save both sets of general registers */ if (save_general_regs (¤t->thread.ckpt_regs, frame) ||save_general_regs (regs, tm_frame))
@@ -1006,6 +998,10 @@ int handle_rt_signal32(struct ksignal *ksig, sigset_t *oldset,int sigret;unsigned long tramp;struct pt_regs *regs = tsk->thread.regs; +#ifdef CONFIG_PPC_TRANSACTIONAL_MEM +/* Save the thread's msr before get_tm_stackpointer() changes it */ +unsigned long msr = regs->msr; +#endif BUG_ON (tsk != current);
@@ -1038,13 +1034,13 @@ int handle_rt_signal32(struct ksignal *ksig, sigset_t *oldset,#ifdef CONFIG_PPC_TRANSACTIONAL_MEM tm_frame = &rt_sf->uc_transact.uc_mcontext; -if (MSR_TM_ACTIVE (regs->msr)) { +if (MSR_TM_ACTIVE (msr)) {if (__put_user ((unsigned long )&rt_sf->uc_transact, &rt_sf->uc.uc_link) ||__put_user ((unsigned long )tm_frame, &rt_sf->uc_transact.uc_regs)) goto badframe; -if (save_tm_user_regs (regs, frame, tm_frame, sigret)) +if (save_tm_user_regs (regs, frame, tm_frame, sigret, msr)) goto badframe; }else
@@ -1451,6 +1447,10 @@ int handle_signal32(struct ksignal *ksig, sigset_t *oldset,int sigret;unsigned long tramp;struct pt_regs *regs = tsk->thread.regs; +#ifdef CONFIG_PPC_TRANSACTIONAL_MEM +/* Save the thread's msr before get_tm_stackpointer() changes it */ +unsigned long msr = regs->msr; +#endif BUG_ON (tsk != current);
@@ -1484,9 +1484,9 @@ int handle_signal32(struct ksignal *ksig, sigset_t *oldset,#ifdef CONFIG_PPC_TRANSACTIONAL_MEM tm_mctx = &frame->mctx_transact; -if (MSR_TM_ACTIVE (regs->msr)) { +if (MSR_TM_ACTIVE (msr)) {if (save_tm_user_regs (regs, &frame->mctx, &frame->mctx_transact, - sigret)) + sigret, msr)) goto badframe; }else
arch/powerpc/kernel/signal_64.c +10 -12
@@ -192,7 +192,8 @@ static long setup_sigcontext(struct sigcontext __user *sc,static long setup_tm_sigcontexts (struct sigcontext __user *sc,struct sigcontext __user *tm_sc,struct task_struct *tsk, -int signr,sigset_t *set,unsigned long handler) +int signr,sigset_t *set,unsigned long handler, +unsigned long msr) {/* When CONFIG_ALTIVEC is set, we _always_ setup v_regs even if the * process never used altivec yet (MSR_VEC is zero in pt_regs of
@@ -207,12 +208,11 @@ static long setup_tm_sigcontexts(struct sigcontext __user *sc,elf_vrreg_t __user *tm_v_regs =sigcontext_vmx_regs (tm_sc);#endif struct pt_regs *regs = tsk->thread.regs; -unsigned long msr = tsk->thread.regs->msr;long err =0 ;BUG_ON (tsk != current); -BUG_ON (!MSR_TM_ACTIVE (regs->msr)); +BUG_ON (!MSR_TM_ACTIVE (msr));WARN_ON (tm_suspend_disabled);
@@ -222,13 +222,6 @@ static long setup_tm_sigcontexts(struct sigcontext __user *sc,*/ msr |= tsk->thread.ckpt_regs.msr & (MSR_FP |MSR_VEC |MSR_VSX ); -/* Remove TM bits from thread's MSR. The MSR in the sigcontext -* just indicates to userland that we were doing a transaction, but we -* don't want to return in transactional state. This also ensures -* that flush_fp_to_thread won't set TIF_RESTORE_TM again. -*/ - regs->msr &= ~MSR_TS_MASK ; -#ifdef CONFIG_ALTIVEC err |=__put_user (v_regs, &sc->v_regs); err |=__put_user (tm_v_regs, &tm_sc->v_regs);
@@ -805,6 +798,10 @@ int handle_rt_signal64(struct ksignal *ksig, sigset_t *set,unsigned long newsp =0 ;long err =0 ;struct pt_regs *regs = tsk->thread.regs; +#ifdef CONFIG_PPC_TRANSACTIONAL_MEM +/* Save the thread's msr before get_tm_stackpointer() changes it */ +unsigned long msr = regs->msr; +#endif BUG_ON (tsk != current);
@@ -822,7 +819,7 @@ int handle_rt_signal64(struct ksignal *ksig, sigset_t *set, err |=__put_user (0 , &frame->uc.uc_flags); err |=__save_altstack (&frame->uc.uc_stack, regs->gpr[1 ]);#ifdef CONFIG_PPC_TRANSACTIONAL_MEM -if (MSR_TM_ACTIVE (regs->msr)) { +if (MSR_TM_ACTIVE (msr)) {/* The ucontext_t passed to userland points to the second * ucontext_t (for transactional state) with its uc_link ptr. */
@@ -830,7 +827,8 @@ int handle_rt_signal64(struct ksignal *ksig, sigset_t *set, err |=setup_tm_sigcontexts (&frame->uc.uc_mcontext, &frame->uc_transact.uc_mcontext, tsk, ksig->sig,NULL , - (unsigned long )ksig->ka.sa.sa_handler); + (unsigned long )ksig->ka.sa.sa_handler, + msr); } else#endif {
Signature · 1 line
2.20.1
Greg Kroah-Hartman
maintainerPATCH 141/165 lib/stackdepot: Fix outdated comments
In reply to Greg Kroah-HartmanFrom: Miles Chen <[email protected]>
[ Upstream commit ee050dc83bc326ad5ef8ee93bca344819371e7a5 ]
Replace "depot_save_stack" with "stack_depot_save" in code comments because depot_save_stack() was replaced in commit c0cfc337264c ("lib/stackdepot:
Provide functions which operate on plain storage arrays") and removed in commit 56d8f079c51a ("lib/stackdepot: Remove obsolete functions")
--- lib/stackdepot.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
lib/stackdepot.c +2 -2
@@ -96,7 +96,7 @@ static bool init_stack_slab(void **prealloc) stack_slabs[depot_index +1 ] = *prealloc;/* * This smp_store_release pairs with smp_load_acquire() from -* |next_slab_inited| above and in depot_save_stack(). +* |next_slab_inited| above and in stack_depot_save(). */ smp_store_release (&next_slab_inited,1 ); }
@@ -123,7 +123,7 @@ static struct stack_record *depot_alloc_stack(unsigned long *entries, int size, depot_offset =0 ;/* * smp_store_release() here pairs with smp_load_acquire() from -* |next_slab_inited| in depot_save_stack() and +* |next_slab_inited| in stack_depot_save() and * init_stack_slab(). */ if (depot_index +1 <STACK_ALLOC_MAX_SLABS )
Signature · 1 line
2.20.1
Greg Kroah-Hartman
maintainerPATCH 142/165 lib/stackdepot.c: fix global out-of-bounds in stack_slabs
In reply to Greg Kroah-HartmanFrom: Alexander Potapenko <[email protected]>
[ Upstream commit 305e519ce48e935702c32241f07d393c3c8fed3e ]
Walter Wu has reported a potential case in which init_stack_slab() is called after stack_slabs[STACK_ALLOC_MAX_SLABS - 1] has already been initialized. In that case init_stack_slab() will overwrite stack_slabs[STACK_ALLOC_MAX_SLABS], which may result in a memory corruption.
--- lib/stackdepot.c | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-)
lib/stackdepot.c +6 -2
@@ -92,15 +92,19 @@ static bool init_stack_slab(void **prealloc)return true;if (stack_slabs[depot_index] ==NULL ) { stack_slabs[depot_index] = *prealloc; + *prealloc =NULL ; }else { - stack_slabs[depot_index +1 ] = *prealloc; +/* If this is the last depot slab, do not touch the next one. */ +if (depot_index +1 <STACK_ALLOC_MAX_SLABS ) { + stack_slabs[depot_index +1 ] = *prealloc; + *prealloc =NULL ; + }/* * This smp_store_release pairs with smp_load_acquire() from * |next_slab_inited| above and in stack_depot_save(). */ smp_store_release (&next_slab_inited,1 ); } - *prealloc =NULL ;return true; }
Signature · 1 line
2.20.1
Greg Kroah-Hartman
maintainerPATCH 143/165 KVM: nVMX: Dont emulate instructions in guest mode
In reply to Greg Kroah-HartmanFrom: Paolo Bonzini <[email protected]>
[ Upstream commit 07721feee46b4b248402133228235318199b05ec ]
vmx_check_intercept is not yet fully implemented. To avoid emulating instructions disallowed by the L1 hypervisor, refuse to emulate instructions by default.
--- arch/x86/kvm/vmx.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/x86/kvm/vmx.c +1 -1
@@ -11354,7 +11354,7 @@ static int vmx_check_intercept(struct kv }/* TODO: check more intercepts... */ -return X86EMUL_CONTINUE ; +return X86EMUL_UNHANDLEABLE ; }#ifdef CONFIG_X86_64
Greg Kroah-Hartman
maintainerPATCH 144/165 netfilter: xt_bpf: add overflow checks
In reply to Greg Kroah-HartmanFrom: Jann Horn <[email protected]>
[ Upstream commit 6ab405114b0b229151ef06f4e31c7834dd09d0c0 ]
Check whether inputs from userspace are too long (explicit length field too big or string not null-terminated) to avoid out-of-bounds reads.
As far as I can tell, this can at worst lead to very limited kernel heap memory disclosure or oopses.
This bug can be triggered by an unprivileged user even if the xt_bpf module is not loaded: iptables is available in network namespaces, and the xt_bpf module can be autoloaded.
Triggering the bug with a classic BPF filter with fake length 0x1000 causes the following KASAN report:
==================================================================
BUG: KASAN: slab-out-of-bounds in bpf_prog_create+0x84/0xf0
Read of size 32768 at addr ffff8801eff2c494 by task test/4627
CPU: 0 PID: 4627 Comm: test Not tainted 4.15.0-rc1+ #1
[...]
Call Trace:
dump_stack+0x5c/0x85
print_address_description+0x6a/0x260
kasan_report+0x254/0x370
? bpf_prog_create+0x84/0xf0
memcpy+0x1f/0x50
bpf_prog_create+0x84/0xf0
bpf_mt_check+0x90/0xd6 [xt_bpf]
[...]
Allocated by task 4627:
kasan_kmalloc+0xa0/0xd0
__kmalloc_node+0x47/0x60
xt_alloc_table_info+0x41/0x70 [x_tables]
[...]
The buggy address belongs to the object at ffff8801eff2c3c0
which belongs to the cache kmalloc-2048 of size 2048
The buggy address is located 212 bytes inside of
2048-byte region [ffff8801eff2c3c0, ffff8801eff2cbc0)[...]
==================================================================
--- net/netfilter/xt_bpf.c | 3 +++ 1 file changed, 3 insertions(+)
net/netfilter/xt_bpf.c +3 -0
@@ -25,6 +25,9 @@ static int bpf_mt_check(const struct xt_mtchk_param *par)struct xt_bpf_info *info = par->matchinfo;struct sock_fprog_kern program; +if (info->bpf_program_num_elem >XT_BPF_MAX_NUM_INSTR ) +return -EINVAL ; + program.len = info->bpf_program_num_elem; program.filter = info->bpf_program;
Signature · 1 line
2.20.1
Greg Kroah-Hartman
maintainerPATCH 145/165 ext4: fix a data race in EXT4_I(inode)->i_disksize
In reply to Greg Kroah-HartmanFrom: Qian Cai <[email protected]>
commit 35df4299a6487f323b0aca120ea3f485dfee2ae3 upstream.
EXT4_I(inode)->i_disksize could be accessed concurrently as noticed by KCSAN,
BUG: KCSAN: data-race in ext4_write_end [ext4] / ext4_writepages [ext4]
write to 0xffff91c6713b00f8 of 8 bytes by task 49268 on cpu 127:
ext4_write_end+0x4e3/0x750 [ext4] ext4_update_i_disksize at fs/ext4/ext4.h:3032 (inlined by) ext4_update_inode_size at fs/ext4/ext4.h:3046 (inlined by) ext4_write_end at fs/ext4/inode.c:1287 generic_perform_write+0x208/0x2a0 ext4_buffered_write_iter+0x11f/0x210 [ext4] ext4_file_write_iter+0xce/0x9e0 [ext4] new_sync_write+0x29c/0x3b0 __vfs_write+0x92/0xa0 vfs_write+0x103/0x260 ksys_write+0x9d/0x130 __x64_sys_write+0x4c/0x60 do_syscall_64+0x91/0xb47 entry_SYSCALL_64_after_hwframe+0x49/0xbe
read to 0xffff91c6713b00f8 of 8 bytes by task 24872 on cpu 37:
ext4_writepages+0x10ac/0x1d00 [ext4] mpage_map_and_submit_extent at fs/ext4/inode.c:2468 (inlined by) ext4_writepages at fs/ext4/inode.c:2772 do_writepages+0x5e/0x130 __writeback_single_inode+0xeb/0xb20 writeback_sb_inodes+0x429/0x900 __writeback_inodes_wb+0xc4/0x150 wb_writeback+0x4bd/0x870 wb_workfn+0x6b4/0x960 process_one_work+0x54c/0xbe0 worker_thread+0x80/0x650 kthread+0x1e0/0x200 ret_from_fork+0x27/0x50
Reported by Kernel Concurrency Sanitizer on:
CPU: 37 PID: 24872 Comm: kworker/u261:2 Tainted: G W O L 5.5.0-next-20200204+ #5 Hardware name: HPE ProLiant DL385 Gen10/ProLiant DL385 Gen10, BIOS A40 07/10/2019 Workqueue: writeback wb_workfn (flush-7:0)
Since only the read is operating as lockless (outside of the "i_data_sem"), load tearing could introduce a logic bug. Fix it by adding READ_ONCE() for the read and WRITE_ONCE() for the write.
--- fs/ext4/ext4.h | 2 +- fs/ext4/inode.c | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-)
fs/ext4/ext4.h +1 -1
@@ -2851,7 +2851,7 @@ static inline void ext4_update_i_disksiz !inode_is_locked(inode));down_write (&EXT4_I (inode)->i_data_sem);if (newsize >EXT4_I (inode)->i_disksize) -EXT4_I (inode)->i_disksize = newsize; +WRITE_ONCE (EXT4_I (inode)->i_disksize, newsize);up_write (&EXT4_I (inode)->i_data_sem); }
fs/ext4/inode.c +1 -1
@@ -2475,7 +2475,7 @@ update_disksize:* truncate are avoided by checking i_size under i_data_sem. */ disksize = ((loff_t )mpd->first_page) <<PAGE_SHIFT ; -if (disksize >EXT4_I (inode)->i_disksize) { +if (disksize >READ_ONCE (EXT4_I (inode)->i_disksize)) {int err2;loff_t i_size;
Greg Kroah-Hartman
maintainerPATCH 146/165 ext4: add cond_resched() to __ext4_find_entry()
In reply to Greg Kroah-HartmanFrom: Shijie Luo <[email protected]>
commit 9424ef56e13a1f14c57ea161eed3ecfdc7b2770e upstream.
We tested a soft lockup problem in linux 4.19 which could also be found in linux 5.x.
When dir inode takes up a large number of blocks, and if the directory is growing when we are searching, it's possible the restart branch could be called many times, and the do while loop could hold cpu a long time.
Here is the call trace in linux 4.19.
[ 473.756186] Call trace: [ 473.756196] dump_backtrace+0x0/0x198 [ 473.756199] show_stack+0x24/0x30 [ 473.756205] dump_stack+0xa4/0xcc [ 473.756210] watchdog_timer_fn+0x300/0x3e8 [ 473.756215] __hrtimer_run_queues+0x114/0x358 [ 473.756217] hrtimer_interrupt+0x104/0x2d8 [ 473.756222] arch_timer_handler_virt+0x38/0x58 [ 473.756226] handle_percpu_devid_irq+0x90/0x248 [ 473.756231] generic_handle_irq+0x34/0x50 [ 473.756234] __handle_domain_irq+0x68/0xc0 [ 473.756236] gic_handle_irq+0x6c/0x150 [ 473.756238] el1_irq+0xb8/0x140 [ 473.756286] ext4_es_lookup_extent+0xdc/0x258 [ext4] [ 473.756310] ext4_map_blocks+0x64/0x5c0 [ext4] [ 473.756333] ext4_getblk+0x6c/0x1d0 [ext4] [ 473.756356] ext4_bread_batch+0x7c/0x1f8 [ext4] [ 473.756379] ext4_find_entry+0x124/0x3f8 [ext4] [ 473.756402] ext4_lookup+0x8c/0x258 [ext4] [ 473.756407] __lookup_hash+0x8c/0xe8 [ 473.756411] filename_create+0xa0/0x170 [ 473.756413] do_mkdirat+0x6c/0x140 [ 473.756415] __arm64_sys_mkdirat+0x28/0x38 [ 473.756419] el0_svc_common+0x78/0x130 [ 473.756421] el0_svc_handler+0x38/0x78 [ 473.756423] el0_svc+0x8/0xc [ 485.755156] watchdog: BUG: soft lockup - CPU#2 stuck for 22s! [tmp:5149]
Add cond_resched() to avoid soft lockup and to provide a better system responding.
--- fs/ext4/namei.c | 1 + 1 file changed, 1 insertion(+)
fs/ext4/namei.c +1 -0
@@ -1445,6 +1445,7 @@ restart:/* * We deal with the read-ahead logic here. */ +cond_resched ();if (ra_ptr >= ra_max) {/* Refill the readahead buffer */ ra_ptr =0 ;
Greg Kroah-Hartman
maintainerPATCH 147/165 ext4: fix mount failure with quota configured as module
In reply to Greg Kroah-HartmanFrom: Jan Kara <[email protected]>
commit 9db176bceb5c5df4990486709da386edadc6bd1d upstream.
When CONFIG_QFMT_V2 is configured as a module, the test in ext4_feature_set_ok() fails and so mount of filesystems with quota or project features fails. Fix the test to use IS_ENABLED macro which works properly even for modules.
--- fs/ext4/super.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
fs/ext4/super.c +1 -1
@@ -2743,7 +2743,7 @@ static int ext4_feature_set_ok(struct sureturn 0 ; } -#if !defined(CONFIG_QUOTA ) || !defined(CONFIG_QFMT_V2 ) +#if !IS_ENABLED (CONFIG_QUOTA ) || !IS_ENABLED (CONFIG_QFMT_V2 )if (!readonly && (ext4_has_feature_quota (sb) ||ext4_has_feature_project (sb))) { ext4_msg(sb, KERN_ERR,
Greg Kroah-Hartman
maintainerPATCH 148/165 ext4: rename s_journal_flag_rwsem to s_writepages_rwsem
In reply to Greg Kroah-HartmanFrom: Eric Biggers <[email protected]>
commit bbd55937de8f2754adc5792b0f8e5ff7d9c0420e upstream.
In preparation for making s_journal_flag_rwsem synchronize ext4_writepages() with changes to both the EXTENTS and JOURNAL_DATA flags (rather than just JOURNAL_DATA as it does currently), rename it to s_writepages_rwsem.
--- fs/ext4/ext4.h | 2 +- fs/ext4/inode.c | 10 +++++----- fs/ext4/super.c | 6 +++--- 3 files changed, 9 insertions(+), 9 deletions(-)
fs/ext4/ext4.h +1 -1
@@ -1515,7 +1515,7 @@ struct ext4_sb_info {struct ratelimit_state s_msg_ratelimit_state;/* Barrier between changing inodes' journal flags and writepages ops. */ -struct percpu_rw_semaphore s_journal_flag_rwsem; +struct percpu_rw_semaphore s_writepages_rwsem;/* Encryption support */ #ifdef CONFIG_EXT4_FS_ENCRYPTION
fs/ext4/inode.c +5 -5
@@ -2652,7 +2652,7 @@ static int ext4_writepages(struct addresstruct blk_plug plug;bool give_up_on_write = false; -percpu_down_read (&sbi->s_journal_flag_rwsem); +percpu_down_read (&sbi->s_writepages_rwsem);trace_ext4_writepages (inode, wbc);if (dax_mapping (mapping)) {
@@ -2853,7 +2853,7 @@ retry: out_writepages:trace_ext4_writepages_result (inode, wbc, ret, nr_to_write - wbc->nr_to_write); -percpu_up_read (&sbi->s_journal_flag_rwsem); +percpu_up_read (&sbi->s_writepages_rwsem);return ret; }
@@ -5688,7 +5688,7 @@ int ext4_change_inode_journal_flag(struc } } -percpu_down_write (&sbi->s_journal_flag_rwsem); +percpu_down_write (&sbi->s_writepages_rwsem);jbd2_journal_lock_updates (journal);/*
@@ -5705,7 +5705,7 @@ int ext4_change_inode_journal_flag(struc err =jbd2_journal_flush (journal);if (err <0 ) {jbd2_journal_unlock_updates (journal); -percpu_up_write (&sbi->s_journal_flag_rwsem); +percpu_up_write (&sbi->s_writepages_rwsem);ext4_inode_resume_unlocked_dio (inode);return err; }
@@ -5714,7 +5714,7 @@ int ext4_change_inode_journal_flag(strucext4_set_aops (inode);jbd2_journal_unlock_updates (journal); -percpu_up_write (&sbi->s_journal_flag_rwsem); +percpu_up_write (&sbi->s_writepages_rwsem);if (val)up_write (&EXT4_I (inode)->i_mmap_sem);
fs/ext4/super.c +3 -3
@@ -865,7 +865,7 @@ static void ext4_put_super(struct super_percpu_counter_destroy (&sbi->s_freeinodes_counter);percpu_counter_destroy (&sbi->s_dirs_counter);percpu_counter_destroy (&sbi->s_dirtyclusters_counter); -percpu_free_rwsem (&sbi->s_journal_flag_rwsem); +percpu_free_rwsem (&sbi->s_writepages_rwsem);brelse (sbi->s_sbh);#ifdef CONFIG_QUOTA for (i =0 ; i <EXT4_MAXQUOTAS ; i++)
@@ -4223,7 +4223,7 @@ no_journal: err =percpu_counter_init (&sbi->s_dirtyclusters_counter,0 ,GFP_KERNEL );if (!err) - err =percpu_init_rwsem (&sbi->s_journal_flag_rwsem); + err =percpu_init_rwsem (&sbi->s_writepages_rwsem);if (err) {ext4_msg (sb,KERN_ERR ,"insufficient memory" );
@@ -4322,7 +4322,7 @@ failed_mount6:percpu_counter_destroy (&sbi->s_freeinodes_counter);percpu_counter_destroy (&sbi->s_dirs_counter);percpu_counter_destroy (&sbi->s_dirtyclusters_counter); -percpu_free_rwsem (&sbi->s_journal_flag_rwsem); +percpu_free_rwsem (&sbi->s_writepages_rwsem); failed_mount5:ext4_ext_release (sb);ext4_release_system_zone (sb);
Greg Kroah-Hartman
maintainerPATCH 149/165 ext4: fix race between writepages and enabling EXT4_EXTENTS_FL
In reply to Greg Kroah-HartmanFrom: Eric Biggers <[email protected]>
commit cb85f4d23f794e24127f3e562cb3b54b0803f456 upstream.
If EXT4_EXTENTS_FL is set on an inode while ext4_writepages() is running on it, the following warning in ext4_add_complete_io() can be hit:
WARNING: CPU: 1 PID: 0 at fs/ext4/page-io.c:234 ext4_put_io_end_defer+0xf0/0x120
Here's a minimal reproducer (not 100% reliable) (root isn't required):
while true; do
sync
done &
while true; do
rm -f file
touch file
chattr -e file
echo X >> file
chattr +e file
done
The problem is that in ext4_writepages(), ext4_should_dioread_nolock() (which only returns true on extent-based files) is checked once to set the number of reserved journal credits, and also again later to select the flags for ext4_map_blocks() and copy the reserved journal handle to ext4_io_end::handle. But if EXT4_EXTENTS_FL is being concurrently set, the first check can see dioread_nolock disabled while the later one can see it enabled, causing the reserved handle to unexpectedly be NULL.
Since changing EXT4_EXTENTS_FL is uncommon, and there may be other races related to doing so as well, fix this by synchronizing changing EXT4_EXTENTS_FL with ext4_writepages() via the existing s_writepages_rwsem (previously called s_journal_flag_rwsem).
This was originally reported by syzbot without a reproducer at
https://syzkaller.appspot.com/bug?extid=2202a584a00fffd19fbf,
but now that dioread_nolock is the default I also started seeing this when running syzkaller locally.
--- fs/ext4/ext4.h | 5 ++++- fs/ext4/migrate.c | 27 +++++++++++++++++++-------- 2 files changed, 23 insertions(+), 9 deletions(-)
fs/ext4/ext4.h +4 -1
@@ -1514,7 +1514,10 @@ struct ext4_sb_info {struct ratelimit_state s_warning_ratelimit_state;struct ratelimit_state s_msg_ratelimit_state; -/* Barrier between changing inodes' journal flags and writepages ops. */ +/* +* Barrier between writepages ops and changing any inode's JOURNAL_DATA +* or EXTENTS flag. +*/ struct percpu_rw_semaphore s_writepages_rwsem;/* Encryption support */
fs/ext4/migrate.c +19 -8
@@ -434,6 +434,7 @@ static int free_ext_block(handle_t *handint ext4_ext_migrate (struct inode *inode) { +struct ext4_sb_info *sbi =EXT4_SB (inode->i_sb);handle_t *handle;int retval =0 , i;__le32 *i_data;
@@ -458,6 +459,8 @@ int ext4_ext_migrate(struct inode *inode*/ return retval; +percpu_down_write (&sbi->s_writepages_rwsem); +/* * Worst case we can touch the allocation bitmaps, a bgd * block, and a block to link in the orphan list. We do need
@@ -468,7 +471,7 @@ int ext4_ext_migrate(struct inode *inodeif (IS_ERR (handle)) { retval =PTR_ERR (handle); -return retval; + goto out_unlock; } goal = (((inode->i_ino -1 ) /EXT4_INODES_PER_GROUP (inode->i_sb)) *EXT4_INODES_PER_GROUP (inode->i_sb)) +1 ;
@@ -479,7 +482,7 @@ int ext4_ext_migrate(struct inode *inodeif (IS_ERR (tmp_inode)) { retval =PTR_ERR (tmp_inode);ext4_journal_stop (handle); -return retval; + goto out_unlock; }i_size_write (tmp_inode,i_size_read (inode));/*
@@ -521,7 +524,7 @@ int ext4_ext_migrate(struct inode *inode*/ ext4_orphan_del (NULL , tmp_inode); retval =PTR_ERR (handle); - goto out; + goto out_tmp_inode; } ei =EXT4_I (inode);
@@ -602,10 +605,11 @@ err_out:/* Reset the extent details */ ext4_ext_tree_init (handle, tmp_inode);ext4_journal_stop (handle); -out: +out_tmp_inode:unlock_new_inode (tmp_inode);iput (tmp_inode); - +out_unlock: +percpu_up_write (&sbi->s_writepages_rwsem);return retval; }
@@ -615,7 +619,8 @@ out:int ext4_ind_migrate (struct inode *inode) {struct ext4_extent_header *eh; -struct ext4_super_block *es =EXT4_SB (inode->i_sb)->s_es; +struct ext4_sb_info *sbi =EXT4_SB (inode->i_sb); +struct ext4_super_block *es = sbi->s_es;struct ext4_inode_info *ei =EXT4_I (inode);struct ext4_extent *ex;unsigned int i, len;
@@ -639,9 +644,13 @@ int ext4_ind_migrate(struct inode *inodeif (test_opt (inode->i_sb,DELALLOC ))ext4_alloc_da_blocks (inode); +percpu_down_write (&sbi->s_writepages_rwsem); + handle =ext4_journal_start (inode,EXT4_HT_MIGRATE ,1 ); -if (IS_ERR (handle)) -return PTR_ERR (handle); +if (IS_ERR (handle)) { + ret =PTR_ERR (handle); + goto out_unlock; + }down_write (&EXT4_I (inode)->i_data_sem); ret =ext4_ext_check_inode (inode);
@@ -676,5 +685,7 @@ int ext4_ind_migrate(struct inode *inode errout:ext4_journal_stop (handle);up_write (&EXT4_I (inode)->i_data_sem); +out_unlock: +percpu_up_write (&sbi->s_writepages_rwsem);return ret; }
Greg Kroah-Hartman
maintainerPATCH 150/165 KVM: nVMX: Refactor IO bitmap checks into helper function
In reply to Greg Kroah-HartmanFrom: Oliver Upton <[email protected]>
commit e71237d3ff1abf9f3388337cfebf53b96df2020d upstream.
Checks against the IO bitmap are useful for both instruction emulation and VM-exit reflection. Refactor the IO bitmap checks into a helper function.
--- arch/x86/kvm/vmx.c | 40 +++++++++++++++++++++++++++------------- 1 file changed, 27 insertions(+), 13 deletions(-)
arch/x86/kvm/vmx.c +27 -13
@@ -4641,6 +4641,26 @@ static bool cs_ss_rpl_check(struct kvm_v (ss.selector & SEGMENT_RPL_MASK)); } +static bool nested_vmx_check_io_bitmaps (struct kvm_vcpu *vcpu, +unsigned int port,int size); +static bool nested_vmx_exit_handled_io (struct kvm_vcpu *vcpu, +struct vmcs12 *vmcs12) +{ +unsigned long exit_qualification; +unsigned int port; +int size; + +if (!nested_cpu_has (vmcs12,CPU_BASED_USE_IO_BITMAPS )) +return nested_cpu_has (vmcs12,CPU_BASED_UNCOND_IO_EXITING ); + + exit_qualification =vmcs_readl (EXIT_QUALIFICATION ); + + port = exit_qualification >>16 ; + size = (exit_qualification &7 ) +1 ; + +return nested_vmx_check_io_bitmaps (vcpu, port, size); +} +/* * Check if guest state is valid. Returns true if valid, false if * not.
@@ -8026,23 +8046,17 @@ static int (*const kvm_vmx_exit_handlersstatic const int kvm_vmx_max_exit_handlers =ARRAY_SIZE (kvm_vmx_exit_handlers); -static bool nested_vmx_exit_handled_io (struct kvm_vcpu *vcpu, -struct vmcs12 *vmcs12) +/* +* Return true if an IO instruction with the specified port and size should cause +* a VM-exit into L1. +*/ +bool nested_vmx_check_io_bitmaps (struct kvm_vcpu *vcpu,unsigned int port, +int size) { -unsigned long exit_qualification; +struct vmcs12 *vmcs12 =get_vmcs12 (vcpu);gpa_t bitmap, last_bitmap; -unsigned int port; -int size;u8 b; -if (!nested_cpu_has (vmcs12,CPU_BASED_USE_IO_BITMAPS )) -return nested_cpu_has (vmcs12,CPU_BASED_UNCOND_IO_EXITING ); - - exit_qualification =vmcs_readl (EXIT_QUALIFICATION ); - - port = exit_qualification >>16 ; - size = (exit_qualification &7 ) +1 ; - last_bitmap = (gpa_t)-1 ; b =-1 ;
Greg Kroah-Hartman
maintainerPATCH 151/165 KVM: nVMX: Check IO instruction VM-exit conditions
In reply to Greg Kroah-HartmanFrom: Oliver Upton <[email protected]>
commit 35a571346a94fb93b5b3b6a599675ef3384bc75c upstream.
Consult the 'unconditional IO exiting' and 'use IO bitmaps' VM-execution controls when checking instruction interception. If the 'use IO bitmaps' VM-execution control is 1, check the instruction access against the IO bitmaps to determine if the instruction causes a VM-exit.
--- arch/x86/kvm/vmx.c | 59 ++++++++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 52 insertions(+), 7 deletions(-)
arch/x86/kvm/vmx.c +52 -7
@@ -4647,7 +4647,7 @@ static bool nested_vmx_exit_handled_io(s struct vmcs12 *vmcs12) {unsigned long exit_qualification; -unsigned int port; +unsigned short port;int size;if (!nested_cpu_has (vmcs12,CPU_BASED_USE_IO_BITMAPS ))
@@ -11349,6 +11349,39 @@ static void nested_vmx_entry_failure(strto_vmx (vcpu)->nested.sync_shadow_vmcs = true; } +static int vmx_check_intercept_io (struct kvm_vcpu *vcpu, +struct x86_instruction_info *info) +{ +struct vmcs12 *vmcs12 =get_vmcs12 (vcpu); +unsigned short port; +bool intercept; +int size; + +if (info->intercept == x86_intercept_in || + info->intercept == x86_intercept_ins) { + port = info->src_val; + size = info->dst_bytes; + }else { + port = info->dst_val; + size = info->src_bytes; + } + +/* +* If the 'use IO bitmaps' VM-execution control is 0, IO instruction +* VM-exits depend on the 'unconditional IO exiting' VM-execution +* control. +* +* Otherwise, IO instruction VM-exits are controlled by the IO bitmaps. +*/ +if (!nested_cpu_has (vmcs12,CPU_BASED_USE_IO_BITMAPS )) + intercept =nested_cpu_has (vmcs12, +CPU_BASED_UNCOND_IO_EXITING ); +else + intercept =nested_vmx_check_io_bitmaps (vcpu, port, size); + +return intercept ?X86EMUL_UNHANDLEABLE :X86EMUL_CONTINUE ; +} +static int vmx_check_intercept (struct kvm_vcpu *vcpu,struct x86_instruction_info *info,enum x86_intercept_stage stage)
@@ -11356,18 +11389,30 @@ static int vmx_check_intercept(struct kvstruct vmcs12 *vmcs12 =get_vmcs12 (vcpu);struct x86_emulate_ctxt *ctxt = &vcpu->arch.emulate_ctxt; +switch (info->intercept) {/* * RDPID causes #UD if disabled through secondary execution controls. * Because it is marked as EmulateOnUD, we need to intercept it here. */ -if (info->intercept == x86_intercept_rdtscp && - !nested_cpu_has2 (vmcs12,SECONDARY_EXEC_RDTSCP )) { - ctxt->exception.vector =UD_VECTOR ; - ctxt->exception.error_code_valid = false; -return X86EMUL_PROPAGATE_FAULT ; - } +case x86_intercept_rdtscp: +if (!nested_cpu_has2 (vmcs12,SECONDARY_EXEC_RDTSCP )) { + ctxt->exception.vector =UD_VECTOR ; + ctxt->exception.error_code_valid = false; +return X86EMUL_PROPAGATE_FAULT ; + } +break ; + +case x86_intercept_in: +case x86_intercept_ins: +case x86_intercept_out: +case x86_intercept_outs: +return vmx_check_intercept_io (vcpu, info);/* TODO: check more intercepts... */ +default : +break ; + } +return X86EMUL_UNHANDLEABLE ; }
Greg Kroah-Hartman
maintainerPATCH 152/165 KVM: apic: avoid calculating pending eoi from an uninitialized val
In reply to Greg Kroah-HartmanFrom: Miaohe Lin <[email protected]>
commit 23520b2def95205f132e167cf5b25c609975e959 upstream.
When pv_eoi_get_user() fails, 'val' may remain uninitialized and the return value of pv_eoi_get_pending() becomes random. Fix the issue by initializing the variable.
--- arch/x86/kvm/lapic.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
arch/x86/kvm/lapic.c +3 -1
@@ -532,9 +532,11 @@ static inline bool pv_eoi_enabled(structstatic bool pv_eoi_get_pending (struct kvm_vcpu *vcpu) {u8 val; -if (pv_eoi_get_user (vcpu, &val) <0 ) +if (pv_eoi_get_user (vcpu, &val) <0 ) {apic_debug ("Can't read EOI MSR value: 0x%llx\n" , (unsigned long long )vcpu->arch.pv_eoi.msr_val); +return false; + }return val &0x1 ; }
Greg Kroah-Hartman
maintainerPATCH 153/165 Btrfs: fix btrfs_wait_ordered_range() so that it waits for all ordered extents
In reply to Greg Kroah-HartmanFrom: Filipe Manana <[email protected]>
commit e75fd33b3f744f644061a4f9662bd63f5434f806 upstream.
In btrfs_wait_ordered_range() once we find an ordered extent that has finished with an error we exit the loop and don't wait for any other ordered extents that might be still in progress.
All the users of btrfs_wait_ordered_range() expect that there are no more ordered extents in progress after that function returns. So past fixes such like the ones from the two following commits:
ff612ba7849964 ("btrfs: fix panic during relocation after ENOSPC before
writeback happens")
28aeeac1dd3080 ("Btrfs: fix panic when starting bg cache writeout after
IO error")
don't work when there are multiple ordered extents in the range.
Fix that by making btrfs_wait_ordered_range() wait for all ordered extents even after it finds one that had an error.
--- fs/btrfs/ordered-data.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-)
fs/btrfs/ordered-data.c +6 -1
@@ -837,10 +837,15 @@ int btrfs_wait_ordered_range(struct inod }btrfs_start_ordered_extent (inode, ordered,1 ); end = ordered->file_offset; +/* +* If the ordered extent had an error save the error but don't +* exit without waiting first for all other ordered extents in +* the range to complete. +*/ if (test_bit (BTRFS_ORDERED_IOERR , &ordered->flags)) ret = -EIO ;btrfs_put_ordered_extent (ordered); -if (ret || end ==0 || end == start) +if (end ==0 || end == start)break ; end--; }
Greg Kroah-Hartman
maintainerPATCH 154/165 scsi: Revert "RDMA/isert: Fix a recently introduced regression related to logout"
In reply to Greg Kroah-HartmanFrom: Bart Van Assche <[email protected]>
commit 76261ada16dcc3be610396a46d35acc3efbda682 upstream.
Since commit 04060db41178 introduces soft lockups when toggling network interfaces, revert it.
--- drivers/infiniband/ulp/isert/ib_isert.c | 12 ++++++++++++ drivers/target/iscsi/iscsi_target.c | 6 +++--- 2 files changed, 15 insertions(+), 3 deletions(-)
drivers/infiniband/ulp/isert/ib_isert.c +12 -0
@@ -2555,6 +2555,17 @@ isert_wait4logout(struct isert_conn *ise } } +static void +isert_wait4cmds (struct iscsi_conn *conn) +{ +isert_info ("iscsi_conn %p\n" , conn); + +if (conn->sess) { +target_sess_cmd_list_set_waiting (conn->sess->se_sess); +target_wait_for_sess_cmds (conn->sess->se_sess); + } +} +/** * isert_put_unsol_pending_cmds() - Drop commands waiting for * unsolicitate dataout
@@ -2602,6 +2613,7 @@ static void isert_wait_conn(struct iscsiib_drain_qp (isert_conn->qp);isert_put_unsol_pending_cmds (conn); +isert_wait4cmds (conn);isert_wait4logout (isert_conn);queue_work (isert_release_wq, &isert_conn->release_work);
drivers/target/iscsi/iscsi_target.c +3 -3
@@ -4162,6 +4162,9 @@ int iscsit_close_connection(iscsit_stop_nopin_response_timer (conn);iscsit_stop_nopin_timer (conn); +if (conn->conn_transport->iscsit_wait_conn) + conn->conn_transport->iscsit_wait_conn (conn); +/* * During Connection recovery drop unacknowledged out of order * commands for this connection, and prepare the other commands
@@ -4247,9 +4250,6 @@ int iscsit_close_connection(target_sess_cmd_list_set_waiting (sess->se_sess);target_wait_for_sess_cmds (sess->se_sess); -if (conn->conn_transport->iscsit_wait_conn) - conn->conn_transport->iscsit_wait_conn (conn); -ahash_request_free (conn->conn_tx_hash);if (conn->conn_rx_hash) {struct crypto_ahash *tfm;
Greg Kroah-Hartman
maintainerPATCH 155/165 scsi: Revert "target: iscsi: Wait for all commands to finish before freeing a session"
In reply to Greg Kroah-HartmanFrom: Bart Van Assche <[email protected]>
commit 807b9515b7d044cf77df31f1af9d842a76ecd5cb upstream.
Since commit e9d3009cb936 introduced a regression and since the fix for that regression was not perfect, revert this commit.
--- drivers/target/iscsi/iscsi_target.c | 10 ++-------- include/scsi/iscsi_proto.h | 1 - 2 files changed, 2 insertions(+), 9 deletions(-)
drivers/target/iscsi/iscsi_target.c +2 -8
@@ -1168,9 +1168,7 @@ int iscsit_setup_scsi_cmd(struct iscsi_c hdr->cmdsn,be32_to_cpu (hdr->data_length), payload_length, conn->cid); -if (target_get_sess_cmd (&cmd->se_cmd, true) <0 ) -return iscsit_add_reject_cmd (cmd, -ISCSI_REASON_WAITING_FOR_LOGOUT , buf); +target_get_sess_cmd (&cmd->se_cmd, true); cmd->sense_reason =transport_lookup_cmd_lun (&cmd->se_cmd,scsilun_to_int (&hdr->lun));
@@ -1988,9 +1986,7 @@ iscsit_handle_task_mgt_cmd(struct iscsi_ conn->sess->se_sess,0 ,DMA_NONE , TCM_SIMPLE_TAG, cmd->sense_buffer + 2); -if (target_get_sess_cmd (&cmd->se_cmd, true) <0 ) -return iscsit_add_reject_cmd (cmd, -ISCSI_REASON_WAITING_FOR_LOGOUT , buf); +target_get_sess_cmd (&cmd->se_cmd, true);/* * TASK_REASSIGN for ERL=2 / connection stays inside of
@@ -4247,8 +4243,6 @@ int iscsit_close_connection(* must wait until they have completed. */ iscsit_check_conn_usage_count (conn); -target_sess_cmd_list_set_waiting (sess->se_sess); -target_wait_for_sess_cmds (sess->se_sess);ahash_request_free (conn->conn_tx_hash);if (conn->conn_rx_hash) {
include/scsi/iscsi_proto.h +0 -1
@@ -638,7 +638,6 @@ struct iscsi_reject {#define ISCSI_REASON_BOOKMARK_INVALID 9#define ISCSI_REASON_BOOKMARK_NO_RESOURCES 10#define ISCSI_REASON_NEGOTIATION_RESET 11 -#define ISCSI_REASON_WAITING_FOR_LOGOUT 12/* Max. number of Key=Value pairs in a text message */ #define MAX_KEY_VALUE_PAIRS 8192
Greg Kroah-Hartman
maintainerPATCH 156/165 usb: gadget: composite: Fix bMaxPower for SuperSpeedPlus
In reply to Greg Kroah-HartmanFrom: Jack Pham <[email protected]>
commit c724417baf162bd3e035659e22cdf990cfb0d917 upstream.
SuperSpeedPlus peripherals must report their bMaxPower of the configuration descriptor in units of 8mA as per the USB 3.2 specification. The current switch statement in encode_bMaxPower() only checks for USB_SPEED_SUPER but not USB_SPEED_SUPER_PLUS so the latter falls back to USB 2.0 encoding which uses 2mA units. Replace the switch with a simple if/else.
--- drivers/usb/gadget/composite.c | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-)
drivers/usb/gadget/composite.c +3 -5
@@ -437,12 +437,10 @@ static u8 encode_bMaxPower(enum usb_devi val =CONFIG_USB_GADGET_VBUS_DRAW ;if (!val)return 0 ; -switch (speed) { -case USB_SPEED_SUPER : -return DIV_ROUND_UP (val,8 ); -default : +if (speed <USB_SPEED_SUPER )return DIV_ROUND_UP (val,2 ); - } +else +return DIV_ROUND_UP (val,8 ); } static int config_buf(struct usb_configuration *config,
Greg Kroah-Hartman
maintainerPATCH 157/165 staging: greybus: use after free in gb_audio_manager_remove_all()
In reply to Greg Kroah-HartmanFrom: Dan Carpenter <[email protected]>
commit b7db58105b80fa9232719c8329b995b3addfab55 upstream.
When we call kobject_put() and it's the last reference to the kobject then it calls gb_audio_module_release() and frees module. We dereference "module" on the next line which is a use after free.
--- drivers/staging/greybus/audio_manager.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/staging/greybus/audio_manager.c +1 -1
@@ -90,8 +90,8 @@ void gb_audio_manager_remove_all(void)list_for_each_entry_safe (module, next, &modules_list, list) {list_del (&module->list); -kobject_put (&module->kobj);ida_simple_remove (&module_id, module->id); +kobject_put (&module->kobj); } is_empty =list_empty (&modules_list);
Greg Kroah-Hartman
maintainerPATCH 158/165 ecryptfs: replace BUG_ON with error handling code
In reply to Greg Kroah-HartmanFrom: Aditya Pakki <[email protected]>
commit 2c2a7552dd6465e8fde6bc9cccf8d66ed1c1eb72 upstream.
In crypt_scatterlist, if the crypt_stat argument is not set up correctly, the kernel crashes. Instead, by returning an error code upstream, the error is handled safely.
The issue is detected via a static analysis tool written by us.
--- fs/ecryptfs/crypto.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-)
fs/ecryptfs/crypto.c +4 -2
@@ -339,8 +339,10 @@ static int crypt_scatterlist(struct ecrystruct extent_crypt_result ecr;int rc =0 ; -BUG_ON (!crypt_stat || !crypt_stat->tfm - || !(crypt_stat->flags &ECRYPTFS_STRUCT_INITIALIZED )); +if (!crypt_stat || !crypt_stat->tfm + || !(crypt_stat->flags &ECRYPTFS_STRUCT_INITIALIZED )) +return -EINVAL ; +if (unlikely (ecryptfs_verbosity >0 )) {ecryptfs_printk (KERN_DEBUG ,"Key size [%zd]; key:\n" , crypt_stat->key_size);
Greg Kroah-Hartman
maintainerPATCH 159/165 ALSA: rawmidi: Avoid bit fields for state flags
In reply to Greg Kroah-HartmanFrom: Takashi Iwai <[email protected]>
commit dfa9a5efe8b932a84b3b319250aa3ac60c20f876 upstream.
The rawmidi state flags (opened, append, active_sensing) are stored in bit fields that can be potentially racy when concurrently accessed without any locks. Although the current code should be fine, there is also no any real benefit by keeping the bitfields for this kind of short number of members.
This patch changes those bit fields flags to the simple bool fields. There should be no size increase of the snd_rawmidi_substream by this change.
--- include/sound/rawmidi.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
include/sound/rawmidi.h +3 -3
@@ -92,9 +92,9 @@ struct snd_rawmidi_substream {struct list_head list;/* list of all substream for given stream */ int stream;/* direction */ int number;/* substream number */ - unsigned int opened: 1, /* open flag */ - append: 1, /* append flag (merge more streams) */ - active_sensing: 1; /* send active sensing when close */ +bool opened;/* open flag */ +bool append;/* append flag (merge more streams) */ +bool active_sensing;/* send active sensing when close */ int use_count;/* use counter (for output) */ size_t bytes;struct snd_rawmidi *rmidi;
Greg Kroah-Hartman
maintainerPATCH 160/165 ALSA: seq: Avoid concurrent access to queue flags
In reply to Greg Kroah-HartmanFrom: Takashi Iwai <[email protected]>
commit bb51e669fa49feb5904f452b2991b240ef31bc97 upstream.
The queue flags are represented in bit fields and the concurrent access may result in unexpected results. Although the current code should be mostly OK as it's only reading a field while writing other fields as KCSAN reported, it's safer to cover both with a proper spinlock protection.
This patch fixes the possible concurrent read by protecting with q->owner_lock. Also the queue owner field is protected as well since it's the field to be protected by the lock itself.
--- sound/core/seq/seq_queue.c | 20 ++++++++++++++++---- 1 file changed, 16 insertions(+), 4 deletions(-)
sound/core/seq/seq_queue.c +16 -4
@@ -415,6 +415,7 @@ int snd_seq_queue_check_access(int queueint snd_seq_queue_set_owner (int queueid,int client,int locked) {struct snd_seq_queue *q =queueptr (queueid); +unsigned long flags;if (q ==NULL )return -EINVAL ;
@@ -424,8 +425,10 @@ int snd_seq_queue_set_owner(int queueid,return -EPERM ; } +spin_lock_irqsave (&q->owner_lock, flags); q->locked = locked ?1 :0 ; q->owner = client; +spin_unlock_irqrestore (&q->owner_lock, flags);queue_access_unlock (q);queuefree (q);
@@ -564,15 +567,17 @@ void snd_seq_queue_client_termination(inunsigned long flags;int i;struct snd_seq_queue *q; +bool matched;for (i =0 ; i <SNDRV_SEQ_MAX_QUEUES ; i++) {if ((q =queueptr (i)) ==NULL )continue ;spin_lock_irqsave (&q->owner_lock, flags); -if (q->owner == client) + matched = (q->owner == client); +if (matched) q->klocked =1 ;spin_unlock_irqrestore (&q->owner_lock, flags); -if (q->owner == client) { +if (matched) {if (q->timer->running)snd_seq_timer_stop (q->timer);snd_seq_timer_reset (q->timer);
@@ -764,6 +769,8 @@ void snd_seq_info_queues_read(struct sndint i, bpm;struct snd_seq_queue *q;struct snd_seq_timer *tmr; +bool locked; +int owner;for (i =0 ; i <SNDRV_SEQ_MAX_QUEUES ; i++) {if ((q =queueptr (i)) ==NULL )
@@ -775,9 +782,14 @@ void snd_seq_info_queues_read(struct sndelse bpm =0 ; +spin_lock_irq (&q->owner_lock); + locked = q->locked; + owner = q->owner; +spin_unlock_irq (&q->owner_lock); +snd_iprintf (buffer,"queue %d: [%s]\n" , q->queue, q->name); -snd_iprintf (buffer,"owned by client : %d\n" , q->owner); -snd_iprintf (buffer,"lock status : %s\n" , q->locked ?"Locked" :"Free" ); +snd_iprintf (buffer,"owned by client : %d\n" , owner); +snd_iprintf (buffer,"lock status : %s\n" , locked ?"Locked" :"Free" );snd_iprintf (buffer,"queued time events : %d\n" ,snd_seq_prioq_avail (q->timeq));snd_iprintf (buffer,"queued tick events : %d\n" ,snd_seq_prioq_avail (q->tickq));snd_iprintf (buffer,"timer state : %s\n" , tmr->running ?"Running" :"Stopped" );
Greg Kroah-Hartman
maintainerPATCH 161/165 ALSA: seq: Fix concurrent access to queue current tick/time
In reply to Greg Kroah-HartmanFrom: Takashi Iwai <[email protected]>
commit dc7497795e014d84699c3b8809ed6df35352dd74 upstream.
snd_seq_check_queue() passes the current tick and time of the given queue as a pointer to snd_seq_prioq_cell_out(), but those might be updated concurrently by the seq timer update.
Fix it by retrieving the current tick and time via the proper helper functions at first, and pass those values to snd_seq_prioq_cell_out() later in the loops.
snd_seq_timer_get_cur_time() takes a new argument and adjusts with the current system time only when it's requested so; this update isn't needed for snd_seq_check_queue(), as it's called either from the interrupt handler or right after queuing.
Also, snd_seq_timer_get_cur_tick() is changed to read the value in the spinlock for the concurrency, too.
--- sound/core/seq/seq_clientmgr.c | 4 ++-- sound/core/seq/seq_queue.c | 9 ++++++--- sound/core/seq/seq_timer.c | 13 ++++++++++--- sound/core/seq/seq_timer.h | 3 ++- 4 files changed, 20 insertions(+), 9 deletions(-)
sound/core/seq/seq_clientmgr.c +2 -2
@@ -564,7 +564,7 @@ static int update_timestamp_of_queue(str event->queue = queue; event->flags &= ~SNDRV_SEQ_TIME_STAMP_MASK ;if (real_time) { - event->time.time =snd_seq_timer_get_cur_time (q->timer); + event->time.time =snd_seq_timer_get_cur_time (q->timer, true); event->flags |=SNDRV_SEQ_TIME_STAMP_REAL ; }else { event->time.tick =snd_seq_timer_get_cur_tick (q->timer);
@@ -1639,7 +1639,7 @@ static int snd_seq_ioctl_get_queue_statu tmr = queue->timer; status->events = queue->tickq->cells + queue->timeq->cells; - status->time =snd_seq_timer_get_cur_time (tmr); + status->time =snd_seq_timer_get_cur_time (tmr, true); status->tick =snd_seq_timer_get_cur_tick (tmr); status->running = tmr->running;
sound/core/seq/seq_queue.c +6 -3
@@ -261,6 +261,8 @@ void snd_seq_check_queue(struct snd_seq_ {unsigned long flags;struct snd_seq_event_cell *cell; +snd_seq_tick_time_t cur_tick; +snd_seq_real_time_t cur_time;if (q ==NULL )return ;
@@ -277,17 +279,18 @@ void snd_seq_check_queue(struct snd_seq_ __again:/* Process tick queue... */ + cur_tick =snd_seq_timer_get_cur_tick (q->timer);for (;;) { - cell =snd_seq_prioq_cell_out (q->tickq, - &q->timer->tick.cur_tick); + cell =snd_seq_prioq_cell_out (q->tickq, &cur_tick);if (!cell)break ;snd_seq_dispatch_event (cell, atomic, hop); }/* Process time queue... */ + cur_time =snd_seq_timer_get_cur_time (q->timer, false);for (;;) { - cell =snd_seq_prioq_cell_out (q->timeq, &q->timer->cur_time); + cell =snd_seq_prioq_cell_out (q->timeq, &cur_time);if (!cell)break ;snd_seq_dispatch_event (cell, atomic, hop);
sound/core/seq/seq_timer.c +10 -3
@@ -436,14 +436,15 @@ int snd_seq_timer_continue(struct snd_se }/* return current 'real' time. use timeofday() to get better granularity. */ -snd_seq_real_time_t snd_seq_timer_get_cur_time (struct snd_seq_timer *tmr) +snd_seq_real_time_t snd_seq_timer_get_cur_time (struct snd_seq_timer *tmr, +bool adjust_ktime) {snd_seq_real_time_t cur_time;unsigned long flags;spin_lock_irqsave (&tmr->lock, flags); cur_time = tmr->cur_time; -if (tmr->running) { +if (adjust_ktime && tmr->running) {struct timespec64 tm;ktime_get_ts64 (&tm);
@@ -460,7 +461,13 @@ snd_seq_real_time_t snd_seq_timer_get_cuhigh PPQ values) */ snd_seq_tick_time_t snd_seq_timer_get_cur_tick (struct snd_seq_timer *tmr) { -return tmr->tick.cur_tick; +snd_seq_tick_time_t cur_tick; +unsigned long flags; + +spin_lock_irqsave (&tmr->lock, flags); + cur_tick = tmr->tick.cur_tick; +spin_unlock_irqrestore (&tmr->lock, flags); +return cur_tick; }
sound/core/seq/seq_timer.h +2 -1
@@ -135,7 +135,8 @@ int snd_seq_timer_set_ppq(struct snd_seqint snd_seq_timer_set_position_tick (struct snd_seq_timer *tmr,snd_seq_tick_time_t position);int snd_seq_timer_set_position_time (struct snd_seq_timer *tmr,snd_seq_real_time_t position);int snd_seq_timer_set_skew (struct snd_seq_timer *tmr,unsigned int skew,unsigned int base); -snd_seq_real_time_t snd_seq_timer_get_cur_time (struct snd_seq_timer *tmr); +snd_seq_real_time_t snd_seq_timer_get_cur_time (struct snd_seq_timer *tmr, +bool adjust_ktime);snd_seq_tick_time_t snd_seq_timer_get_cur_tick (struct snd_seq_timer *tmr);extern int seq_default_timer_class;
Greg Kroah-Hartman
maintainerPATCH 162/165 netfilter: xt_hashlimit: limit the max size of hashtable
In reply to Greg Kroah-HartmanFrom: Cong Wang <[email protected]>
commit 8d0015a7ab76b8b1e89a3e5f5710a6e5103f2dd5 upstream.
The user-specified hashtable size is unbound, this could easily lead to an OOM or a hung task as we hold the global mutex while allocating and initializing the new hashtable.
Add a max value to cap both cfg->size and cfg->max, as suggested by Florian.
--- net/netfilter/xt_hashlimit.c | 10 ++++++++++ 1 file changed, 10 insertions(+)
net/netfilter/xt_hashlimit.c +10 -0
@@ -735,6 +735,8 @@ hashlimit_mt(const struct sk_buff *skb,return hashlimit_mt_common (skb, par, hinfo, &info->cfg,2 ); } +#define HASHLIMIT_MAX_SIZE 1048576 + static int hashlimit_mt_check_common(const struct xt_mtchk_param *par, struct xt_hashlimit_htable **hinfo, struct hashlimit_cfg2 *cfg,
@@ -745,6 +747,14 @@ static int hashlimit_mt_check_common(conif (cfg->gc_interval ==0 || cfg->expire ==0 )return -EINVAL ; +if (cfg->size >HASHLIMIT_MAX_SIZE ) { + cfg->size =HASHLIMIT_MAX_SIZE ; +pr_info_ratelimited ("size too large, truncated to %u\n" , cfg->size); + } +if (cfg->max >HASHLIMIT_MAX_SIZE ) { + cfg->max =HASHLIMIT_MAX_SIZE ; +pr_info_ratelimited ("max too large, truncated to %u\n" , cfg->max); + }if (par->family ==NFPROTO_IPV4 ) {if (cfg->srcmask >32 || cfg->dstmask >32 )return -EINVAL ;
Greg Kroah-Hartman
maintainerPATCH 163/165 ata: ahci: Add shutdown to freeze hardware resources of ahci
In reply to Greg Kroah-HartmanFrom: Prabhakar Kushwaha <[email protected]>
commit 10a663a1b15134a5a714aa515e11425a44d4fdf7 upstream.
device_shutdown() called from reboot or power_shutdown expect all devices to be shutdown. Same is true for even ahci pci driver. As no ahci shutdown function is implemented, the ata subsystem always remains alive with DMA & interrupt support. File system related calls should not be honored after device_shutdown().
So defining ahci pci driver shutdown to freeze hardware (mask interrupt, stop DMA engine and free DMA resources).
--- drivers/ata/ahci.c | 7 +++++++ drivers/ata/libata-core.c | 21 +++++++++++++++++++++ include/linux/libata.h | 1 + 3 files changed, 29 insertions(+)
drivers/ata/ahci.c +7 -0
@@ -86,6 +86,7 @@ enum board_ids {static int ahci_init_one (struct pci_dev *pdev,const struct pci_device_id *ent);static void ahci_remove_one (struct pci_dev *dev); +static void ahci_shutdown_one (struct pci_dev *dev);static int ahci_vt8251_hardreset (struct ata_link *link,unsigned int *class,unsigned long deadline); static int ahci_avn_hardreset(struct ata_link *link, unsigned int *class,
@@ -582,6 +583,7 @@ static struct pci_driver ahci_pci_driver .id_table = ahci_pci_tbl, .probe = ahci_init_one, .remove = ahci_remove_one, + .shutdown = ahci_shutdown_one, .driver = { .pm = &ahci_pci_pm_ops, },
@@ -1775,6 +1777,11 @@ static int ahci_init_one(struct pci_devreturn 0 ; } +static void ahci_shutdown_one (struct pci_dev *pdev) +{ +ata_pci_shutdown_one (pdev); +} +static void ahci_remove_one (struct pci_dev *pdev) {pm_runtime_get_noresume (&pdev->dev);
drivers/ata/libata-core.c +21 -0
@@ -6580,6 +6580,26 @@ void ata_pci_remove_one(struct pci_dev *ata_host_detach (host); } +void ata_pci_shutdown_one (struct pci_dev *pdev) +{ +struct ata_host *host =pci_get_drvdata (pdev); +int i; + +for (i =0 ; i < host->n_ports; i++) { +struct ata_port *ap = host->ports[i]; + + ap->pflags |=ATA_PFLAG_FROZEN ; + +/* Disable port interrupts */ +if (ap->ops->freeze) + ap->ops->freeze (ap); + +/* Stop the port DMA engines */ +if (ap->ops->port_stop) + ap->ops->port_stop (ap); + } +} +/* move to PCI subsystem */ int pci_test_config_bits (struct pci_dev *pdev,const struct pci_bits *bits) {
@@ -7200,6 +7220,7 @@ EXPORT_SYMBOL_GPL(ata_timing_cycle2mode)#ifdef CONFIG_PCI EXPORT_SYMBOL_GPL (pci_test_config_bits); +EXPORT_SYMBOL_GPL (ata_pci_shutdown_one);EXPORT_SYMBOL_GPL (ata_pci_remove_one);#ifdef CONFIG_PM EXPORT_SYMBOL_GPL (ata_pci_device_do_suspend);
include/linux/libata.h +1 -0
@@ -1222,6 +1222,7 @@ struct pci_bits { };extern int pci_test_config_bits (struct pci_dev *pdev,const struct pci_bits *bits); +extern void ata_pci_shutdown_one (struct pci_dev *pdev);extern void ata_pci_remove_one (struct pci_dev *pdev);#ifdef CONFIG_PM
Greg Kroah-Hartman
maintainerPATCH 164/165 xen: Enable interrupts when calling _cond_resched()
In reply to Greg Kroah-HartmanFrom: Thomas Gleixner <[email protected]>
commit 8645e56a4ad6dcbf504872db7f14a2f67db88ef2 upstream.
xen_maybe_preempt_hcall() is called from the exception entry point xen_do_hypervisor_callback with interrupts disabled.
_cond_resched() evades the might_sleep() check in cond_resched() which would have caught that and schedule_debug() unfortunately lacks a check for irqs_disabled().
Enable interrupts around the call and use cond_resched() to catch future issues.
--- drivers/xen/preempt.c | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
drivers/xen/preempt.c +3 -1
@@ -37,7 +37,9 @@ asmlinkage __visible void xen_maybe_pree* cpu. */ __this_cpu_write (xen_in_preemptible_hcall, false); -_cond_resched (); +local_irq_enable (); +cond_resched (); +local_irq_disable ();__this_cpu_write (xen_in_preemptible_hcall, true); } }
Greg Kroah-Hartman
maintainerPATCH 165/165 s390/mm: Explicitly compare PAGE_DEFAULT_KEY against zero in storage_key_init_range
In reply to Greg Kroah-HartmanFrom: Nathan Chancellor <[email protected]>
commit 380324734956c64cd060e1db4304f3117ac15809 upstream.
Clang warns:
In file included from ../arch/s390/purgatory/purgatory.c:10:
In file included from ../include/linux/kexec.h:18:
In file included from ../include/linux/crash_core.h:6:
In file included from ../include/linux/elfcore.h:5:
In file included from ../include/linux/user.h:1:
In file included from ../arch/s390/include/asm/user.h:11:
../arch/s390/include/asm/page.h:45:6: warning: converting the result of '<<' to a boolean always evaluates to false [-Wtautological-constant-compare]
if (PAGE_DEFAULT_KEY)
^
../arch/s390/include/asm/page.h:23:44: note: expanded from macro
'PAGE_DEFAULT_KEY'
#define PAGE_DEFAULT_KEY (PAGE_DEFAULT_ACC << 4)
^1 warning generated.
Explicitly compare this against zero to silence the warning as it is intended to be used in a boolean context.
--- arch/s390/include/asm/page.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/s390/include/asm/page.h +1 -1
@@ -35,7 +35,7 @@ void __storage_key_init_range(unsigned lstatic inline void storage_key_init_range (unsigned long start,unsigned long end) { -if (PAGE_DEFAULT_KEY ) +if (PAGE_DEFAULT_KEY !=0 )__storage_key_init_range (start, end); }
Quoted 8 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 4.9.215 release. There are 165 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Sat, 29 Feb 2020 13:21:24 +0000. Anything received after that time might be too late.
Building powerpc:defconfig ... failed
--------------
Error log:
In file included from include/linux/bug.h:4:0,
from include/linux/thread_info.h:11,
from include/asm-generic/preempt.h:4,
from ./arch/powerpc/include/generated/asm/preempt.h:1,
from include/linux/preempt.h:59,
from include/linux/spinlock.h:50,
from include/linux/seqlock.h:35,
from include/linux/time.h:5,
from include/uapi/linux/timex.h:56,
from include/linux/timex.h:56,
from include/linux/sched.h:19,
from arch/powerpc/kernel/signal_32.c:20:arch/powerpc/kernel/signal_32.c: In function ‘save_tm_user_regs’:arch/powerpc/kernel/signal_32.c:521:10: error: ‘tm_suspend_disabled’ undeclared
Also affects v4.14.y.
Guenter
Greg Kroah-Hartman
maintainerQuoted 25 lines · Guenter Roeck
Quoted 8 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 4.9.215 release. There are 165 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Sat, 29 Feb 2020 13:21:24 +0000. Anything received after that time might be too late.
Building powerpc:defconfig ... failed
--------------
Error log:
In file included frominclude/linux/bug.h:4:0,from include/linux/thread_info.h:11, from include/asm-generic/preempt.h:4, from ./arch/powerpc/include/generated/asm/preempt.h:1, from include/linux/preempt.h:59, from include/linux/spinlock.h:50, from include/linux/seqlock.h:35, from include/linux/time.h:5, from include/uapi/linux/timex.h:56, from include/linux/timex.h:56, from include/linux/sched.h:19, from arch/powerpc/kernel/signal_32.c:20:
Quoted 4 lines
arch/powerpc/kernel/signal_32.c: In function ‘save_tm_user_regs’:arch/powerpc/kernel/signal_32.c:521:10: error: ‘tm_suspend_disabled’ undeclaredAlso affects v4.14.y.
Thanks for letting me know, I've now dropped 3 powerpc patches from 4.14 and 4.9 and will push out a -rc2 for those trees in a few minutes.
greg k-h
Jon Hunter
maintainerQuoted 9 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 4.9.215 release. There are 165 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Sat, 29 Feb 2020 13:21:24 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
Quoted 8 lines
https://www.kernel.org/pub/linux/kernel/v4.x/stable-review/patch-4.9.215-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-4.9.y
and the diffstat can be found below.thanks,
greg k-h
All tests are passing for Tegra ...
Test results for stable-v4.9:
8 builds: 8 pass, 0 fail
16 boots: 16 pass, 0 fail
24 tests: 24 pass, 0 failLinux version: 4.9.215-rc1-gb8e4943d6bee
Boards tested: tegra124-jetson-tk1, tegra20-ventana,
tegra210-p2371-2180, tegra30-cardhu-a04
Cheers
Jon
Signature · 1 line
nvpublic
Quoted 8 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 4.9.215 release. There are 165 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Sat, 29 Feb 2020 13:21:24 +0000. Anything received after that time might be too late.
Build results:
total: 172 pass: 170 fail: 2
Failed builds:
powerpc:defconfig
powerpc:allmodconfig
Qemu test results:
total: 375 pass: 361 fail: 14 Failed tests: ppc64:mac99:ppc64_book3s_defconfig:smp:nvme:rootfs ppc64:pseries:pseries_defconfig:initrd ppc64:pseries:pseries_defconfig:scsi:rootfs ppc64:pseries:pseries_defconfig:usb:rootfs ppc64:pseries:pseries_defconfig:sdhci:mmc:rootfs ppc64:pseries:pseries_defconfig:nvme:rootfs ppc64:pseries:pseries_defconfig:little:initrd ppc64:pseries:pseries_defconfig:little:scsi:rootfs ppc64:pseries:pseries_defconfig:little:usb:rootfs ppc64:pseries:pseries_defconfig:little:scsi[MEGASAS]:rootfs ppc64:pseries:pseries_defconfig:little:scsi[FUSION]:rootfs ppc64:pseries:pseries_defconfig:little:sdhci:mmc:rootfs ppc64:pseries:pseries_defconfig:little:nvme:rootfs ppc64:powernv:powernv_defconfig:initrd
Failures as already reported.
Guenter
Quoted 10 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 4.9.215 release. There are 165 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Sat, 29 Feb 2020 13:21:24 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
Quoted 8 lines
https://www.kernel.org/pub/linux/kernel/v4.x/stable-review/patch-4.9.215-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-4.9.y
and the diffstat can be found below.thanks,
greg k-h
Results from Linaro’s test farm.
No regressions on arm64, arm, x86_64, and i386.
Summary
------------------------------------------------------------------------
kernel: 4.9.215-rc1
git repo: https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.git
git branch: linux-4.9.y
git commit: b8e4943d6bee55c8a2c077fc7639d0b8e8127e1a
git describe: v4.9.214-166-gb8e4943d6bee
Test details: https://qa-reports.linaro.org/lkft/linux-stable-rc-4.9-oe/build/v4.9.214-166-gb8e4943d6bee
No regressions (compared to build v4.9.214)
No fixes (compared to build v4.9.214)
Ran 26738 total tests in the following environments and test suites.
Environments
--------------
- dragonboard-410c - arm64
- hi6220-hikey - arm64
- i386
- juno-r2 - arm64
- qemu_arm
- qemu_arm64
- qemu_i386
- qemu_x86_64
- x15 - arm
- x86_64
Test Suites
-----------
* build
* install-android-platform-tools-r2600
* kselftest
* libhugetlbfs
* linux-log-parser
* ltp-cap_bounds-tests
* ltp-commands-tests
* ltp-containers-tests
* ltp-cpuhotplug-tests
* ltp-dio-tests
* ltp-fcntl-locktests-tests
* ltp-filecaps-tests
* ltp-fs-tests
* ltp-fs_bind-tests
* ltp-fs_perms_simple-tests
* ltp-fsx-tests
* ltp-hugetlb-tests
* ltp-io-tests
* ltp-ipc-tests
* ltp-math-tests
* ltp-mm-tests
* ltp-nptl-tests
* ltp-pty-tests
* ltp-sched-tests
* ltp-securebits-tests
* ltp-syscalls-tests
* perf
* v4l2-compliance
* ltp-cve-tests
* network-basic-tests
* spectre-meltdown-checker-test
* ltp-open-posix-tests
* kvm-unit-tests
* ltp-cap_bounds-64k-page_size-tests
* ltp-cap_bounds-kasan-tests
* ltp-commands-64k-page_size-tests
* ltp-commands-kasan-tests
* ltp-containers-64k-page_size-tests
* ltp-containers-kasan-tests
* ltp-cpuhotplug-64k-page_size-tests
* ltp-cpuhotplug-kasan-tests
* ltp-crypto-64k-page_size-tests
* ltp-crypto-kasan-tests
* ltp-crypto-tests
* ltp-cve-64k-page_size-tests
* ltp-cve-kasan-tests
* ltp-dio-64k-page_size-tests
* ltp-dio-kasan-tests
* ltp-fcntl-locktests-64k-page_size-tests
* ltp-fcntl-locktests-kasan-tests
* ltp-filecaps-64k-page_size-tests
* ltp-filecaps-kasan-tests
* ltp-fs-64k-page_size-tests
* ltp-fs-kasan-tests
* ltp-fs_bind-64k-page_size-tests
* ltp-fs_bind-kasan-tests
* ltp-fs_perms_simple-64k-page_size-tests
* ltp-fs_perms_simple-kasan-tests
* ltp-fsx-64k-page_size-tests
* ltp-fsx-kasan-tests
* ltp-hugetlb-64k-page_size-tests
* ltp-hugetlb-kasan-tests
* ltp-io-64k-page_size-tests
* ltp-io-kasan-tests
* ltp-ipc-64k-page_size-tests
* ltp-ipc-kasan-tests
* ltp-math-64k-page_size-tests
* ltp-math-kasan-tests
* ltp-mm-64k-page_size-tests
* ltp-mm-kasan-tests
* ltp-nptl-64k-page_size-tests
* ltp-nptl-kasan-tests
* ltp-pty-64k-page_size-tests
* ltp-pty-kasan-tests
* ltp-sched-64k-page_size-tests
* ltp-sched-kasan-tests
* ltp-securebits-64k-page_size-tests
* ltp-securebits-kasan-tests
* ltp-syscalls-64k-page_size-tests
* ltp-syscalls-compat-tests
* ltp-syscalls-kasan-tests
* prep-tmp-disk
* ssuite
Signature · 2 lines
Linaro LKFT https://lkft.linaro.org
Quoted 9 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 4.9.215 release. There are 165 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Sat, 29 Feb 2020 13:21:24 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
Quoted 9 lines
https://www.kernel.org/pub/linux/kernel/v4.x/stable-review/patch-4.9.215-rc1.gzor in the git tree and branch at:
git://git.kernel.org/pub/scm/linux/kernel/git/stable/linux-stable-rc.gitlinux-4.9.y
and the diffstat can be found below.thanks,
greg k-h
Compiled and booted on my test system. No dmesg regressions.
thanks,
-- Shuah
Greg Kroah-Hartman
maintainerQuoted 10 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 4.9.215 release. There are 165 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Sat, 29 Feb 2020 13:21:24 +0000. Anything received after that time might be too late.
The whole patch series can be found in one patch at:
https://www.kernel.org/pub/linux/kernel/v4.x/stable-review/patch-4.9.215-rc1.gz
-rc2 is out to hopefully resolve the powerpc build issues that were found:
https://www.kernel.org/pub/linux/kernel/v4.x/stable-review/patch-4.9.215-rc2.gz
Quoted 9 lines · Greg Kroah-Hartman
Quoted 8 lines · Greg Kroah-Hartman
This is the start of the stable review cycle for the 4.9.215 release. There are 165 patches in this series, all will be posted as a response to this one. If anyone has any issues with these being applied, please let me know.
Responses should be made by Sat, 29 Feb 2020 13:21:24 +0000. Anything received after that time might be too late.
Quoted 7 lines
Quoted 2 lines
The whole patch series can be found in one patch at:
https://www.kernel.org/pub/linux/kernel/v4.x/stable-review/patch-4.9.215-rc1.gz-rc2 is out to hopefully resolve the powerpc build issues that were found:
https://www.kernel.org/pub/linux/kernel/v4.x/stable-review/patch-4.9.215-rc2.gz
For v4.9.214-163-g176b68c72aeb:
Build results:
total: 172 pass: 172 fail: 0 Qemu test results: total: 375 pass: 375 fail: 0
Guenter