crypto: qcom-rng - Fix qcom_rng_of_match unused warning
Subsystems (11)
Sasha Levin
maintainerPATCH 1/21 crypto: qcom-rng - Fix qcom_rng_of_match unused warning
From: Herbert Xu <[email protected]>
[ Upstream commit 882aa6525cabcfa0cea61e1a19c9af4c543118ac ]
Module device tables need to be declared as maybe_unused because they will be unused when built-in and the corresponding option is also disabled.
This patch adds the maybe_unused attributes to OF and ACPI. This also allows us to remove the ifdef around the ACPI data structure.
--- drivers/crypto/qcom-rng.c | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-)
drivers/crypto/qcom-rng.c +3 -4
@@ -9,6 +9,7 @@#include <linux/crypto.h> #include <linux/io.h> #include <linux/iopoll.h> +#include <linux/kernel.h> #include <linux/module.h> #include <linux/of.h> #include <linux/platform_device.h>
@@ -201,15 +202,13 @@ static int qcom_rng_remove(struct platform_device *pdev)return 0 ; } -#if IS_ENABLED (CONFIG_ACPI ) -static const struct acpi_device_id qcom_rng_acpi_match[] = { +static const struct acpi_device_id __maybe_unused qcom_rng_acpi_match[] = { { .id ="QCOM8160" , .driver_data =1 }, {} };MODULE_DEVICE_TABLE (acpi, qcom_rng_acpi_match); -#endif -static const struct of_device_id qcom_rng_of_match[] = { +static const struct of_device_id __maybe_unused qcom_rng_of_match[] = { { .compatible ="qcom,prng" , .data = (void *)0 }, { .compatible ="qcom,prng-ee" , .data = (void *)1 }, {}
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 2/21 crypto: ccp - Add a quirk to firmware update
From: Jarkko Sakkinen <[email protected]>
[ Upstream commit b3b9fdf1a9be4266b01a2063b1f37cdc20806e3b ]
A quirk for fixing the committed TCB version, when upgrading from a firmware version earlier than 1.50. This is a known issue, and the documented workaround is to load the firmware twice.
Currently, this issue requires the following workaround:
sudo modprobe -r kvm_amd
sudo modprobe -r ccp
sudo modprobe ccp
sudo modprobe kvm_amd
Implement this workaround inside kernel by checking whether the API version is less than 1.50, and if so, download the firmware twice. This addresses the TCB version issue.
--- drivers/crypto/ccp/sev-dev.c | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-)
drivers/crypto/ccp/sev-dev.c +14 -2
@@ -555,6 +555,11 @@ static int sev_update_firmware(struct device *dev)struct page *p;u64 data_size; +if (!sev_version_greater_or_equal (0 ,15 )) { +dev_dbg (dev,"DOWNLOAD_FIRMWARE not supported\n" ); +return -1 ; + } +if (sev_get_firmware (dev, &firmware) == -ENOENT ) {dev_dbg (dev,"No SEV firmware file present\n" );return -1 ;
@@ -587,6 +592,14 @@ static int sev_update_firmware(struct device *dev) data->len = firmware->size; ret =sev_do_cmd (SEV_CMD_DOWNLOAD_FIRMWARE , data, &error); + +/* +* A quirk for fixing the committed TCB version, when upgrading from +* earlier firmware version than 1.50. +*/ +if (!ret && !sev_version_greater_or_equal (1 ,50 )) + ret =sev_do_cmd (SEV_CMD_DOWNLOAD_FIRMWARE , data, &error); +if (ret)dev_dbg (dev,"Failed to update SEV firmware: %#x\n" , error);else
@@ -1091,8 +1104,7 @@ void sev_pci_init(void)if (sev_get_api_version ()) goto err; -if (sev_version_greater_or_equal (0 ,15 ) && -sev_update_firmware (sev->dev) ==0 ) +if (sev_update_firmware (sev->dev) ==0 )sev_get_api_version ();/* Obtain the TMR memory area for SEV-ES use */
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 3/21 gfs2: Switch from strlcpy to strscpy
In reply to Sasha LevinFrom: Andreas Gruenbacher <[email protected]>
[ Upstream commit 204c0300c4e99707e9fb6e57840aa1127060e63f ]
Switch from strlcpy to strscpy and make sure that @count is the size of the smaller of the source and destination buffers. This prevents reading beyond the end of the source buffer when the source string isn't null terminated.
Found by a modified version of syzkaller.
--- fs/gfs2/ops_fstype.c | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-)
fs/gfs2/ops_fstype.c +7 -5
@@ -385,8 +385,10 @@ static int init_names(struct gfs2_sbd *sdp, int silent)if (!table[0 ]) table = sdp->sd_vfs->s_id; -strlcpy (sdp->sd_proto_name, proto,GFS2_FSNAME_LEN ); -strlcpy (sdp->sd_table_name, table,GFS2_FSNAME_LEN ); +BUILD_BUG_ON (GFS2_LOCKNAME_LEN >GFS2_FSNAME_LEN ); + +strscpy (sdp->sd_proto_name, proto,GFS2_LOCKNAME_LEN ); +strscpy (sdp->sd_table_name, table,GFS2_LOCKNAME_LEN ); table = sdp->sd_table_name;while ((table =strchr (table,'/' )))
@@ -1443,13 +1445,13 @@ static int gfs2_parse_param(struct fs_context *fc, struct fs_parameter *param)switch (o) {case Opt_lockproto: -strlcpy (args->ar_lockproto, param->string,GFS2_LOCKNAME_LEN ); +strscpy (args->ar_lockproto, param->string,GFS2_LOCKNAME_LEN );break ;case Opt_locktable: -strlcpy (args->ar_locktable, param->string,GFS2_LOCKNAME_LEN ); +strscpy (args->ar_locktable, param->string,GFS2_LOCKNAME_LEN );break ;case Opt_hostdata: -strlcpy (args->ar_hostdata, param->string,GFS2_LOCKNAME_LEN ); +strscpy (args->ar_hostdata, param->string,GFS2_LOCKNAME_LEN );break ;case Opt_spectator: args->ar_spectator =1 ;
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 4/21 powerpc/hw_breakpoint: Avoid relying on caller synchronization
In reply to Sasha LevinFrom: Marco Elver <[email protected]>
[ Upstream commit f95e5a3d59011eec1257d0e76de1e1f8969d426f ]
Internal data structures (cpu_bps, task_bps) of powerpc's hw_breakpoint implementation have relied on nr_bp_mutex serializing access to them.
Before overhauling synchronization of kernel/events/hw_breakpoint.c, introduce 2 spinlocks to synchronize cpu_bps and task_bps respectively, thus avoiding reliance on callers synchronizing powerpc's hw_breakpoint.
--- arch/powerpc/kernel/hw_breakpoint.c | 53 ++++++++++++++++++++++------- 1 file changed, 40 insertions(+), 13 deletions(-)
arch/powerpc/kernel/hw_breakpoint.c +40 -13
@@ -15,6 +15,7 @@#include <linux/kernel.h> #include <linux/sched.h> #include <linux/smp.h> +#include <linux/spinlock.h> #include <linux/debugfs.h> #include <linux/init.h>
@@ -129,7 +130,14 @@ struct breakpoint {bool ptrace_bp; }; +/* +* While kernel/events/hw_breakpoint.c does its own synchronization, we cannot +* rely on it safely synchronizing internals here; however, we can rely on it +* not requesting more breakpoints than available. +*/ +static DEFINE_SPINLOCK (cpu_bps_lock); static DEFINE_PER_CPU(struct breakpoint *, cpu_bps[HBP_NUM_MAX]); +static DEFINE_SPINLOCK (task_bps_lock);static LIST_HEAD (task_bps);static struct breakpoint *alloc_breakpoint (struct perf_event *bp)
@@ -174,7 +182,9 @@ static int task_bps_add(struct perf_event *bp)if (IS_ERR (tmp))return PTR_ERR (tmp); +spin_lock (&task_bps_lock);list_add (&tmp->list, &task_bps); +spin_unlock (&task_bps_lock);return 0 ; }
@@ -182,6 +192,7 @@ static void task_bps_remove(struct perf_event *bp) {struct list_head *pos, *q; +spin_lock (&task_bps_lock);list_for_each_safe (pos, q, &task_bps) { struct breakpoint *tmp = list_entry(pos, struct breakpoint, list);
@@ -191,6 +202,7 @@ static void task_bps_remove(struct perf_event *bp)break ; } } +spin_unlock (&task_bps_lock); }/*
@@ -200,12 +212,17 @@ static void task_bps_remove(struct perf_event *bp)static bool all_task_bps_check (struct perf_event *bp) {struct breakpoint *tmp; +bool ret = false; +spin_lock (&task_bps_lock);list_for_each_entry (tmp, &task_bps, list) { -if (!can_co_exist (tmp, bp)) -return true; +if (!can_co_exist (tmp, bp)) { + ret = true; +break ; + } } -return false; +spin_unlock (&task_bps_lock); +return ret; }/*
@@ -215,13 +232,18 @@ static bool all_task_bps_check(struct perf_event *bp)static bool same_task_bps_check (struct perf_event *bp) {struct breakpoint *tmp; +bool ret = false; +spin_lock (&task_bps_lock);list_for_each_entry (tmp, &task_bps, list) {if (tmp->bp->hw.target == bp->hw.target && - !can_co_exist (tmp, bp)) -return true; + !can_co_exist (tmp, bp)) { + ret = true; +break ; + } } -return false; +spin_unlock (&task_bps_lock); +return ret; }static int cpu_bps_add (struct perf_event *bp)
@@ -234,6 +256,7 @@ static int cpu_bps_add(struct perf_event *bp)if (IS_ERR (tmp))return PTR_ERR (tmp); +spin_lock (&cpu_bps_lock); cpu_bp =per_cpu_ptr (cpu_bps, bp->cpu);for (i =0 ; i <nr_wp_slots (); i++) {if (!cpu_bp[i]) {
@@ -241,6 +264,7 @@ static int cpu_bps_add(struct perf_event *bp)break ; } } +spin_unlock (&cpu_bps_lock);return 0 ; }
@@ -249,6 +273,7 @@ static void cpu_bps_remove(struct perf_event *bp)struct breakpoint **cpu_bp;int i =0 ; +spin_lock (&cpu_bps_lock); cpu_bp =per_cpu_ptr (cpu_bps, bp->cpu);for (i =0 ; i <nr_wp_slots (); i++) {if (!cpu_bp[i])
@@ -260,19 +285,25 @@ static void cpu_bps_remove(struct perf_event *bp)break ; } } +spin_unlock (&cpu_bps_lock); }static bool cpu_bps_check (int cpu,struct perf_event *bp) {struct breakpoint **cpu_bp; +bool ret = false;int i; +spin_lock (&cpu_bps_lock); cpu_bp =per_cpu_ptr (cpu_bps, cpu);for (i =0 ; i <nr_wp_slots (); i++) { -if (cpu_bp[i] && !can_co_exist (cpu_bp[i], bp)) -return true; +if (cpu_bp[i] && !can_co_exist (cpu_bp[i], bp)) { + ret = true; +break ; + } } -return false; +spin_unlock (&cpu_bps_lock); +return ret; }static bool all_cpu_bps_check (struct perf_event *bp)
@@ -286,10 +317,6 @@ static bool all_cpu_bps_check(struct perf_event *bp)return false; } -/* -* We don't use any locks to serialize accesses to cpu_bps or task_bps -* because are already inside nr_bp_mutex. -*/ int arch_reserve_bp_slot (struct perf_event *bp) {int ret;
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 5/21 cgroup: Remove data-race around cgrp_dfl_visible
In reply to Sasha LevinFrom: Tejun Heo <[email protected]>
[ Upstream commit dc79ec1b232ad2c165d381d3dd2626df4ef9b5a4 ]
There's a seemingly harmless data-race around cgrp_dfl_visible detected by kernel concurrency sanitizer. Let's remove it by throwing WRITE/READ_ONCE at it.
--- kernel/cgroup/cgroup.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
kernel/cgroup/cgroup.c +2 -2
@@ -2152,7 +2152,7 @@ static int cgroup_get_tree(struct fs_context *fc)struct cgroup_fs_context *ctx =cgroup_fc2context (fc);int ret; - cgrp_dfl_visible = true; +WRITE_ONCE (cgrp_dfl_visible, true);cgroup_get_live (&cgrp_dfl_root.cgrp); ctx->root = &cgrp_dfl_root;
@@ -6067,7 +6067,7 @@ int proc_cgroup_show(struct seq_file *m, struct pid_namespace *ns,struct cgroup *cgrp;int ssid, count =0 ; -if (root == &cgrp_dfl_root && !cgrp_dfl_visible) +if (root == &cgrp_dfl_root && !READ_ONCE (cgrp_dfl_visible))continue ;seq_printf (m,"%d:" , root->hierarchy_id);
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 6/21 of/fdt: Don't calculate initrd size from DT if start > end
In reply to Sasha LevinFrom: Marek Bykowski <[email protected]>
[ Upstream commit d5e3050c0feb8bf7b9a75482fafcc31b90257926 ]
If the properties 'linux,initrd-start' and 'linux,initrd-end' of the chosen node populated from the bootloader, eg. U-Boot, are so that start > end, then the phys_initrd_size calculated from end - start is negative that subsequently gets converted to a high positive value for being unsigned long long. Then, the memory region with the (invalid) size is added to the bootmem and attempted being paged in paging_init() that results in the kernel fault.
For example, on the FVP ARM64 system I'm running, the U-Boot populates the 'linux,initrd-start' with 8800_0000 and 'linux,initrd-end' with 0. The phys_initrd_size calculated is then ffff_ffff_7800_0000 (= 0 - 8800_0000 = -8800_0000 + ULLONG_MAX + 1). paging_init() then attempts to map the address 8800_0000 + ffff_ffff_7800_0000 and oops'es as below.
It should be stressed, it is generally a fault of the bootloader's with the kernel relying on it, however we should not allow the bootloader's misconfiguration to lead to the kernel oops. Not only the kernel should be bullet proof against it but also finding the root cause of the paging fault spanning over the bootloader, DT, and kernel may happen is not so easy.
Unable to handle kernel paging request at virtual address fffffffefe43c000
Mem abort info:
ESR = 0x96000007
EC = 0x25: DABT (current EL), IL = 32 bits
SET = 0, FnV = 0
EA = 0, S1PTW = 0
Data abort info:
ISV = 0, ISS = 0x00000007
CM = 0, WnR = 0
swapper pgtable: 4k pages, 39-bit VAs, pgdp=0000000080e3d000
[fffffffefe43c000] pgd=0000000080de9003, pud=0000000080de9003
Unable to handle kernel paging request at virtual address ffffff8000de9f90
Mem abort info:
ESR = 0x96000005
EC = 0x25: DABT (current EL), IL = 32 bits
SET = 0, FnV = 0
EA = 0, S1PTW = 0
Data abort info:
ISV = 0, ISS = 0x00000005
CM = 0, WnR = 0
swapper pgtable: 4k pages, 39-bit VAs, pgdp=0000000080e3d000
[ffffff8000de9f90] pgd=0000000000000000, pud=0000000000000000
Internal error: Oops: 96000005 [#1] PREEMPT SMP
Modules linked in:
CPU: 0 PID: 0 Comm: swapper Not tainted 5.4.51-yocto-standard #1
Hardware name: FVP Base (DT)
pstate: 60000085 (nZCv daIf -PAN -UAO)
pc : show_pte+0x12c/0x1b4
lr : show_pte+0x100/0x1b4
sp : ffffffc010ce3b30
x29: ffffffc010ce3b30 x28: ffffffc010ceed80
x27: fffffffefe43c000 x26: fffffffefe43a028
x25: 0000000080bf0000 x24: 0000000000000025
x23: ffffffc010b8d000 x22: ffffffc010e3d000
x23: ffffffc010b8d000 x22: ffffffc010e3d000
x21: 0000000080de9000 x20: ffffff7f80000f90
x19: fffffffefe43c000 x18: 0000000000000030
x17: 0000000000001400 x16: 0000000000001c00
x15: ffffffc010cef1b8 x14: ffffffffffffffff
x13: ffffffc010df1f40 x12: ffffffc010df1b70
x11: ffffffc010ce3b30 x10: ffffffc010ce3b30
x9 : 00000000ffffffc8 x8 : 0000000000000000
x7 : 000000000000000f x6 : ffffffc010df16e8
x5 : 0000000000000000 x4 : 0000000000000000
x3 : 00000000ffffffff x2 : 0000000000000000
x1 : 0000008080000000 x0 : ffffffc010af1d68
Call trace:
show_pte+0x12c/0x1b4
die_kernel_fault+0x54/0x78
__do_kernel_fault+0x11c/0x128
do_translation_fault+0x58/0xac
do_mem_abort+0x50/0xb0
el1_da+0x1c/0x90
__create_pgd_mapping+0x348/0x598
paging_init+0x3f0/0x70d0
setup_arch+0x2c0/0x5d4
start_kernel+0x94/0x49c
Code: 92748eb5 900052a0 9135a000 cb010294 (f8756a96) --- drivers/of/fdt.c | 2 ++ 1 file changed, 2 insertions(+)
drivers/of/fdt.c +2 -0
@@ -937,6 +937,8 @@ static void __init early_init_dt_check_for_initrd(unsigned long node)if (!prop)return ; end =of_read_number (prop, len/4 ); +if (start > end) +return ;__early_init_dt_declare_initrd (start, end); phys_initrd_start = start;
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 7/21 objtool,x86: Teach decode about LOOP* instructions
In reply to Sasha LevinFrom: Peter Zijlstra <[email protected]>
[ Upstream commit 7a7621dfa417aa3715d2a3bd1bdd6cf5018274d0 ]
When 'discussing' control flow Masami mentioned the LOOP* instructions and I realized objtool doesn't decode them properly.
As it turns out, these instructions are somewhat inefficient and as such unlikely to be emitted by the compiler (a few vmlinux.o checks can't find a single one) so this isn't critical, but still, best to decode them properly.
--- tools/objtool/arch/x86/decode.c | 6 ++++++ 1 file changed, 6 insertions(+)
tools/objtool/arch/x86/decode.c +6 -0
@@ -574,6 +574,12 @@ int arch_decode_instruction(const struct elf *elf, const struct section *sec, *type =INSN_CONTEXT_SWITCH ;break ; +case 0xe0 :/* loopne */ +case 0xe1 :/* loope */ +case 0xe2 :/* loop */ + *type =INSN_JUMP_CONDITIONAL ; +break ; +case 0xe8 : *type =INSN_CALL ;/*
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 8/21 locking/rwsem: Disable preemption while trying for rwsem lock
In reply to Sasha LevinFrom: Gokul krishna Krishnakumar <[email protected]>
[ Upstream commit 48dfb5d2560d36fb16c7d430c229d1604ea7d185 ]
Make the region inside the rwsem_write_trylock non preemptible.
We observe RT task is hogging CPU when trying to acquire rwsem lock which was acquired by a kworker task but before the rwsem owner was set.
Here is the scenario:
1. CFS task (affined to a particular CPU) takes rwsem lock.
2. CFS task gets preempted by a RT task before setting owner.
3. RT task (FIFO) is trying to acquire the lock, but spinning until RT throttling happens for the lock as the lock was taken by CFS task.
This patch attempts to fix the above issue by disabling preemption until owner is set for the lock. While at it also fix the issues at the places where rwsem_{set,clear}_owner() are called.
This also adds lockdep annotation of preemption disable in rwsem_{set,clear}_owner() on Peter Z. suggestion.
--- kernel/locking/rwsem.c | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-)
kernel/locking/rwsem.c +12 -2
@@ -133,14 +133,19 @@* the owner value concurrently without lock. Read from owner, however, * may not need READ_ONCE() as long as the pointer value is only used * for comparison and isn't being dereferenced. +* +* Both rwsem_{set,clear}_owner() functions should be in the same +* preempt disable section as the atomic op that changes sem->count. */ static inline void rwsem_set_owner (struct rw_semaphore *sem) { +lockdep_assert_preemption_disabled ();atomic_long_set (&sem->owner, (long )current); }static inline void rwsem_clear_owner (struct rw_semaphore *sem) { +lockdep_assert_preemption_disabled ();atomic_long_set (&sem->owner,0 ); }
@@ -251,13 +256,16 @@ static inline bool rwsem_read_trylock(struct rw_semaphore *sem, long *cntp)static inline bool rwsem_write_trylock (struct rw_semaphore *sem) {long tmp =RWSEM_UNLOCKED_VALUE ; +bool ret = false; +preempt_disable ();if (atomic_long_try_cmpxchg_acquire (&sem->count, &tmp,RWSEM_WRITER_LOCKED )) {rwsem_set_owner (sem); -return true; + ret = true; } -return false; +preempt_enable (); +return ret; }/*
@@ -1333,8 +1341,10 @@ static inline void __up_write(struct rw_semaphore *sem)DEBUG_RWSEMS_WARN_ON ((rwsem_owner (sem) != current) && !rwsem_test_oflags (sem,RWSEM_NONSPINNABLE ), sem); +preempt_disable ();rwsem_clear_owner (sem); tmp =atomic_long_fetch_add_release (-RWSEM_WRITER_LOCKED , &sem->count); +preempt_enable ();if (unlikely (tmp &RWSEM_FLAG_WAITERS ))rwsem_wake (sem); }
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 9/21 gfs2: Check sb_bsize_shift after reading superblock
In reply to Sasha LevinFrom: Andrew Price <[email protected]>
[ Upstream commit 670f8ce56dd0632dc29a0322e188cc73ce3c6b92 ]
Fuzzers like to scribble over sb_bsize_shift but in reality it's very unlikely that this field would be corrupted on its own. Nevertheless it should be checked to avoid the possibility of messy mount errors due to bad calculations. It's always a fixed value based on the block size so we can just check that it's the expected value.
Tested with:
mkfs.gfs2 -O -p lock_nolock /dev/vdb
for i in 0 -1 64 65 32 33; do
gfs2_edit -p sb field sb_bsize_shift $i /dev/vdb mount /dev/vdb /mnt/test && umount /mnt/test
done
Before this patch we get a withdraw after
[ 76.413681] gfs2: fsid=loop0.0: fatal: invalid metadata block [ 76.413681] bh = 19 (type: exp=5, found=4) [ 76.413681] function = gfs2_meta_buffer, file = fs/gfs2/meta_io.c, line = 492
and with UBSAN configured we also get complaints like
[ 76.373395] UBSAN: shift-out-of-bounds in fs/gfs2/ops_fstype.c:295:19 [ 76.373815] shift exponent 4294967287 is too large for 64-bit type 'long unsigned int'
After the patch, these complaints don't appear, mount fails immediately and we get an explanation in dmesg.
--- fs/gfs2/ops_fstype.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
fs/gfs2/ops_fstype.c +4 -1
@@ -180,7 +180,10 @@ static int gfs2_check_sb(struct gfs2_sbd *sdp, int silent)pr_warn ("Invalid block size\n" );return -EINVAL ; } - +if (sb->sb_bsize_shift !=ffs (sb->sb_bsize) -1 ) { +pr_warn ("Invalid block size shift\n" ); +return -EINVAL ; + }return 0 ; }
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 10/21 powerpc/64: don't refer nr_cpu_ids in asm code when it's undefined
In reply to Sasha LevinFrom: Yury Norov <[email protected]>
[ Upstream commit 546a073d628111e3338af689938407e77d5dc38f ]
generic_secondary_common_init() calls LOAD_REG_ADDR(r7, nr_cpu_ids) conditionally on CONFIG_SMP. However, if 'NR_CPUS == 1', kernel doesn't use the nr_cpu_ids, and in C code, it's just:
#if NR_CPUS == 1
#define nr_cpu_ids
...
This series makes declaration of nr_cpu_ids conditional on NR_CPUS == 1, and that reveals the issue, because compiler can't link the LOAD_REG_ADDR(r7, nr_cpu_ids) against nonexisting symbol.
Current code looks unsafe for those who build kernel with CONFIG_SMP=y and NR_CPUS == 1. This is weird configuration, but not disallowed.
Fix the linker error by replacing LOAD_REG_ADDR() with LOAD_REG_IMMEDIATE() conditionally on NR_CPUS == 1.
As the following patch adds CONFIG_FORCE_NR_CPUS option that has the similar effect on nr_cpu_ids, make the generic_secondary_common_init() conditional on it too.
--- arch/powerpc/kernel/head_64.S | 4 ++++ 1 file changed, 4 insertions(+)
arch/powerpc/kernel/head_64.S +4 -0
@@ -400,8 +400,12 @@ generic_secondary_common_init: #else LOAD_REG_ADDR(r8, paca_ptrs) /* Load paca_ptrs pointe */ ld r8,0(r8) /* Get base vaddr of array */ +#if (NR_CPUS == 1) || defined(CONFIG_FORCE_NR_CPUS) + LOAD_REG_IMMEDIATE(r7, NR_CPUS) +#else LOAD_REG_ADDR(r7, nr_cpu_ids) /* Load nr_cpu_ids address */ lwz r7,0(r7) /* also the max paca allocated */ +#endif li r5,0 /* logical cpu id */ 1: sldi r9,r5,3 /* get paca_ptrs[] index from cpu id */
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 11/21 m68knommu: fix non-specific 68328 choice interrupt build failure
In reply to Sasha LevinFrom: Greg Ungerer <[email protected]>
[ Upstream commit 750321ace9107e103f254bf46900629ff347eb7b ]
Compiling for a classic m68k non-MMU target with no specific CPU selected fails with the following error:
arch/m68k/68000/ints.c: In function 'process_int':
Quoted 1 line
Quoted 1 line
arch/m68k/68000/ints.c:82:30: error: 'ISR' undeclared (first use in this function)
82 | unsigned long pend = ISR;
| ^~~This interrupt handling code is specific to the 68328 family of 68000 parts. There is a couple of variants (68EZ328, 68VZ328) and the common ancestor of them the strait 68328.
The code here includes a specific header for each variant type. But if none is selected then nothing is included to supply the appropriate register and bit flags defines.
Rearrange the includes so that at least one type is always included. At the very least the 68328 base type should be the fallback, so make that true.
--- arch/m68k/68000/ints.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-)
arch/m68k/68000/ints.c +3 -3
@@ -18,12 +18,12 @@#include <asm/io.h> #include <asm/machdep.h> -#if defined(CONFIG_M68328 ) -#include <asm/MC68328.h> -#elif defined(CONFIG_M68EZ328 ) +#if defined(CONFIG_M68EZ328 )#include <asm/MC68EZ328.h> #elif defined(CONFIG_M68VZ328 )#include <asm/MC68VZ328.h> +#else +#include <asm/MC68328.h> #endif /* assembler routines */
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 12/21 m68knommu: fix non-mmu classic 68000 legacy timer tick selection
In reply to Sasha LevinFrom: Greg Ungerer <[email protected]>
[ Upstream commit 18011e50c497f04a57a8e00122906f04922b30b4 ]
The family of classic 68000 parts supported when in non-mmu mode all currently use the legacy timer support. Move the selection of that config option, LEGACY_TIMER_TICK, into the core CPU configuration.
This fixes compilation if no specific CPU variant is selected, since the LEGACY_TIMER_TICK option was only selected in the specific CPU variant configurations.
--- arch/m68k/Kconfig.cpu | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
arch/m68k/Kconfig.cpu +1 -3
@@ -46,6 +46,7 @@ config M68000 select GENERIC_CSUM select CPU_NO_EFFICIENT_FFS select HAVE_ARCH_HASH + select LEGACY_TIMER_TICK help The Freescale (was Motorola) 68000 CPU is the first generation of the well known M68K family of processors. The CPU core as well as
@@ -108,7 +109,6 @@ config M68060 config M68328 bool depends on !MMU - select LEGACY_TIMER_TICK select M68000 help Motorola 68328 processor support.
@@ -116,7 +116,6 @@ config M68328 config M68EZ328 bool depends on !MMU - select LEGACY_TIMER_TICK select M68000 help Motorola 68EX328 processor support.
@@ -124,7 +123,6 @@ config M68EZ328 config M68VZ328 bool depends on !MMU - select LEGACY_TIMER_TICK select M68000 help Motorola 68VZ328 processor support.
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 13/21 of: Fix "dma-ranges" handling for bus controllers
In reply to Sasha LevinFrom: Robin Murphy <[email protected]>
[ Upstream commit f1ad5338a4d57fe1fe6475003acb8c70bf9d1bdf ]
Commit 951d48855d86 ("of: Make of_dma_get_range() work on bus nodes") relaxed the handling of "dma-ranges" for any leaf node on the assumption that it would still represent a usage error for the property to be present on a non-bus leaf node. However there turns out to be a fiddly case where a bus also represents a DMA-capable device in its own right, such as a PCIe root complex with an integrated DMA engine on its platform side. In such cases, "dma-ranges" translation is entirely valid for devices discovered behind the bus, but should not be erroneously applied to the bus controller device itself which operates in its parent's address space. Fix this by restoring the previous behaviour for the specific case where a device is configured via its own OF node, since it is logical to assume that a device should never represent its own parent bus.
--- drivers/of/address.c | 4 +++- drivers/of/device.c | 9 ++++++++- drivers/of/of_private.h | 5 +++++ 3 files changed, 16 insertions(+), 2 deletions(-)
drivers/of/address.c +3 -1
@@ -579,7 +579,8 @@ u64 of_translate_address(struct device_node *dev, const __be32 *in_addr) }EXPORT_SYMBOL (of_translate_address); -static struct device_node *__of_get_dma_parent (const struct device_node *np) +#ifdef CONFIG_HAS_DMA +struct device_node *__of_get_dma_parent (const struct device_node *np) {struct of_phandle_args args;int ret, index;
@@ -596,6 +597,7 @@ static struct device_node *__of_get_dma_parent(const struct device_node *np) return of_node_get(args.np); } +#endif static struct device_node *of_get_next_dma_parent (struct device_node *np) {
drivers/of/device.c +8 -1
@@ -116,12 +116,19 @@ int of_dma_configure_id(struct device *dev, struct device_node *np, {const struct iommu_ops *iommu;const struct bus_dma_region *map =NULL ; +struct device_node *bus_np;u64 dma_start =0 ;u64 mask, end, size =0 ;bool coherent;int ret; - ret =of_dma_get_range (np, &map); +if (np == dev->of_node) + bus_np =__of_get_dma_parent (np); +else + bus_np =of_node_get (np); + + ret =of_dma_get_range (bus_np, &map); +of_node_put (bus_np);if (ret <0 ) {/* * For legacy reasons, we have to assume some devices need
drivers/of/of_private.h +5 -0
@@ -163,12 +163,17 @@ struct bus_dma_region;#if defined(CONFIG_OF_ADDRESS ) && defined(CONFIG_HAS_DMA )int of_dma_get_range (struct device_node *np,const struct bus_dma_region **map); +struct device_node *__of_get_dma_parent (const struct device_node *np);#else static inline int of_dma_get_range (struct device_node *np,const struct bus_dma_region **map) {return -ENODEV ; } +static inline struct device_node *__of_get_dma_parent (const struct device_node *np) +{ +return of_get_parent (np); +}#endif void fdt_init_reserved_mem (void );
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 14/21 x86/hyperv: Replace kmap() with kmap_local_page()
In reply to Sasha LevinFrom: Zhao Liu <[email protected]>
[ Upstream commit 154fb14df7a3c81dea82eca7c0c46590f5ffc3d2 ]
kmap() is being deprecated in favor of kmap_local_page()[1].
There are two main problems with kmap(): (1) It comes with an overhead as mapping space is restricted and protected by a global lock for synchronization and (2) it also requires global TLB invalidation when the kmap's pool wraps and it might block when the mapping space is fully utilized until a slot becomes available.
With kmap_local_page() the mappings are per thread, CPU local, can take page faults, and can be called from any context (including interrupts). It is faster than kmap() in kernels with HIGHMEM enabled. Furthermore, the tasks can be preempted and, when they are scheduled to run again, the kernel virtual addresses are restored and are still valid.
In the fuction hyperv_init() of hyperv/hv_init.c, the mapping is used in a single thread and is short live. So, in this case, it's safe to simply use kmap_local_page() to create mapping, and this avoids the wasted cost of kmap() for global synchronization.
In addtion, the fuction hyperv_init() checks if kmap() fails by BUG_ON(). From the original discussion[2], the BUG_ON() here is just used to explicitly panic NULL pointer. So still keep the BUG_ON() in place to check if kmap_local_page() fails. Based on this consideration, memcpy_to_page() is not selected here but only kmap_local_page() is used.
Therefore, replace kmap() with kmap_local_page() in hyperv/hv_init.c.
[1]: https://lore.kernel.org/all/[email protected]
[2]: https://lore.kernel.org/lkml/20200915103710.cqmdvzh5lys4wsqo@liuwe-devbox-debian-v2/
--- arch/x86/hyperv/hv_init.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
arch/x86/hyperv/hv_init.c +2 -2
@@ -407,13 +407,13 @@ void __init hyperv_init(void)wrmsrl (HV_X64_MSR_HYPERCALL , hypercall_msr.as_uint64); pg =vmalloc_to_page (hv_hypercall_pg); - dst =kmap (pg); + dst =kmap_local_page (pg); src =memremap (hypercall_msr.guest_physical_address <<PAGE_SHIFT ,PAGE_SIZE ,MEMREMAP_WB );BUG_ON (!(src && dst));memcpy (dst, src,HV_HYP_PAGE_SIZE );memunmap (src); -kunmap (pg); +kunmap_local (dst); }else { hypercall_msr.guest_physical_address =vmalloc_to_pfn (hv_hypercall_pg);wrmsrl (HV_X64_MSR_HYPERCALL , hypercall_msr.as_uint64);
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 15/21 kmsan: disable instrumentation of unsupported common kernel code
In reply to Sasha LevinFrom: Alexander Potapenko <[email protected]>
[ Upstream commit 79dbd006a6d6f51777ba4948046561b6d9270504 ]
EFI stub cannot be linked with KMSAN runtime, so we disable instrumentation for it.
Instrumenting kcov, stackdepot or lockdep leads to infinite recursion caused by instrumentation hooks calling instrumented code again.
--- drivers/firmware/efi/libstub/Makefile | 1 + kernel/Makefile | 1 + kernel/locking/Makefile | 3 ++- lib/Makefile | 3 +++ 4 files changed, 7 insertions(+), 1 deletion(-)
drivers/firmware/efi/libstub/Makefile +1 -0
@@ -53,6 +53,7 @@ GCOV_PROFILE := n # Sanitizer runtimes are unavailable and cannot be linked here. KASAN_SANITIZE := n KCSAN_SANITIZE := n +KMSAN_SANITIZE := n UBSAN_SANITIZE := n OBJECT_FILES_NON_STANDARD := y
kernel/Makefile +1 -0
@@ -39,6 +39,7 @@ KCOV_INSTRUMENT_kcov.o := n KASAN_SANITIZE_kcov.o := n KCSAN_SANITIZE_kcov.o := n UBSAN_SANITIZE_kcov.o := n +KMSAN_SANITIZE_kcov.o := n CFLAGS_kcov.o := $(call cc-option, -fno-conserve-stack) -fno-stack-protector # Don't instrument error handlers
kernel/locking/Makefile +2 -1
@@ -5,8 +5,9 @@ KCOV_INSTRUMENT := n obj-y += mutex.o semaphore.o rwsem.o percpu-rwsem.o -# Avoid recursion lockdep -> KCSAN -> ... -> lockdep. +# Avoid recursion lockdep -> sanitizer -> ... -> lockdep. KCSAN_SANITIZE_lockdep.o := n +KMSAN_SANITIZE_lockdep.o := n ifdef CONFIG_FUNCTION_TRACER CFLAGS_REMOVE_lockdep.o = $(CC_FLAGS_FTRACE)
lib/Makefile +3 -0
@@ -268,6 +268,9 @@ obj-$(CONFIG_IRQ_POLL) += irq_poll.o CFLAGS_stackdepot.o += -fno-builtin obj-$(CONFIG_STACKDEPOT) += stackdepot.o KASAN_SANITIZE_stackdepot.o := n +# In particular, instrumenting stackdepot.c with KMSAN will result in infinite +# recursion. +KMSAN_SANITIZE_stackdepot.o := n KCOV_INSTRUMENT_stackdepot.o := n libfdt_files = fdt.o fdt_ro.o fdt_wip.o fdt_rw.o fdt_sw.o fdt_strerror.o \
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 16/21 kmsan: disable physical page merging in biovec
In reply to Sasha LevinFrom: Alexander Potapenko <[email protected]>
[ Upstream commit f630a5d0ca59a6e73b61e3f82c371dc230da99ff ]
KMSAN metadata for adjacent physical pages may not be adjacent, therefore accessing such pages together may lead to metadata corruption. We disable merging pages in biovec to prevent such corruptions.
--- block/blk.h | 7 +++++++ 1 file changed, 7 insertions(+)
block/blk.h +7 -0
@@ -66,6 +66,13 @@ static inline bool biovec_phys_mergeable(struct request_queue *q,phys_addr_t addr1 =page_to_phys (vec1->bv_page) + vec1->bv_offset;phys_addr_t addr2 =page_to_phys (vec2->bv_page) + vec2->bv_offset; +/* +* Merging adjacent physical pages may not work correctly under KMSAN +* if their metadata pages aren't adjacent. Just disable merging. +*/ +if (IS_ENABLED (CONFIG_KMSAN )) +return false; +if (addr1 + vec1->bv_len != addr2)return false;if (xen_domain () && !xen_biovec_phys_mergeable (vec1, vec2->bv_page))
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 17/21 f2fs: fix to detect corrupted meta ino
In reply to Sasha LevinFrom: Chao Yu <[email protected]>
[ Upstream commit fcc2d8cc96b2f6141bbbe5b1e8953db990794b44 ]
It is possible that ino of dirent or orphan inode is corrupted in a fuzzed image, occasionally, if corrupted ino is equal to meta ino:meta_ino, node_ino or compress_ino, caller of f2fs_iget() from below call paths will get meta inode directly, it's not allowed, let's add sanity check to detect such cases.
case #1
- recover_dentry
- __f2fs_find_entry
- f2fs_iget_retry
case #2
- recover_orphan_inode
- f2fs_iget_retry
--- fs/f2fs/inode.c | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-)
fs/f2fs/inode.c +16 -5
@@ -480,6 +480,12 @@ static int do_read_inode(struct inode *inode)return 0 ; } +static bool is_meta_ino (struct f2fs_sb_info *sbi,unsigned int ino) +{ +return ino ==F2FS_NODE_INO (sbi) || ino ==F2FS_META_INO (sbi) || + ino ==F2FS_COMPRESS_INO (sbi); +} +struct inode *f2fs_iget (struct super_block *sb,unsigned long ino) {struct f2fs_sb_info *sbi =F2FS_SB (sb);
@@ -491,16 +497,21 @@ struct inode *f2fs_iget(struct super_block *sb, unsigned long ino)return ERR_PTR (-ENOMEM );if (!(inode->i_state &I_NEW )) { +if (is_meta_ino (sbi, ino)) { +f2fs_err (sbi,"inaccessible inode: %lu, run fsck to repair" , ino); +set_sbi_flag (sbi,SBI_NEED_FSCK ); + ret = -EFSCORRUPTED ; +trace_f2fs_iget_exit (inode, ret); +iput (inode); +return ERR_PTR (ret); + } +trace_f2fs_iget (inode);return inode; } -if (ino ==F2FS_NODE_INO (sbi) || ino ==F2FS_META_INO (sbi)) - goto make_now; -#ifdef CONFIG_F2FS_FS_COMPRESSION -if (ino ==F2FS_COMPRESS_INO (sbi)) +if (is_meta_ino (sbi, ino)) goto make_now; -#endif ret =do_read_inode (inode);if (ret)
Signature · 8 lines
2.35.1 _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Sasha Levin
maintainerPATCH 18/21 9p: trans_fd/p9_conn_cancel: drop client lock earlier
In reply to Sasha LevinFrom: Dominique Martinet <[email protected]>
[ Upstream commit 52f1c45dde9136f964d63a77d19826c8a74e2c7f ]
syzbot reported a double-lock here and we no longer need this lock after requests have been moved off to local list:
just drop the lock earlier.
--- net/9p/trans_fd.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
net/9p/trans_fd.c +2 -1
@@ -207,6 +207,8 @@ static void p9_conn_cancel(struct p9_conn *m, int err)list_move (&req->req_list, &cancel_list); } +spin_unlock (&m->client->lock); +list_for_each_entry_safe (req, rtmp, &cancel_list, req_list) {p9_debug (P9_DEBUG_ERROR ,"call back req %p\n" , req);list_del (&req->req_list);
@@ -214,7 +216,6 @@ static void p9_conn_cancel(struct p9_conn *m, int err) req->t_err = err;p9_client_cb (m->client, req,REQ_STATUS_ERROR ); } -spin_unlock (&m->client->lock); } static __poll_t
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 19/21 9p/trans_fd: always use O_NONBLOCK read/write
In reply to Sasha LevinFrom: Tetsuo Handa <[email protected]>
[ Upstream commit ef575281b21e9a34dfae544a187c6aac2ae424a9 ]
syzbot is reporting hung task at p9_fd_close() [1], for p9_mux_poll_stop()
from p9_conn_destroy() from p9_fd_close() is failing to interrupt already
started kernel_read() from p9_fd_read() from p9_read_work() and/or kernel_write() from p9_fd_write() from p9_write_work() requests.
Since p9_socket_open() sets O_NONBLOCK flag, p9_mux_poll_stop() does not need to interrupt kernel_read()/kernel_write(). However, since p9_fd_open() does not set O_NONBLOCK flag, but pipe blocks unless signal is pending, p9_mux_poll_stop() needs to interrupt kernel_read()/kernel_write() when the file descriptor refers to a pipe. In other words, pipe file descriptor needs to be handled as if socket file descriptor.
We somehow need to interrupt kernel_read()/kernel_write() on pipes.
A minimal change, which this patch is doing, is to set O_NONBLOCK flag
from p9_fd_open(), for O_NONBLOCK flag does not affect reading/writing
of regular files. But this approach changes O_NONBLOCK flag on userspace- supplied file descriptors (which might break userspace programs), and O_NONBLOCK flag could be changed by userspace. It would be possible to set O_NONBLOCK flag every time p9_fd_read()/p9_fd_write() is invoked, but still remains small race window for clearing O_NONBLOCK flag.
If we don't want to manipulate O_NONBLOCK flag, we might be able to surround kernel_read()/kernel_write() with set_thread_flag(TIF_SIGPENDING) and recalc_sigpending(). Since p9_read_work()/p9_write_work() works are processed by kernel threads which process global system_wq workqueue, signals could not be delivered from remote threads when p9_mux_poll_stop()
from p9_conn_destroy() from p9_fd_close() is called. Therefore, calling
set_thread_flag(TIF_SIGPENDING)/recalc_sigpending() every time would be needed if we count on signals for making kernel_read()/kernel_write() non-blocking.
--- net/9p/trans_fd.c | 3 +++ 1 file changed, 3 insertions(+)
net/9p/trans_fd.c +3 -0
@@ -824,11 +824,14 @@ static int p9_fd_open(struct p9_client *client, int rfd, int wfd) goto out_free_ts;if (!(ts->rd->f_mode &FMODE_READ )) goto out_put_rd; +/* prevent workers from hanging on IO when fd is a pipe */ + ts->rd->f_flags |=O_NONBLOCK ; ts->wr =fget (wfd);if (!ts->wr) goto out_put_rd;if (!(ts->wr->f_mode &FMODE_WRITE )) goto out_put_wr; + ts->wr->f_flags |=O_NONBLOCK ; client->trans = ts; client->status = Connected;
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 20/21 net/9p: use a dedicated spinlock for trans_fd
In reply to Sasha LevinFrom: Dominique Martinet <[email protected]>
[ Upstream commit 296ab4a813841ba1d5f40b03190fd1bd8f25aab0 ]
Shamelessly copying the explanation from Tetsuo Handa's suggested patch[1] (slightly reworded):
syzbot is reporting inconsistent lock state in p9_req_put()[2], for p9_tag_remove() from p9_req_put() from IRQ context is using spin_lock_irqsave() on "struct p9_client"->lock but trans_fd (not from IRQ context) is using spin_lock().
Since the locks actually protect different things in client.c and in trans_fd.c, just replace trans_fd.c's lock by a new one specific to the transport (client.c's protect the idr for fid/tag allocations, while trans_fd.c's protects its own req list and request status field that acts as the transport's state machine)
--- net/9p/trans_fd.c | 41 +++++++++++++++++++++++++---------------- 1 file changed, 25 insertions(+), 16 deletions(-)
net/9p/trans_fd.c +25 -16
@@ -93,6 +93,7 @@ struct p9_poll_wait {* @mux_list: list link for mux to manage multiple connections (?) * @client: reference to client instance for this connection * @err: error state +* @req_lock: lock protecting req_list and requests statuses * @req_list: accounting for requests which have been sent * @unsent_req_list: accounting for requests that haven't been sent * @rreq: read request
@@ -116,6 +117,7 @@ struct p9_conn {struct list_head mux_list;struct p9_client *client;int err; +spinlock_t req_lock;struct list_head req_list;struct list_head unsent_req_list;struct p9_req_t *rreq;
@@ -191,10 +193,10 @@ static void p9_conn_cancel(struct p9_conn *m, int err)p9_debug (P9_DEBUG_ERROR ,"mux %p err %d\n" , m, err); -spin_lock (&m->client->lock); +spin_lock (&m->req_lock);if (m->err) { -spin_unlock (&m->client->lock); +spin_unlock (&m->req_lock);return ; }
@@ -207,7 +209,7 @@ static void p9_conn_cancel(struct p9_conn *m, int err)list_move (&req->req_list, &cancel_list); } -spin_unlock (&m->client->lock); +spin_unlock (&m->req_lock);list_for_each_entry_safe (req, rtmp, &cancel_list, req_list) {p9_debug (P9_DEBUG_ERROR ,"call back req %p\n" , req);
@@ -362,7 +364,7 @@ static void p9_read_work(struct work_struct *work)if ((m->rreq) && (m->rc.offset == m->rc.capacity)) {p9_debug (P9_DEBUG_TRANS ,"got new packet\n" ); m->rreq->rc.size = m->rc.offset; -spin_lock (&m->client->lock); +spin_lock (&m->req_lock);if (m->rreq->status ==REQ_STATUS_SENT ) {list_del (&m->rreq->req_list);p9_client_cb (m->client, m->rreq,REQ_STATUS_RCVD );
@@ -371,14 +373,14 @@ static void p9_read_work(struct work_struct *work)p9_debug (P9_DEBUG_TRANS ,"Ignore replies associated with a cancelled request\n" ); }else { -spin_unlock (&m->client->lock); +spin_unlock (&m->req_lock);p9_debug (P9_DEBUG_ERROR ,"Request tag %d errored out while we were reading the reply\n" , m->rc.tag); err = -EIO ; goto error; } -spin_unlock (&m->client->lock); +spin_unlock (&m->req_lock); m->rc.sdata =NULL ; m->rc.offset =0 ; m->rc.capacity =0 ;
@@ -456,10 +458,10 @@ static void p9_write_work(struct work_struct *work) }if (!m->wsize) { -spin_lock (&m->client->lock); +spin_lock (&m->req_lock);if (list_empty (&m->unsent_req_list)) {clear_bit (Wworksched, &m->wsched); -spin_unlock (&m->client->lock); +spin_unlock (&m->req_lock);return ; }
@@ -474,7 +476,7 @@ static void p9_write_work(struct work_struct *work) m->wpos =0 ;p9_req_get (req); m->wreq = req; -spin_unlock (&m->client->lock); +spin_unlock (&m->req_lock); } p9_debug(P9_DEBUG_TRANS, "mux %p pos %d size %d\n",
@@ -591,6 +593,7 @@ static void p9_conn_create(struct p9_client *client)INIT_LIST_HEAD (&m->mux_list); m->client = client; +spin_lock_init (&m->req_lock);INIT_LIST_HEAD (&m->req_list);INIT_LIST_HEAD (&m->unsent_req_list);INIT_WORK (&m->rq, p9_read_work);
@@ -672,10 +675,10 @@ static int p9_fd_request(struct p9_client *client, struct p9_req_t *req)if (m->err <0 )return m->err; -spin_lock (&client->lock); +spin_lock (&m->req_lock); req->status =REQ_STATUS_UNSENT ;list_add_tail (&req->req_list, &m->unsent_req_list); -spin_unlock (&client->lock); +spin_unlock (&m->req_lock);if (test_and_clear_bit (Wpending, &m->wsched)) n =EPOLLOUT ;
@@ -690,11 +693,13 @@ static int p9_fd_request(struct p9_client *client, struct p9_req_t *req)static int p9_fd_cancel (struct p9_client *client,struct p9_req_t *req) { +struct p9_trans_fd *ts = client->trans; +struct p9_conn *m = &ts->conn;int ret =1 ;p9_debug (P9_DEBUG_TRANS ,"client %p req %p\n" , client, req); -spin_lock (&client->lock); +spin_lock (&m->req_lock);if (req->status ==REQ_STATUS_UNSENT ) {list_del (&req->req_list);
@@ -702,21 +707,24 @@ static int p9_fd_cancel(struct p9_client *client, struct p9_req_t *req)p9_req_put (client, req); ret =0 ; } -spin_unlock (&client->lock); +spin_unlock (&m->req_lock);return ret; }static int p9_fd_cancelled (struct p9_client *client,struct p9_req_t *req) { +struct p9_trans_fd *ts = client->trans; +struct p9_conn *m = &ts->conn; +p9_debug (P9_DEBUG_TRANS ,"client %p req %p\n" , client, req); -spin_lock (&client->lock); +spin_lock (&m->req_lock);/* Ignore cancelled request if message has been received * before lock. */ if (req->status ==REQ_STATUS_RCVD ) { -spin_unlock (&client->lock); +spin_unlock (&m->req_lock);return 0 ; }
@@ -725,7 +733,8 @@ static int p9_fd_cancelled(struct p9_client *client, struct p9_req_t *req)*/ list_del (&req->req_list); req->status =REQ_STATUS_FLSHD ; -spin_unlock (&client->lock); +spin_unlock (&m->req_lock); +p9_req_put (client, req);return 0 ;
Signature · 1 line
2.35.1
Sasha Levin
maintainerPATCH 21/21 virtio_pci: don't try to use intxif pin is zero
In reply to Sasha LevinFrom: Angus Chen <[email protected]>
[ Upstream commit 71491c54eafa318fdd24a1f26a1c82b28e1ac21d ]
The background is that we use dpu in cloud computing,the arch is x86,80 cores. We will have a lots of virtio devices,like 512 or more. When we probe about 200 virtio_blk devices,it will fail and the stack is printed as follows:
[25338.485128] virtio-pci 0000:b3:00.0: virtio_pci: leaving for legacy driver [25338.496174] genirq: Flags mismatch irq 0. 00000080 (virtio418) vs. 00015a00 (timer) [25338.503822] CPU: 20 PID: 5431 Comm: kworker/20:0 Kdump: loaded Tainted: G OE --------- - - 4.18.0-305.30.1.el8.x86_64 [25338.516403] Hardware name: Inspur NF5280M5/YZMB-00882-10E, BIOS 4.1.21 08/25/2021 [25338.523881] Workqueue: events work_for_cpu_fn [25338.528235] Call Trace: [25338.530687] dump_stack+0x5c/0x80 [25338.534000] __setup_irq.cold.53+0x7c/0xd3 [25338.538098] request_threaded_irq+0xf5/0x160 [25338.542371] vp_find_vqs+0xc7/0x190 [25338.545866] init_vq+0x17c/0x2e0 [virtio_blk] [25338.550223] ? ncpus_cmp_func+0x10/0x10 [25338.554061] virtblk_probe+0xe6/0x8a0 [virtio_blk] [25338.558846] virtio_dev_probe+0x158/0x1f0 [25338.562861] really_probe+0x255/0x4a0 [25338.566524] ? __driver_attach_async_helper+0x90/0x90 [25338.571567] driver_probe_device+0x49/0xc0 [25338.575660] bus_for_each_drv+0x79/0xc0 [25338.579499] __device_attach+0xdc/0x160 [25338.583337] bus_probe_device+0x9d/0xb0 [25338.587167] device_add+0x418/0x780 [25338.590654] register_virtio_device+0x9e/0xe0 [25338.595011] virtio_pci_probe+0xb3/0x140 [25338.598941] local_pci_probe+0x41/0x90 [25338.602689] work_for_cpu_fn+0x16/0x20 [25338.606443] process_one_work+0x1a7/0x360 [25338.610456] ? create_worker+0x1a0/0x1a0 [25338.614381] worker_thread+0x1cf/0x390 [25338.618132] ? create_worker+0x1a0/0x1a0 [25338.622051] kthread+0x116/0x130 [25338.625283] ? kthread_flush_work_fn+0x10/0x10 [25338.629731] ret_from_fork+0x1f/0x40 [25338.633395] virtio_blk: probe of virtio418 failed with error -16
The log :
"genirq: Flags mismatch irq 0. 00000080 (virtio418) vs. 00015a00 (timer)" was printed because of the irq 0 is used by timer exclusive,and when vp_find_vqs call vp_find_vqs_msix and returns false twice (for whatever reason), then it will call vp_find_vqs_intx as a fallback. Because vp_dev->pci_dev->irq is zero, we request irq 0 with flag IRQF_SHARED, and get a backtrace like above.
According to PCI spec about "Interrupt Pin" Register (Offset 3Dh):
"The Interrupt Pin register is a read-only register that identifies the
legacy interrupt Message(s) the Function uses. Valid values are 01h, 02h, 03h, and 04h that map to legacy interrupt Messages for INTA, INTB, INTC, and INTD respectively. A value of 00h indicates that the Function uses no legacy interrupt Message(s)."
So if vp_dev->pci_dev->pin is zero, we should not request legacy interrupt.
Message-Id: <[email protected]>
--- drivers/virtio/virtio_pci_common.c | 3 +++ 1 file changed, 3 insertions(+)
drivers/virtio/virtio_pci_common.c +3 -0
@@ -403,6 +403,9 @@ int vp_find_vqs(struct virtio_device *vdev, unsigned nvqs, err =vp_find_vqs_msix (vdev, nvqs, vqs, callbacks, names, false, ctx, desc);if (!err)return 0 ; +/* Is there an interrupt pin? If not give up. */ +if (!(to_vp_device (vdev)->pci_dev->pin)) +return err;/* Finally fall back to regular interrupts. */ return vp_find_vqs_intx (vdev, nvqs, vqs, callbacks, names, ctx); }
Signature · 6 lines
2.35.1 _______________________________________________ Virtualization mailing list [email protected] https://lists.linuxfoundation.org/mailman/listinfo/virtualization