linux 6.5.3-chos1

linux/0001-ZEN-Add-sysctl-and-CONFIG-to-disallow-unprivileged-C.patch

@@ -1,7 +1,7 @@
-From 8659d263820b50c42036dd38fff16e0f6852575d Mon Sep 17 00:00:00 2001
+From 92b8cd4f582347e53163d544db15d20f563d1c17 Mon Sep 17 00:00:00 2001
 From: "Jan Alexander Steffens (heftig)" <[email protected]>
 Date: Mon, 16 Sep 2019 04:53:20 +0200
-Subject: [PATCH 1/6] ZEN: Add sysctl and CONFIG to disallow unprivileged
+Subject: [PATCH 1/8] ZEN: Add sysctl and CONFIG to disallow unprivileged
  CLONE_NEWUSER
 
 Our default behavior continues to match the vanilla kernel.
@@ -36,10 +36,10 @@ index 45f09bec02c48..87b20e2ee2744 100644
  {
  	return &init_user_ns;
 diff --git a/init/Kconfig b/init/Kconfig
-index f7f65af4ee129..c2ecb3bb33928 100644
+index 5e7d4885d1bf8..13ad937752373 100644
 --- a/init/Kconfig
 +++ b/init/Kconfig
-@@ -1225,6 +1225,22 @@ config USER_NS
+@@ -1226,6 +1226,22 @@ config USER_NS
 
  	  If unsure, say N.
 

linux/0002-drivers-firmware-skip-simpledrm-if-nvidia-drm.modese.patch

@@ -1,7 +1,7 @@
-From f0d16bed34435cef3908134d6af13aee7793cfdc Mon Sep 17 00:00:00 2001
+From 5e9d8dd3971972048485610161c2556a7608849e Mon Sep 17 00:00:00 2001
 From: Javier Martinez Canillas <[email protected]>
 Date: Thu, 19 May 2022 14:40:07 +0200
-Subject: [PATCH 2/6] drivers/firmware: skip simpledrm if nvidia-drm.modeset=1
+Subject: [PATCH 2/8] drivers/firmware: skip simpledrm if nvidia-drm.modeset=1
  is set
 
 The Nvidia proprietary driver has some bugs that leads to issues if used

linux/0003-sphinx-kfigure.py-Convert-outdir-to-str-before-using.patch

@@ -0,0 +1,33 @@
+From 37d1bd4999f06c7c4b3094cb74b7614c552ecc1d Mon Sep 17 00:00:00 2001
+From: "Jan Alexander Steffens (heftig)" <[email protected]>
+Date: Thu, 24 Aug 2023 01:28:17 +0200
+Subject: [PATCH 3/8] sphinx: kfigure.py: Convert outdir to str before using
+ len
+
+Sphinx 7.2 replaced several uses of str with pathlib Paths, causing the
+build to fail with a TypeError when attempting to use len on one.
+
+Patch by @loqs; thanks.
+
+Fixes: https://bugs.archlinux.org/task/79446
+Signed-off-by: Jan Alexander Steffens (heftig) <[email protected]>
+---
+ Documentation/sphinx/kfigure.py | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/Documentation/sphinx/kfigure.py b/Documentation/sphinx/kfigure.py
+index cefdbb7e75230..13e885bbd499c 100644
+--- a/Documentation/sphinx/kfigure.py
++++ b/Documentation/sphinx/kfigure.py
+@@ -309,7 +309,7 @@ def convert_image(img_node, translator, src_fname=None):
+     if dst_fname:
+         # the builder needs not to copy one more time, so pop it if exists.
+         translator.builder.images.pop(img_node['uri'], None)
+-        _name = dst_fname[len(translator.builder.outdir) + 1:]
++        _name = dst_fname[len(str(translator.builder.outdir)) + 1:]
+
+         if isNewer(dst_fname, src_fname):
+             kernellog.verbose(app,
+-- 
+2.41.0
+

linux/0004-ASoC-Intel-soc-acpi-fix-Dell-SKU-0B34.patch

@@ -0,0 +1,51 @@
+From eb39b2a95930f53bd2cb4fbda0e1372609dff976 Mon Sep 17 00:00:00 2001
+From: Pierre-Louis Bossart <[email protected]>
+Date: Tue, 5 Sep 2023 11:16:16 -0400
+Subject: [PATCH 4/8] ASoC: Intel: soc-acpi: fix Dell SKU 0B34
+
+The rule for the SoundWire tables is that the platforms with more
+devices need to be added first. We broke that rule with the Dell SKU
+0B34, and caused the second amplifier for SKU 0AF3 to be ignored.
+
+The fix is simple, we need to move the single-amplifier entry after
+the two-amplifier one.
+
+Fixes: b62a1a839b48 ("ASoC: Intel: soc-acpi: add tables for Dell SKU 0B34")
+Closes: https://github.com/thesofproject/linux/issues/4559
+Signed-off-by: Pierre-Louis Bossart <[email protected]>
+---
+ sound/soc/intel/common/soc-acpi-intel-adl-match.c | 12 ++++++------
+ 1 file changed, 6 insertions(+), 6 deletions(-)
+
+diff --git a/sound/soc/intel/common/soc-acpi-intel-adl-match.c b/sound/soc/intel/common/soc-acpi-intel-adl-match.c
+index bcd66e0094b4b..c4b57cca6b228 100644
+--- a/sound/soc/intel/common/soc-acpi-intel-adl-match.c
++++ b/sound/soc/intel/common/soc-acpi-intel-adl-match.c
+@@ -648,18 +648,18 @@ struct snd_soc_acpi_mach snd_soc_acpi_intel_adl_sdw_machines[] = {
+ 		.drv_name = "sof_sdw",
+ 		.sof_tplg_filename = "sof-adl-rt1316-l2-mono-rt714-l3.tplg",
+ 	},
+-	{
+-		.link_mask = 0x3, /* rt1316 on link1 & rt714 on link0 */
+-		.links = adl_sdw_rt1316_link1_rt714_link0,
+-		.drv_name = "sof_sdw",
+-		.sof_tplg_filename = "sof-adl-rt1316-l1-mono-rt714-l0.tplg",
+-	},
+ 	{
+ 		.link_mask = 0x7, /* rt714 on link0 & two rt1316s on link1 and link2 */
+ 		.links = adl_sdw_rt1316_link12_rt714_link0,
+ 		.drv_name = "sof_sdw",
+ 		.sof_tplg_filename = "sof-adl-rt1316-l12-rt714-l0.tplg",
+ 	},
++	{
++		.link_mask = 0x3, /* rt1316 on link1 & rt714 on link0 */
++		.links = adl_sdw_rt1316_link1_rt714_link0,
++		.drv_name = "sof_sdw",
++		.sof_tplg_filename = "sof-adl-rt1316-l1-mono-rt714-l0.tplg",
++	},
+ 	{
+ 		.link_mask = 0x5, /* 2 active links required */
+ 		.links = adl_sdw_rt1316_link2_rt714_link0,
+-- 
+2.41.0
+

linux/0005-btrfs-wait-on-uncached-block-groups-on-every-allocat.patch

@@ -0,0 +1,255 @@
+From 8da079307d115705e243d226591dcb4388cef7e2 Mon Sep 17 00:00:00 2001
+From: Josef Bacik <[email protected]>
+Date: Mon, 31 Jul 2023 16:28:43 -0400
+Subject: [PATCH 5/8] btrfs: wait on uncached block groups on every allocation
+ loop
+
+My initial fix for the generic/475 hangs was related to metadata, but
+our CI testing uncovered another case where we hang for similar reasons.
+We again have a task with a plug that is holding an outstanding request
+that is keeping the dm device from finishing it's suspend, and that task
+is stuck in the allocator.
+
+This time it is stuck trying to allocate data, but we do not have a
+block group that matches the size class.  The larger loop in the
+allocator looks like this (simplified of course)
+
+  find_free_extent
+    for_each_block_group {
+      ffe_ctl->cached == btrfs_block_group_cache_done(bg)
+      if (!ffe_ctl->cached)
+	ffe_ctl->have_caching_bg = true;
+      do_allocation()
+	btrfs_wait_block_group_cache_progress();
+    }
+
+    if (loop == LOOP_CACHING_WAIT && ffe_ctl->have_caching_bg)
+      go search again;
+
+In my earlier fix we were trying to allocate from the block group, but
+we weren't waiting for the progress because we were only waiting for the
+free space to be >= the amount of free space we wanted.  My fix made it
+so we waited for forward progress to be made as well, so we would be
+sure to wait.
+
+This time however we did not have a block group that matched our size
+class, so what was happening was this
+
+  find_free_extent
+    for_each_block_group {
+      ffe_ctl->cached == btrfs_block_group_cache_done(bg)
+      if (!ffe_ctl->cached)
+	ffe_ctl->have_caching_bg = true;
+      if (size_class_doesn't_match())
+	goto loop;
+      do_allocation()
+	btrfs_wait_block_group_cache_progress();
+  loop:
+      release_block_group(block_group);
+    }
+
+    if (loop == LOOP_CACHING_WAIT && ffe_ctl->have_caching_bg)
+      go search again;
+
+The size_class_doesn't_match() part was true, so we'd just skip this
+block group and never wait for caching, and then because we found a
+caching block group we'd just go back and do the loop again.  We never
+sleep and thus never flush the plug and we have the same deadlock.
+
+Fix the logic for waiting on the block group caching to instead do it
+unconditionally when we goto loop.  This takes the logic out of the
+allocation step, so now the loop looks more like this
+
+  find_free_extent
+    for_each_block_group {
+      ffe_ctl->cached == btrfs_block_group_cache_done(bg)
+      if (!ffe_ctl->cached)
+	ffe_ctl->have_caching_bg = true;
+      if (size_class_doesn't_match())
+	goto loop;
+      do_allocation()
+	btrfs_wait_block_group_cache_progress();
+  loop:
+      if (loop > LOOP_CACHING_NOWAIT && !ffe_ctl->retry_uncached &&
+	  !ffe_ctl->cached) {
+	 ffe_ctl->retry_uncached = true;
+	 btrfs_wait_block_group_cache_progress();
+      }
+
+      release_block_group(block_group);
+    }
+
+    if (loop == LOOP_CACHING_WAIT && ffe_ctl->have_caching_bg)
+      go search again;
+
+This simplifies the logic a lot, and makes sure that if we're hitting
+uncached block groups we're always waiting on them at some point.
+
+I ran this through 100 iterations of generic/475, as this particular
+case was harder to hit than the previous one.
+
+Signed-off-by: Josef Bacik <[email protected]>
+Signed-off-by: David Sterba <[email protected]>
+---
+ fs/btrfs/extent-tree.c | 61 +++++++++++++-----------------------------
+ fs/btrfs/extent-tree.h | 13 +++------
+ 2 files changed, 22 insertions(+), 52 deletions(-)
+
+diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
+index f396a9afa4032..6096bd98e6c70 100644
+--- a/fs/btrfs/extent-tree.c
++++ b/fs/btrfs/extent-tree.c
+@@ -3427,7 +3427,6 @@ btrfs_release_block_group(struct btrfs_block_group *cache,
+  * Helper function for find_free_extent().
+  *
+  * Return -ENOENT to inform caller that we need fallback to unclustered mode.
+- * Return -EAGAIN to inform caller that we need to re-search this block group
+  * Return >0 to inform caller that we find nothing
+  * Return 0 means we have found a location and set ffe_ctl->found_offset.
+  */
+@@ -3508,14 +3507,6 @@ static int find_free_extent_clustered(struct btrfs_block_group *bg,
+ 			trace_btrfs_reserve_extent_cluster(bg, ffe_ctl);
+ 			return 0;
+ 		}
+-	} else if (!ffe_ctl->cached && ffe_ctl->loop > LOOP_CACHING_NOWAIT &&
+-		   !ffe_ctl->retry_clustered) {
+-		spin_unlock(&last_ptr->refill_lock);
+-
+-		ffe_ctl->retry_clustered = true;
+-		btrfs_wait_block_group_cache_progress(bg, ffe_ctl->num_bytes +
+-				ffe_ctl->empty_cluster + ffe_ctl->empty_size);
+-		return -EAGAIN;
+ 	}
+ 	/*
+ 	 * At this point we either didn't find a cluster or we weren't able to
+@@ -3530,7 +3521,6 @@ static int find_free_extent_clustered(struct btrfs_block_group *bg,
+ /*
+  * Return >0 to inform caller that we find nothing
+  * Return 0 when we found an free extent and set ffe_ctrl->found_offset
+- * Return -EAGAIN to inform caller that we need to re-search this block group
+  */
+ static int find_free_extent_unclustered(struct btrfs_block_group *bg,
+ 					struct find_free_extent_ctl *ffe_ctl)
+@@ -3568,25 +3558,8 @@ static int find_free_extent_unclustered(struct btrfs_block_group *bg,
+ 	offset = btrfs_find_space_for_alloc(bg, ffe_ctl->search_start,
+ 			ffe_ctl->num_bytes, ffe_ctl->empty_size,
+ 			&ffe_ctl->max_extent_size);
+-
+-	/*
+-	 * If we didn't find a chunk, and we haven't failed on this block group
+-	 * before, and this block group is in the middle of caching and we are
+-	 * ok with waiting, then go ahead and wait for progress to be made, and
+-	 * set @retry_unclustered to true.
+-	 *
+-	 * If @retry_unclustered is true then we've already waited on this
+-	 * block group once and should move on to the next block group.
+-	 */
+-	if (!offset && !ffe_ctl->retry_unclustered && !ffe_ctl->cached &&
+-	    ffe_ctl->loop > LOOP_CACHING_NOWAIT) {
+-		btrfs_wait_block_group_cache_progress(bg, ffe_ctl->num_bytes +
+-						      ffe_ctl->empty_size);
+-		ffe_ctl->retry_unclustered = true;
+-		return -EAGAIN;
+-	} else if (!offset) {
++	if (!offset)
+ 		return 1;
+-	}
+ 	ffe_ctl->found_offset = offset;
+ 	return 0;
+ }
+@@ -3600,7 +3573,7 @@ static int do_allocation_clustered(struct btrfs_block_group *block_group,
+ 	/* We want to try and use the cluster allocator, so lets look there */
+ 	if (ffe_ctl->last_ptr && ffe_ctl->use_cluster) {
+ 		ret = find_free_extent_clustered(block_group, ffe_ctl, bg_ret);
+-		if (ret >= 0 || ret == -EAGAIN)
++		if (ret >= 0)
+ 			return ret;
+ 		/* ret == -ENOENT case falls through */
+ 	}
+@@ -3816,8 +3789,7 @@ static void release_block_group(struct btrfs_block_group *block_group,
+ {
+ 	switch (ffe_ctl->policy) {
+ 	case BTRFS_EXTENT_ALLOC_CLUSTERED:
+-		ffe_ctl->retry_clustered = false;
+-		ffe_ctl->retry_unclustered = false;
++		ffe_ctl->retry_uncached = false;
+ 		break;
+ 	case BTRFS_EXTENT_ALLOC_ZONED:
+ 		/* Nothing to do */
+@@ -4168,9 +4140,7 @@ static noinline int find_free_extent(struct btrfs_root *root,
+ 	ffe_ctl->orig_have_caching_bg = false;
+ 	ffe_ctl->index = btrfs_bg_flags_to_raid_index(ffe_ctl->flags);
+ 	ffe_ctl->loop = 0;
+-	/* For clustered allocation */
+-	ffe_ctl->retry_clustered = false;
+-	ffe_ctl->retry_unclustered = false;
++	ffe_ctl->retry_uncached = false;
+ 	ffe_ctl->cached = 0;
+ 	ffe_ctl->max_extent_size = 0;
+ 	ffe_ctl->total_free_space = 0;
+@@ -4321,16 +4291,12 @@ static noinline int find_free_extent(struct btrfs_root *root,
+
+ 		bg_ret = NULL;
+ 		ret = do_allocation(block_group, ffe_ctl, &bg_ret);
+-		if (ret == 0) {
+-			if (bg_ret && bg_ret != block_group) {
+-				btrfs_release_block_group(block_group,
+-							  ffe_ctl->delalloc);
+-				block_group = bg_ret;
+-			}
+-		} else if (ret == -EAGAIN) {
+-			goto have_block_group;
+-		} else if (ret > 0) {
++		if (ret > 0)
+ 			goto loop;
++
++		if (bg_ret && bg_ret != block_group) {
++			btrfs_release_block_group(block_group, ffe_ctl->delalloc);
++			block_group = bg_ret;
+ 		}
+
+ 		/* Checks */
+@@ -4371,6 +4337,15 @@ static noinline int find_free_extent(struct btrfs_root *root,
+ 		btrfs_release_block_group(block_group, ffe_ctl->delalloc);
+ 		break;
+ loop:
++		if (!ffe_ctl->cached && ffe_ctl->loop > LOOP_CACHING_NOWAIT &&
++		    !ffe_ctl->retry_uncached) {
++			ffe_ctl->retry_uncached = true;
++			btrfs_wait_block_group_cache_progress(block_group,
++						ffe_ctl->num_bytes +
++						ffe_ctl->empty_cluster +
++						ffe_ctl->empty_size);
++			goto have_block_group;
++		}
+ 		release_block_group(block_group, ffe_ctl, ffe_ctl->delalloc);
+ 		cond_resched();
+ 	}
+diff --git a/fs/btrfs/extent-tree.h b/fs/btrfs/extent-tree.h
+index 429d5c5700618..6bfba2f22fdd4 100644
+--- a/fs/btrfs/extent-tree.h
++++ b/fs/btrfs/extent-tree.h
+@@ -48,16 +48,11 @@ struct find_free_extent_ctl {
+ 	int loop;
+
+ 	/*
+-	 * Whether we're refilling a cluster, if true we need to re-search
+-	 * current block group but don't try to refill the cluster again.
++	 * Set to true if we're retrying the allocation on this block group
++	 * after waiting for caching progress, this is so that we retry only
++	 * once before moving on to another block group.
+ 	 */
+-	bool retry_clustered;
+-
+-	/*
+-	 * Whether we're updating free space cache, if true we need to re-search
+-	 * current block group but don't try updating free space cache again.
+-	 */
+-	bool retry_unclustered;
++	bool retry_uncached;
+
+ 	/* If current block group is cached */
+ 	int cached;
+-- 
+2.41.0
+