From: Greg Kroah-Hartman Date: Fri, 19 Mar 2021 09:52:46 +0000 (+0100) Subject: 5.11-stable patches X-Git-Tag: v4.19.182~13 X-Git-Url: http://git.ipfire.org/gitweb.cgi?a=commitdiff_plain;h=36866aeb92dad3da2c276e4aa0bf48102be3d0ed;p=thirdparty%2Fkernel%2Fstable-queue.git 5.11-stable patches added patches: fuse-fix-live-lock-in-fuse_iget.patch rdma-srp-fix-support-for-unpopulated-and-unbalanced-numa-nodes.patch --- diff --git a/queue-5.11/fuse-fix-live-lock-in-fuse_iget.patch b/queue-5.11/fuse-fix-live-lock-in-fuse_iget.patch new file mode 100644 index 00000000000..3bea63b8714 --- /dev/null +++ b/queue-5.11/fuse-fix-live-lock-in-fuse_iget.patch @@ -0,0 +1,52 @@ +From 775c5033a0d164622d9d10dd0f0a5531639ed3ed Mon Sep 17 00:00:00 2001 +From: Amir Goldstein +Date: Thu, 4 Mar 2021 11:09:12 +0200 +Subject: fuse: fix live lock in fuse_iget() + +From: Amir Goldstein + +commit 775c5033a0d164622d9d10dd0f0a5531639ed3ed upstream. + +Commit 5d069dbe8aaf ("fuse: fix bad inode") replaced make_bad_inode() +in fuse_iget() with a private implementation fuse_make_bad(). + +The private implementation fails to remove the bad inode from inode +cache, so the retry loop with iget5_locked() finds the same bad inode +and marks it bad forever. + +kmsg snip: + +[ ] rcu: INFO: rcu_sched self-detected stall on CPU +... +[ ] ? bit_wait_io+0x50/0x50 +[ ] ? fuse_init_file_inode+0x70/0x70 +[ ] ? find_inode.isra.32+0x60/0xb0 +[ ] ? fuse_init_file_inode+0x70/0x70 +[ ] ilookup5_nowait+0x65/0x90 +[ ] ? fuse_init_file_inode+0x70/0x70 +[ ] ilookup5.part.36+0x2e/0x80 +[ ] ? fuse_init_file_inode+0x70/0x70 +[ ] ? fuse_inode_eq+0x20/0x20 +[ ] iget5_locked+0x21/0x80 +[ ] ? fuse_inode_eq+0x20/0x20 +[ ] fuse_iget+0x96/0x1b0 + +Fixes: 5d069dbe8aaf ("fuse: fix bad inode") +Cc: stable@vger.kernel.org # 5.10+ +Signed-off-by: Amir Goldstein +Signed-off-by: Miklos Szeredi +Signed-off-by: Greg Kroah-Hartman +--- + fs/fuse/fuse_i.h | 1 + + 1 file changed, 1 insertion(+) + +--- a/fs/fuse/fuse_i.h ++++ b/fs/fuse/fuse_i.h +@@ -863,6 +863,7 @@ static inline u64 fuse_get_attr_version( + + static inline void fuse_make_bad(struct inode *inode) + { ++ remove_inode_hash(inode); + set_bit(FUSE_I_BAD, &get_fuse_inode(inode)->state); + } + diff --git a/queue-5.11/rdma-srp-fix-support-for-unpopulated-and-unbalanced-numa-nodes.patch b/queue-5.11/rdma-srp-fix-support-for-unpopulated-and-unbalanced-numa-nodes.patch new file mode 100644 index 00000000000..fb7f04f5108 --- /dev/null +++ b/queue-5.11/rdma-srp-fix-support-for-unpopulated-and-unbalanced-numa-nodes.patch @@ -0,0 +1,179 @@ +From 2b5715fc17386a6223490d5b8f08d031999b0c0b Mon Sep 17 00:00:00 2001 +From: Nicolas Morey-Chaisemartin +Date: Fri, 5 Feb 2021 09:14:28 +0100 +Subject: RDMA/srp: Fix support for unpopulated and unbalanced NUMA nodes + +From: Nicolas Morey-Chaisemartin + +commit 2b5715fc17386a6223490d5b8f08d031999b0c0b upstream. + +The current code computes a number of channels per SRP target and spreads +them equally across all online NUMA nodes. Each channel is then assigned +a CPU within this node. + +In the case of unbalanced, or even unpopulated nodes, some channels do not +get a CPU associated and thus do not get connected. This causes the SRP +connection to fail. + +This patch solves the issue by rewriting channel computation and +allocation: + +- Drop channel to node/CPU association as it had no real effect on + locality but added unnecessary complexity. + +- Tweak the number of channels allocated to reduce CPU contention when + possible: + - Up to one channel per CPU (instead of up to 4 by node) + - At least 4 channels per node, unless ch_count module parameter is + used. + +Link: https://lore.kernel.org/r/9cb4d9d3-30ad-2276-7eff-e85f7ddfb411@suse.com +Signed-off-by: Nicolas Morey-Chaisemartin +Reviewed-by: Bart Van Assche +Signed-off-by: Jason Gunthorpe +Cc: Yi Zhang +Signed-off-by: Greg Kroah-Hartman +--- + drivers/infiniband/ulp/srp/ib_srp.c | 116 ++++++++++++++---------------------- + 1 file changed, 48 insertions(+), 68 deletions(-) + +--- a/drivers/infiniband/ulp/srp/ib_srp.c ++++ b/drivers/infiniband/ulp/srp/ib_srp.c +@@ -3628,7 +3628,7 @@ static ssize_t srp_create_target(struct + struct srp_rdma_ch *ch; + struct srp_device *srp_dev = host->srp_dev; + struct ib_device *ibdev = srp_dev->dev; +- int ret, node_idx, node, cpu, i; ++ int ret, i, ch_idx; + unsigned int max_sectors_per_mr, mr_per_cmd = 0; + bool multich = false; + uint32_t max_iu_len; +@@ -3753,81 +3753,61 @@ static ssize_t srp_create_target(struct + goto out; + + ret = -ENOMEM; +- if (target->ch_count == 0) ++ if (target->ch_count == 0) { + target->ch_count = +- max_t(unsigned int, num_online_nodes(), +- min(ch_count ?: +- min(4 * num_online_nodes(), +- ibdev->num_comp_vectors), +- num_online_cpus())); ++ min(ch_count ?: ++ max(4 * num_online_nodes(), ++ ibdev->num_comp_vectors), ++ num_online_cpus()); ++ } ++ + target->ch = kcalloc(target->ch_count, sizeof(*target->ch), + GFP_KERNEL); + if (!target->ch) + goto out; + +- node_idx = 0; +- for_each_online_node(node) { +- const int ch_start = (node_idx * target->ch_count / +- num_online_nodes()); +- const int ch_end = ((node_idx + 1) * target->ch_count / +- num_online_nodes()); +- const int cv_start = node_idx * ibdev->num_comp_vectors / +- num_online_nodes(); +- const int cv_end = (node_idx + 1) * ibdev->num_comp_vectors / +- num_online_nodes(); +- int cpu_idx = 0; +- +- for_each_online_cpu(cpu) { +- if (cpu_to_node(cpu) != node) +- continue; +- if (ch_start + cpu_idx >= ch_end) +- continue; +- ch = &target->ch[ch_start + cpu_idx]; +- ch->target = target; +- ch->comp_vector = cv_start == cv_end ? cv_start : +- cv_start + cpu_idx % (cv_end - cv_start); +- spin_lock_init(&ch->lock); +- INIT_LIST_HEAD(&ch->free_tx); +- ret = srp_new_cm_id(ch); +- if (ret) +- goto err_disconnect; +- +- ret = srp_create_ch_ib(ch); +- if (ret) +- goto err_disconnect; +- +- ret = srp_alloc_req_data(ch); +- if (ret) +- goto err_disconnect; +- +- ret = srp_connect_ch(ch, max_iu_len, multich); +- if (ret) { +- char dst[64]; +- +- if (target->using_rdma_cm) +- snprintf(dst, sizeof(dst), "%pIS", +- &target->rdma_cm.dst); +- else +- snprintf(dst, sizeof(dst), "%pI6", +- target->ib_cm.orig_dgid.raw); +- shost_printk(KERN_ERR, target->scsi_host, +- PFX "Connection %d/%d to %s failed\n", +- ch_start + cpu_idx, +- target->ch_count, dst); +- if (node_idx == 0 && cpu_idx == 0) { +- goto free_ch; +- } else { +- srp_free_ch_ib(target, ch); +- srp_free_req_data(target, ch); +- target->ch_count = ch - target->ch; +- goto connected; +- } ++ for (ch_idx = 0; ch_idx < target->ch_count; ++ch_idx) { ++ ch = &target->ch[ch_idx]; ++ ch->target = target; ++ ch->comp_vector = ch_idx % ibdev->num_comp_vectors; ++ spin_lock_init(&ch->lock); ++ INIT_LIST_HEAD(&ch->free_tx); ++ ret = srp_new_cm_id(ch); ++ if (ret) ++ goto err_disconnect; ++ ++ ret = srp_create_ch_ib(ch); ++ if (ret) ++ goto err_disconnect; ++ ++ ret = srp_alloc_req_data(ch); ++ if (ret) ++ goto err_disconnect; ++ ++ ret = srp_connect_ch(ch, max_iu_len, multich); ++ if (ret) { ++ char dst[64]; ++ ++ if (target->using_rdma_cm) ++ snprintf(dst, sizeof(dst), "%pIS", ++ &target->rdma_cm.dst); ++ else ++ snprintf(dst, sizeof(dst), "%pI6", ++ target->ib_cm.orig_dgid.raw); ++ shost_printk(KERN_ERR, target->scsi_host, ++ PFX "Connection %d/%d to %s failed\n", ++ ch_idx, ++ target->ch_count, dst); ++ if (ch_idx == 0) { ++ goto free_ch; ++ } else { ++ srp_free_ch_ib(target, ch); ++ srp_free_req_data(target, ch); ++ target->ch_count = ch - target->ch; ++ goto connected; + } +- +- multich = true; +- cpu_idx++; + } +- node_idx++; ++ multich = true; + } + + connected: diff --git a/queue-5.11/series b/queue-5.11/series index a2e17bd2028..9482313ef52 100644 --- a/queue-5.11/series +++ b/queue-5.11/series @@ -23,3 +23,5 @@ bpf-simplify-alu_limit-masking-for-pointer-arithmetic.patch bpf-add-sanity-check-for-upper-ptr_limit.patch bpf-selftests-fix-up-some-test_verifier-cases-for-unprivileged.patch arm64-unconditionally-set-virtual-cpu-id-registers.patch +rdma-srp-fix-support-for-unpopulated-and-unbalanced-numa-nodes.patch +fuse-fix-live-lock-in-fuse_iget.patch