commit: 25387cd201c8d4fe72a2321d30fcdf209f84c544 Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Wed Jul 5 20:28:46 2023 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Wed Jul 5 20:28:46 2023 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=25387cd2
Linux patch 6.1.38 Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> 0000_README | 4 + 1037_linux-6.1.38.patch | 367 ++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 371 insertions(+) diff --git a/0000_README b/0000_README index 0d9f0d0b..6c8d0f22 100644 --- a/0000_README +++ b/0000_README @@ -191,6 +191,10 @@ Patch: 1036_linux-6.1.37.patch From: https://www.kernel.org Desc: Linux 6.1.37 +Patch: 1037_linux-6.1.38.patch +From: https://www.kernel.org +Desc: Linux 6.1.38 + Patch: 1500_XATTR_USER_PREFIX.patch From: https://bugs.gentoo.org/show_bug.cgi?id=470644 Desc: Support for namespace user.pax.* on tmpfs. diff --git a/1037_linux-6.1.38.patch b/1037_linux-6.1.38.patch new file mode 100644 index 00000000..7a5cc22c --- /dev/null +++ b/1037_linux-6.1.38.patch @@ -0,0 +1,367 @@ +diff --git a/Documentation/process/changes.rst b/Documentation/process/changes.rst +index 9844ca3a71a61..c76b02d940946 100644 +--- a/Documentation/process/changes.rst ++++ b/Documentation/process/changes.rst +@@ -60,6 +60,7 @@ openssl & libcrypto 1.0.0 openssl version + bc 1.06.95 bc --version + Sphinx\ [#f1]_ 1.7 sphinx-build --version + cpio any cpio --version ++gtags (optional) 6.6.5 gtags --version + ====================== =============== ======================================== + + .. [#f1] Sphinx is needed only to build the Kernel documentation +@@ -174,6 +175,12 @@ You will need openssl to build kernels 3.7 and higher if module signing is + enabled. You will also need openssl development packages to build kernels 4.3 + and higher. + ++gtags / GNU GLOBAL (optional) ++----------------------------- ++ ++The kernel build requires GNU GLOBAL version 6.6.5 or later to generate ++tag files through ``make gtags``. This is due to its use of the gtags ++``-C (--directory)`` flag. + + System utilities + **************** +diff --git a/Makefile b/Makefile +index 26d73ce7e9267..57c891b8b13cc 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 6 + PATCHLEVEL = 1 +-SUBLEVEL = 37 ++SUBLEVEL = 38 + EXTRAVERSION = + NAME = Curry Ramen + +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +index 003aa9e47085e..5a8a4cda7e987 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +@@ -2363,6 +2363,10 @@ int amdgpu_vm_ioctl(struct drm_device *dev, void *data, struct drm_file *filp) + long timeout = msecs_to_jiffies(2000); + int r; + ++ /* No valid flags defined yet */ ++ if (args->in.flags) ++ return -EINVAL; ++ + switch (args->in.op) { + case AMDGPU_VM_OP_RESERVE_VMID: + /* We only have requirement to reserve vmid from gfxhub */ +diff --git a/drivers/gpu/drm/amd/display/dc/core/dc.c b/drivers/gpu/drm/amd/display/dc/core/dc.c +index af7aefe285ffd..087a4838488b2 100644 +--- a/drivers/gpu/drm/amd/display/dc/core/dc.c ++++ b/drivers/gpu/drm/amd/display/dc/core/dc.c +@@ -401,8 +401,13 @@ bool dc_stream_adjust_vmin_vmax(struct dc *dc, + { + int i; + +- if (memcmp(adjust, &stream->adjust, sizeof(struct dc_crtc_timing_adjust)) == 0) +- return true; ++ /* ++ * Don't adjust DRR while there's bandwidth optimizations pending to ++ * avoid conflicting with firmware updates. ++ */ ++ if (dc->ctx->dce_version > DCE_VERSION_MAX) ++ if (dc->optimized_required || dc->wm_optimized_required) ++ return false; + + stream->adjust.v_total_max = adjust->v_total_max; + stream->adjust.v_total_mid = adjust->v_total_mid; +@@ -2024,27 +2029,33 @@ void dc_post_update_surfaces_to_stream(struct dc *dc) + + post_surface_trace(dc); + +- if (dc->ctx->dce_version >= DCE_VERSION_MAX) +- TRACE_DCN_CLOCK_STATE(&context->bw_ctx.bw.dcn.clk); +- else ++ /* ++ * Only relevant for DCN behavior where we can guarantee the optimization ++ * is safe to apply - retain the legacy behavior for DCE. ++ */ ++ ++ if (dc->ctx->dce_version < DCE_VERSION_MAX) + TRACE_DCE_CLOCK_STATE(&context->bw_ctx.bw.dce); ++ else { ++ TRACE_DCN_CLOCK_STATE(&context->bw_ctx.bw.dcn.clk); + +- if (is_flip_pending_in_pipes(dc, context)) +- return; ++ if (is_flip_pending_in_pipes(dc, context)) ++ return; + +- for (i = 0; i < dc->res_pool->pipe_count; i++) +- if (context->res_ctx.pipe_ctx[i].stream == NULL || +- context->res_ctx.pipe_ctx[i].plane_state == NULL) { +- context->res_ctx.pipe_ctx[i].pipe_idx = i; +- dc->hwss.disable_plane(dc, &context->res_ctx.pipe_ctx[i]); +- } ++ for (i = 0; i < dc->res_pool->pipe_count; i++) ++ if (context->res_ctx.pipe_ctx[i].stream == NULL || ++ context->res_ctx.pipe_ctx[i].plane_state == NULL) { ++ context->res_ctx.pipe_ctx[i].pipe_idx = i; ++ dc->hwss.disable_plane(dc, &context->res_ctx.pipe_ctx[i]); ++ } + +- process_deferred_updates(dc); ++ process_deferred_updates(dc); + +- dc->hwss.optimize_bandwidth(dc, context); ++ dc->hwss.optimize_bandwidth(dc, context); + +- if (dc->debug.enable_double_buffered_dsc_pg_support) +- dc->hwss.update_dsc_pg(dc, context, true); ++ if (dc->debug.enable_double_buffered_dsc_pg_support) ++ dc->hwss.update_dsc_pg(dc, context, true); ++ } + + dc->optimized_required = false; + dc->wm_optimized_required = false; +@@ -3869,12 +3880,9 @@ void dc_commit_updates_for_stream(struct dc *dc, + if (new_pipe->plane_state && new_pipe->plane_state != old_pipe->plane_state) + new_pipe->plane_state->force_full_update = true; + } +- } else if (update_type == UPDATE_TYPE_FAST && dc_ctx->dce_version >= DCE_VERSION_MAX) { ++ } else if (update_type == UPDATE_TYPE_FAST) { + /* + * Previous frame finished and HW is ready for optimization. +- * +- * Only relevant for DCN behavior where we can guarantee the optimization +- * is safe to apply - retain the legacy behavior for DCE. + */ + dc_post_update_surfaces_to_stream(dc); + } +diff --git a/drivers/nubus/proc.c b/drivers/nubus/proc.c +index 1fd667852271f..cd4bd06cf3094 100644 +--- a/drivers/nubus/proc.c ++++ b/drivers/nubus/proc.c +@@ -137,6 +137,18 @@ static int nubus_proc_rsrc_show(struct seq_file *m, void *v) + return 0; + } + ++static int nubus_rsrc_proc_open(struct inode *inode, struct file *file) ++{ ++ return single_open(file, nubus_proc_rsrc_show, inode); ++} ++ ++static const struct proc_ops nubus_rsrc_proc_ops = { ++ .proc_open = nubus_rsrc_proc_open, ++ .proc_read = seq_read, ++ .proc_lseek = seq_lseek, ++ .proc_release = single_release, ++}; ++ + void nubus_proc_add_rsrc_mem(struct proc_dir_entry *procdir, + const struct nubus_dirent *ent, + unsigned int size) +@@ -152,8 +164,8 @@ void nubus_proc_add_rsrc_mem(struct proc_dir_entry *procdir, + pded = nubus_proc_alloc_pde_data(nubus_dirptr(ent), size); + else + pded = NULL; +- proc_create_single_data(name, S_IFREG | 0444, procdir, +- nubus_proc_rsrc_show, pded); ++ proc_create_data(name, S_IFREG | 0444, procdir, ++ &nubus_rsrc_proc_ops, pded); + } + + void nubus_proc_add_rsrc(struct proc_dir_entry *procdir, +@@ -166,9 +178,9 @@ void nubus_proc_add_rsrc(struct proc_dir_entry *procdir, + return; + + snprintf(name, sizeof(name), "%x", ent->type); +- proc_create_single_data(name, S_IFREG | 0444, procdir, +- nubus_proc_rsrc_show, +- nubus_proc_alloc_pde_data(data, 0)); ++ proc_create_data(name, S_IFREG | 0444, procdir, ++ &nubus_rsrc_proc_ops, ++ nubus_proc_alloc_pde_data(data, 0)); + } + + /* +diff --git a/drivers/pci/pci-acpi.c b/drivers/pci/pci-acpi.c +index 1698205dd73cb..7aa1c20582ab8 100644 +--- a/drivers/pci/pci-acpi.c ++++ b/drivers/pci/pci-acpi.c +@@ -1043,6 +1043,16 @@ bool acpi_pci_bridge_d3(struct pci_dev *dev) + return false; + } + ++static void acpi_pci_config_space_access(struct pci_dev *dev, bool enable) ++{ ++ int val = enable ? ACPI_REG_CONNECT : ACPI_REG_DISCONNECT; ++ int ret = acpi_evaluate_reg(ACPI_HANDLE(&dev->dev), ++ ACPI_ADR_SPACE_PCI_CONFIG, val); ++ if (ret) ++ pci_dbg(dev, "ACPI _REG %s evaluation failed (%d)\n", ++ enable ? "connect" : "disconnect", ret); ++} ++ + int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state) + { + struct acpi_device *adev = ACPI_COMPANION(&dev->dev); +@@ -1053,32 +1063,49 @@ int acpi_pci_set_power_state(struct pci_dev *dev, pci_power_t state) + [PCI_D3hot] = ACPI_STATE_D3_HOT, + [PCI_D3cold] = ACPI_STATE_D3_COLD, + }; +- int error = -EINVAL; ++ int error; + + /* If the ACPI device has _EJ0, ignore the device */ + if (!adev || acpi_has_method(adev->handle, "_EJ0")) + return -ENODEV; + + switch (state) { +- case PCI_D3cold: +- if (dev_pm_qos_flags(&dev->dev, PM_QOS_FLAG_NO_POWER_OFF) == +- PM_QOS_FLAGS_ALL) { +- error = -EBUSY; +- break; +- } +- fallthrough; + case PCI_D0: + case PCI_D1: + case PCI_D2: + case PCI_D3hot: +- error = acpi_device_set_power(adev, state_conv[state]); ++ case PCI_D3cold: ++ break; ++ default: ++ return -EINVAL; ++ } ++ ++ if (state == PCI_D3cold) { ++ if (dev_pm_qos_flags(&dev->dev, PM_QOS_FLAG_NO_POWER_OFF) == ++ PM_QOS_FLAGS_ALL) ++ return -EBUSY; ++ ++ /* Notify AML lack of PCI config space availability */ ++ acpi_pci_config_space_access(dev, false); + } + +- if (!error) +- pci_dbg(dev, "power state changed by ACPI to %s\n", +- acpi_power_state_string(adev->power.state)); ++ error = acpi_device_set_power(adev, state_conv[state]); ++ if (error) ++ return error; + +- return error; ++ pci_dbg(dev, "power state changed by ACPI to %s\n", ++ acpi_power_state_string(adev->power.state)); ++ ++ /* ++ * Notify AML of PCI config space availability. Config space is ++ * accessible in all states except D3cold; the only transitions ++ * that change availability are transitions to D3cold and from ++ * D3cold to D0. ++ */ ++ if (state == PCI_D0) ++ acpi_pci_config_space_access(dev, true); ++ ++ return 0; + } + + pci_power_t acpi_pci_get_power_state(struct pci_dev *dev) +diff --git a/include/linux/mm.h b/include/linux/mm.h +index f5b6ef943ede2..b8ed44f401b58 100644 +--- a/include/linux/mm.h ++++ b/include/linux/mm.h +@@ -378,7 +378,7 @@ extern unsigned int kobjsize(const void *objp); + #endif /* CONFIG_HAVE_ARCH_USERFAULTFD_MINOR */ + + /* Bits set in the VMA until the stack is in its final location */ +-#define VM_STACK_INCOMPLETE_SETUP (VM_RAND_READ | VM_SEQ_READ) ++#define VM_STACK_INCOMPLETE_SETUP (VM_RAND_READ | VM_SEQ_READ | VM_STACK_EARLY) + + #define TASK_EXEC ((current->personality & READ_IMPLIES_EXEC) ? VM_EXEC : 0) + +@@ -400,8 +400,10 @@ extern unsigned int kobjsize(const void *objp); + + #ifdef CONFIG_STACK_GROWSUP + #define VM_STACK VM_GROWSUP ++#define VM_STACK_EARLY VM_GROWSDOWN + #else + #define VM_STACK VM_GROWSDOWN ++#define VM_STACK_EARLY 0 + #endif + + #define VM_STACK_FLAGS (VM_STACK | VM_STACK_DEFAULT_FLAGS | VM_ACCOUNT) +diff --git a/mm/nommu.c b/mm/nommu.c +index da26b3fec9ebe..8e8fe491d914a 100644 +--- a/mm/nommu.c ++++ b/mm/nommu.c +@@ -688,8 +688,13 @@ EXPORT_SYMBOL(find_vma); + struct vm_area_struct *lock_mm_and_find_vma(struct mm_struct *mm, + unsigned long addr, struct pt_regs *regs) + { ++ struct vm_area_struct *vma; ++ + mmap_read_lock(mm); +- return vma_lookup(mm, addr); ++ vma = vma_lookup(mm, addr); ++ if (!vma) ++ mmap_read_unlock(mm); ++ return vma; + } + + /* +diff --git a/scripts/tags.sh b/scripts/tags.sh +index 0d045182c08c0..f23b9b7ed0159 100755 +--- a/scripts/tags.sh ++++ b/scripts/tags.sh +@@ -25,6 +25,13 @@ else + tree=${srctree}/ + fi + ++# gtags(1) refuses to index any file outside of its current working dir. ++# If gtags indexing is requested and the build output directory is not ++# the kernel source tree, index all files in absolute-path form. ++if [[ "$1" == "gtags" && -n "${tree}" ]]; then ++ tree=$(realpath "$tree")/ ++fi ++ + # Detect if ALLSOURCE_ARCHS is set. If not, we assume SRCARCH + if [ "${ALLSOURCE_ARCHS}" = "" ]; then + ALLSOURCE_ARCHS=${SRCARCH} +@@ -124,7 +131,7 @@ docscope() + + dogtags() + { +- all_target_sources | gtags -i -f - ++ all_target_sources | gtags -i -C "${tree:-.}" -f - "$PWD" + } + + # Basic regular expressions with an optional /kind-spec/ for ctags and +diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c +index a3a165ae933ad..98014f9375686 100644 +--- a/tools/perf/util/symbol.c ++++ b/tools/perf/util/symbol.c +@@ -1368,10 +1368,23 @@ static int dso__load_kcore(struct dso *dso, struct map *map, + + /* Find the kernel map using the '_stext' symbol */ + if (!kallsyms__get_function_start(kallsyms_filename, "_stext", &stext)) { ++ u64 replacement_size = 0; ++ + list_for_each_entry(new_map, &md.maps, node) { +- if (stext >= new_map->start && stext < new_map->end) { ++ u64 new_size = new_map->end - new_map->start; ++ ++ if (!(stext >= new_map->start && stext < new_map->end)) ++ continue; ++ ++ /* ++ * On some architectures, ARM64 for example, the kernel ++ * text can get allocated inside of the vmalloc segment. ++ * Select the smallest matching segment, in case stext ++ * falls within more than one in the list. ++ */ ++ if (!replacement_map || new_size < replacement_size) { + replacement_map = new_map; +- break; ++ replacement_size = new_size; + } + } + }
