commit: 0b0b12cabf9c32c90ee268fd7db419a634e26f61 Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Wed Jul 5 20:26:23 2023 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Wed Jul 5 20:26:23 2023 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=0b0b12ca
Linux patch 6.4.2 Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> 0000_README | 4 + 1001_linux-6.4.2.patch | 554 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 558 insertions(+) diff --git a/0000_README b/0000_README index a09a44a9..f9224452 100644 --- a/0000_README +++ b/0000_README @@ -47,6 +47,10 @@ Patch: 1000_linux-6.4.1.patch From: https://www.kernel.org Desc: Linux 6.4.1 +Patch: 1001_linux-6.4.2.patch +From: https://www.kernel.org +Desc: Linux 6.4.2 + 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/1001_linux-6.4.2.patch b/1001_linux-6.4.2.patch new file mode 100644 index 00000000..a72ad77b --- /dev/null +++ b/1001_linux-6.4.2.patch @@ -0,0 +1,554 @@ +diff --git a/Documentation/process/changes.rst b/Documentation/process/changes.rst +index ef540865ad22e..a9ef00509c9b1 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 9f6376cbafebe..bcac81556b569 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 6 + PATCHLEVEL = 4 +-SUBLEVEL = 1 ++SUBLEVEL = 2 + EXTRAVERSION = + NAME = Hurr durr I'ma ninja sloth + +diff --git a/arch/arm64/mm/fault.c b/arch/arm64/mm/fault.c +index 8a169bdb4d534..df1386a60d521 100644 +--- a/arch/arm64/mm/fault.c ++++ b/arch/arm64/mm/fault.c +@@ -522,9 +522,7 @@ static int __kprobes do_page_fault(unsigned long far, unsigned long esr, + unsigned long vm_flags; + unsigned int mm_flags = FAULT_FLAG_DEFAULT; + unsigned long addr = untagged_addr(far); +-#ifdef CONFIG_PER_VMA_LOCK + struct vm_area_struct *vma; +-#endif + + if (kprobe_page_fault(regs, esr)) + return 0; +diff --git a/drivers/cxl/core/pci.c b/drivers/cxl/core/pci.c +index 67f4ab6daa34f..74962b18e3b21 100644 +--- a/drivers/cxl/core/pci.c ++++ b/drivers/cxl/core/pci.c +@@ -308,36 +308,17 @@ static void disable_hdm(void *_cxlhdm) + hdm + CXL_HDM_DECODER_CTRL_OFFSET); + } + +-int devm_cxl_enable_hdm(struct cxl_port *port, struct cxl_hdm *cxlhdm) ++static int devm_cxl_enable_hdm(struct device *host, struct cxl_hdm *cxlhdm) + { +- void __iomem *hdm; ++ void __iomem *hdm = cxlhdm->regs.hdm_decoder; + u32 global_ctrl; + +- /* +- * If the hdm capability was not mapped there is nothing to enable and +- * the caller is responsible for what happens next. For example, +- * emulate a passthrough decoder. +- */ +- if (IS_ERR(cxlhdm)) +- return 0; +- +- hdm = cxlhdm->regs.hdm_decoder; + global_ctrl = readl(hdm + CXL_HDM_DECODER_CTRL_OFFSET); +- +- /* +- * If the HDM decoder capability was enabled on entry, skip +- * registering disable_hdm() since this decode capability may be +- * owned by platform firmware. +- */ +- if (global_ctrl & CXL_HDM_DECODER_ENABLE) +- return 0; +- + writel(global_ctrl | CXL_HDM_DECODER_ENABLE, + hdm + CXL_HDM_DECODER_CTRL_OFFSET); + +- return devm_add_action_or_reset(&port->dev, disable_hdm, cxlhdm); ++ return devm_add_action_or_reset(host, disable_hdm, cxlhdm); + } +-EXPORT_SYMBOL_NS_GPL(devm_cxl_enable_hdm, CXL); + + int cxl_dvsec_rr_decode(struct device *dev, int d, + struct cxl_endpoint_dvsec_info *info) +@@ -511,7 +492,7 @@ int cxl_hdm_decode_init(struct cxl_dev_state *cxlds, struct cxl_hdm *cxlhdm, + if (info->mem_enabled) + return 0; + +- rc = devm_cxl_enable_hdm(port, cxlhdm); ++ rc = devm_cxl_enable_hdm(&port->dev, cxlhdm); + if (rc) + return rc; + +diff --git a/drivers/cxl/cxl.h b/drivers/cxl/cxl.h +index f93a285389621..044a92d9813e2 100644 +--- a/drivers/cxl/cxl.h ++++ b/drivers/cxl/cxl.h +@@ -710,7 +710,6 @@ struct cxl_endpoint_dvsec_info { + struct cxl_hdm; + struct cxl_hdm *devm_cxl_setup_hdm(struct cxl_port *port, + struct cxl_endpoint_dvsec_info *info); +-int devm_cxl_enable_hdm(struct cxl_port *port, struct cxl_hdm *cxlhdm); + int devm_cxl_enumerate_decoders(struct cxl_hdm *cxlhdm, + struct cxl_endpoint_dvsec_info *info); + int devm_cxl_add_passthrough_decoder(struct cxl_port *port); +diff --git a/drivers/cxl/port.c b/drivers/cxl/port.c +index c23b6164e1c0f..07c5ac598da1c 100644 +--- a/drivers/cxl/port.c ++++ b/drivers/cxl/port.c +@@ -60,17 +60,13 @@ static int discover_region(struct device *dev, void *root) + static int cxl_switch_port_probe(struct cxl_port *port) + { + struct cxl_hdm *cxlhdm; +- int rc, nr_dports; +- +- nr_dports = devm_cxl_port_enumerate_dports(port); +- if (nr_dports < 0) +- return nr_dports; ++ int rc; + +- cxlhdm = devm_cxl_setup_hdm(port, NULL); +- rc = devm_cxl_enable_hdm(port, cxlhdm); +- if (rc) ++ rc = devm_cxl_port_enumerate_dports(port); ++ if (rc < 0) + return rc; + ++ cxlhdm = devm_cxl_setup_hdm(port, NULL); + if (!IS_ERR(cxlhdm)) + return devm_cxl_enumerate_decoders(cxlhdm, NULL); + +@@ -79,7 +75,7 @@ static int cxl_switch_port_probe(struct cxl_port *port) + return PTR_ERR(cxlhdm); + } + +- if (nr_dports == 1) { ++ if (rc == 1) { + dev_dbg(&port->dev, "Fallback to passthrough decoder\n"); + return devm_cxl_add_passthrough_decoder(port); + } +diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +index 3c0310576b3bf..5b3a70becbdf4 100644 +--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c ++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c +@@ -2368,6 +2368,10 @@ int amdgpu_vm_ioctl(struct drm_device *dev, void *data, struct drm_file *filp) + struct amdgpu_fpriv *fpriv = filp->driver_priv; + 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/md/dm-ioctl.c b/drivers/md/dm-ioctl.c +index 7d5c9c582ed2d..0d2fa7f86a544 100644 +--- a/drivers/md/dm-ioctl.c ++++ b/drivers/md/dm-ioctl.c +@@ -1830,30 +1830,36 @@ static ioctl_fn lookup_ioctl(unsigned int cmd, int *ioctl_flags) + * As well as checking the version compatibility this always + * copies the kernel interface version out. + */ +-static int check_version(unsigned int cmd, struct dm_ioctl __user *user) ++static int check_version(unsigned int cmd, struct dm_ioctl __user *user, ++ struct dm_ioctl *kernel_params) + { +- uint32_t version[3]; + int r = 0; + +- if (copy_from_user(version, user->version, sizeof(version))) ++ /* Make certain version is first member of dm_ioctl struct */ ++ BUILD_BUG_ON(offsetof(struct dm_ioctl, version) != 0); ++ ++ if (copy_from_user(kernel_params->version, user->version, sizeof(kernel_params->version))) + return -EFAULT; + +- if ((version[0] != DM_VERSION_MAJOR) || +- (version[1] > DM_VERSION_MINOR)) { ++ if ((kernel_params->version[0] != DM_VERSION_MAJOR) || ++ (kernel_params->version[1] > DM_VERSION_MINOR)) { + DMERR("ioctl interface mismatch: kernel(%u.%u.%u), user(%u.%u.%u), cmd(%d)", + DM_VERSION_MAJOR, DM_VERSION_MINOR, + DM_VERSION_PATCHLEVEL, +- version[0], version[1], version[2], cmd); ++ kernel_params->version[0], ++ kernel_params->version[1], ++ kernel_params->version[2], ++ cmd); + r = -EINVAL; + } + + /* + * Fill in the kernel version. + */ +- version[0] = DM_VERSION_MAJOR; +- version[1] = DM_VERSION_MINOR; +- version[2] = DM_VERSION_PATCHLEVEL; +- if (copy_to_user(user->version, version, sizeof(version))) ++ kernel_params->version[0] = DM_VERSION_MAJOR; ++ kernel_params->version[1] = DM_VERSION_MINOR; ++ kernel_params->version[2] = DM_VERSION_PATCHLEVEL; ++ if (copy_to_user(user->version, kernel_params->version, sizeof(kernel_params->version))) + return -EFAULT; + + return r; +@@ -1879,7 +1885,10 @@ static int copy_params(struct dm_ioctl __user *user, struct dm_ioctl *param_kern + const size_t minimum_data_size = offsetof(struct dm_ioctl, data); + unsigned int noio_flag; + +- if (copy_from_user(param_kernel, user, minimum_data_size)) ++ /* check_version() already copied version from userspace, avoid TOCTOU */ ++ if (copy_from_user((char *)param_kernel + sizeof(param_kernel->version), ++ (char __user *)user + sizeof(param_kernel->version), ++ minimum_data_size - sizeof(param_kernel->version))) + return -EFAULT; + + if (param_kernel->data_size < minimum_data_size) { +@@ -1991,7 +2000,7 @@ static int ctl_ioctl(struct file *file, uint command, struct dm_ioctl __user *us + * Check the interface version passed in. This also + * writes out the kernel's interface version. + */ +- r = check_version(cmd, user); ++ r = check_version(cmd, user, ¶m_kernel); + if (r) + return r; + +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 052a611081ecd..a05350a4e49cb 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/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c +index ecfdfb2529a36..581201818ed8f 100644 +--- a/fs/hugetlbfs/inode.c ++++ b/fs/hugetlbfs/inode.c +@@ -821,7 +821,6 @@ static long hugetlbfs_fallocate(struct file *file, int mode, loff_t offset, + */ + struct folio *folio; + unsigned long addr; +- bool present; + + cond_resched(); + +@@ -845,10 +844,9 @@ static long hugetlbfs_fallocate(struct file *file, int mode, loff_t offset, + mutex_lock(&hugetlb_fault_mutex_table[hash]); + + /* See if already present in mapping to avoid alloc/free */ +- rcu_read_lock(); +- present = page_cache_next_miss(mapping, index, 1) != index; +- rcu_read_unlock(); +- if (present) { ++ folio = filemap_get_folio(mapping, index); ++ if (!IS_ERR(folio)) { ++ folio_put(folio); + mutex_unlock(&hugetlb_fault_mutex_table[hash]); + hugetlb_drop_vma_policy(&pseudo_vma); + continue; +diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c +index a910b9a638c5e..8172dd4135a1d 100644 +--- a/fs/nfs/inode.c ++++ b/fs/nfs/inode.c +@@ -845,7 +845,7 @@ int nfs_getattr(struct mnt_idmap *idmap, const struct path *path, + + request_mask &= STATX_TYPE | STATX_MODE | STATX_NLINK | STATX_UID | + STATX_GID | STATX_ATIME | STATX_MTIME | STATX_CTIME | +- STATX_INO | STATX_SIZE | STATX_BLOCKS | STATX_BTIME | ++ STATX_INO | STATX_SIZE | STATX_BLOCKS | + STATX_CHANGE_COOKIE; + + if ((query_flags & AT_STATX_DONT_SYNC) && !force_sync) { +diff --git a/include/linux/mm.h b/include/linux/mm.h +index 6cbcc55a80b02..9e10485f37e7f 100644 +--- a/include/linux/mm.h ++++ b/include/linux/mm.h +@@ -377,7 +377,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) + +@@ -399,8 +399,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/hugetlb.c b/mm/hugetlb.c +index f154019e6b840..f791076da157c 100644 +--- a/mm/hugetlb.c ++++ b/mm/hugetlb.c +@@ -5731,13 +5731,13 @@ static bool hugetlbfs_pagecache_present(struct hstate *h, + { + struct address_space *mapping = vma->vm_file->f_mapping; + pgoff_t idx = vma_hugecache_offset(h, vma, address); +- bool present; +- +- rcu_read_lock(); +- present = page_cache_next_miss(mapping, idx, 1) != idx; +- rcu_read_unlock(); ++ struct folio *folio; + +- return present; ++ folio = filemap_get_folio(mapping, idx); ++ if (IS_ERR(folio)) ++ return false; ++ folio_put(folio); ++ return true; + } + + int hugetlb_add_to_page_cache(struct folio *folio, struct address_space *mapping, +diff --git a/mm/nommu.c b/mm/nommu.c +index fdc392735ec6d..c072a660ec2cf 100644 +--- a/mm/nommu.c ++++ b/mm/nommu.c +@@ -637,8 +637,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 ea31640b26715..f6b3c7cd39c7c 100755 +--- a/scripts/tags.sh ++++ b/scripts/tags.sh +@@ -32,6 +32,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} +@@ -131,7 +138,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/include/nolibc/arch-x86_64.h b/tools/include/nolibc/arch-x86_64.h +index f7f2a11d4c3b0..f52725f51fca6 100644 +--- a/tools/include/nolibc/arch-x86_64.h ++++ b/tools/include/nolibc/arch-x86_64.h +@@ -190,7 +190,7 @@ const unsigned long *_auxv __attribute__((weak)); + * 2) The deepest stack frame should be zero (the %rbp). + * + */ +-void __attribute__((weak,noreturn,optimize("omit-frame-pointer"))) _start(void) ++void __attribute__((weak,noreturn,optimize("omit-frame-pointer"),no_stack_protector)) _start(void) + { + __asm__ volatile ( + #ifdef NOLIBC_STACKPROTECTOR +diff --git a/tools/testing/cxl/Kbuild b/tools/testing/cxl/Kbuild +index 6f9347ade82cd..fba7bec96acd1 100644 +--- a/tools/testing/cxl/Kbuild ++++ b/tools/testing/cxl/Kbuild +@@ -6,7 +6,6 @@ ldflags-y += --wrap=acpi_pci_find_root + ldflags-y += --wrap=nvdimm_bus_register + ldflags-y += --wrap=devm_cxl_port_enumerate_dports + ldflags-y += --wrap=devm_cxl_setup_hdm +-ldflags-y += --wrap=devm_cxl_enable_hdm + ldflags-y += --wrap=devm_cxl_add_passthrough_decoder + ldflags-y += --wrap=devm_cxl_enumerate_decoders + ldflags-y += --wrap=cxl_await_media_ready +diff --git a/tools/testing/cxl/test/mock.c b/tools/testing/cxl/test/mock.c +index 2844165276440..de3933a776fdb 100644 +--- a/tools/testing/cxl/test/mock.c ++++ b/tools/testing/cxl/test/mock.c +@@ -149,21 +149,6 @@ struct cxl_hdm *__wrap_devm_cxl_setup_hdm(struct cxl_port *port, + } + EXPORT_SYMBOL_NS_GPL(__wrap_devm_cxl_setup_hdm, CXL); + +-int __wrap_devm_cxl_enable_hdm(struct cxl_port *port, struct cxl_hdm *cxlhdm) +-{ +- int index, rc; +- struct cxl_mock_ops *ops = get_cxl_mock_ops(&index); +- +- if (ops && ops->is_mock_port(port->uport)) +- rc = 0; +- else +- rc = devm_cxl_enable_hdm(port, cxlhdm); +- put_cxl_mock_ops(index); +- +- return rc; +-} +-EXPORT_SYMBOL_NS_GPL(__wrap_devm_cxl_enable_hdm, CXL); +- + int __wrap_devm_cxl_add_passthrough_decoder(struct cxl_port *port) + { + int rc, index;
