mirror of
https://github.com/torvalds/linux.git
synced 2024-12-04 01:51:34 +00:00
5ccac54f3e
The hmem enabling in commit cf8741ac57 ("ACPI: NUMA: HMAT: Register
"soft reserved" memory as an "hmem" device") only registered ranges to the
hmem driver for each soft-reservation that also appeared in the HMAT.
While this is meant to encourage platform firmware to "do the right thing"
and publish an HMAT, the corollary is that platforms that fail to publish
an accurate HMAT will strand memory from Linux usage. Additionally, the
"efi_fake_mem" kernel command line option enabling will strand memory by
default without an HMAT.
Arrange for "soft reserved" memory that goes unclaimed by HMAT entries to
be published as raw resource ranges for the hmem driver to consume.
Include a module parameter to disable either this fallback behavior, or
the hmat enabling from creating hmem devices. The module parameter
requires the hmem device enabling to have unique name in the module
namespace: "device_hmem".
The driver depends on the architecture providing phys_to_target_node()
which is only x86 via numa_meminfo() and arm64 via a generic memblock
implementation.
[joao.m.martins@oracle.com: require NUMA_KEEP_MEMINFO for phys_to_target_node()]
Link: https://lkml.kernel.org/r/aaae71a7-4846-f5cc-5acf-cf05fdb1f2dc@oracle.com
Signed-off-by: Dan Williams <dan.j.williams@intel.com>
Signed-off-by: Joao Martins <joao.m.martins@oracle.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Reviewed-by: Joao Martins <joao.m.martins@oracle.com>
Cc: Jonathan Cameron <Jonathan.Cameron@huawei.com>
Cc: Brice Goglin <Brice.Goglin@inria.fr>
Cc: Jeff Moyer <jmoyer@redhat.com>
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Will Deacon <will@kernel.org>
Cc: Andy Lutomirski <luto@kernel.org>
Cc: Ard Biesheuvel <ardb@kernel.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Ben Skeggs <bskeggs@redhat.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: Daniel Vetter <daniel@ffwll.ch>
Cc: Dave Hansen <dave.hansen@linux.intel.com>
Cc: Dave Jiang <dave.jiang@intel.com>
Cc: David Airlie <airlied@linux.ie>
Cc: David Hildenbrand <david@redhat.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Ira Weiny <ira.weiny@intel.com>
Cc: Jason Gunthorpe <jgg@mellanox.com>
Cc: Jia He <justin.he@arm.com>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Mike Rapoport <rppt@linux.ibm.com>
Cc: Paul Mackerras <paulus@ozlabs.org>
Cc: Pavel Tatashin <pasha.tatashin@soleen.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Tom Lendacky <thomas.lendacky@amd.com>
Cc: Vishal Verma <vishal.l.verma@intel.com>
Cc: Wei Yang <richard.weiyang@linux.alibaba.com>
Cc: Ard Biesheuvel <ard.biesheuvel@linaro.org>
Cc: Bjorn Helgaas <bhelgaas@google.com>
Cc: Boris Ostrovsky <boris.ostrovsky@oracle.com>
Cc: Hulk Robot <hulkci@huawei.com>
Cc: Jason Yan <yanaijie@huawei.com>
Cc: "Jérôme Glisse" <jglisse@redhat.com>
Cc: Juergen Gross <jgross@suse.com>
Cc: kernel test robot <lkp@intel.com>
Cc: Randy Dunlap <rdunlap@infradead.org>
Cc: Stefano Stabellini <sstabellini@kernel.org>
Cc: Vivek Goyal <vgoyal@redhat.com>
Link: https://lkml.kernel.org/r/159643098298.4062302.17587338161136144730.stgit@dwillia2-desk3.amr.corp.intel.com
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
101 lines
2.3 KiB
C
101 lines
2.3 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
#include <linux/platform_device.h>
|
|
#include <linux/memregion.h>
|
|
#include <linux/module.h>
|
|
#include <linux/dax.h>
|
|
#include <linux/mm.h>
|
|
|
|
static bool nohmem;
|
|
module_param_named(disable, nohmem, bool, 0444);
|
|
|
|
void hmem_register_device(int target_nid, struct resource *r)
|
|
{
|
|
/* define a clean / non-busy resource for the platform device */
|
|
struct resource res = {
|
|
.start = r->start,
|
|
.end = r->end,
|
|
.flags = IORESOURCE_MEM,
|
|
};
|
|
struct platform_device *pdev;
|
|
struct memregion_info info;
|
|
int rc, id;
|
|
|
|
if (nohmem)
|
|
return;
|
|
|
|
rc = region_intersects(res.start, resource_size(&res), IORESOURCE_MEM,
|
|
IORES_DESC_SOFT_RESERVED);
|
|
if (rc != REGION_INTERSECTS)
|
|
return;
|
|
|
|
id = memregion_alloc(GFP_KERNEL);
|
|
if (id < 0) {
|
|
pr_err("memregion allocation failure for %pr\n", &res);
|
|
return;
|
|
}
|
|
|
|
pdev = platform_device_alloc("hmem", id);
|
|
if (!pdev) {
|
|
pr_err("hmem device allocation failure for %pr\n", &res);
|
|
goto out_pdev;
|
|
}
|
|
|
|
pdev->dev.numa_node = numa_map_to_online_node(target_nid);
|
|
info = (struct memregion_info) {
|
|
.target_node = target_nid,
|
|
};
|
|
rc = platform_device_add_data(pdev, &info, sizeof(info));
|
|
if (rc < 0) {
|
|
pr_err("hmem memregion_info allocation failure for %pr\n", &res);
|
|
goto out_pdev;
|
|
}
|
|
|
|
rc = platform_device_add_resources(pdev, &res, 1);
|
|
if (rc < 0) {
|
|
pr_err("hmem resource allocation failure for %pr\n", &res);
|
|
goto out_resource;
|
|
}
|
|
|
|
rc = platform_device_add(pdev);
|
|
if (rc < 0) {
|
|
dev_err(&pdev->dev, "device add failed for %pr\n", &res);
|
|
goto out_resource;
|
|
}
|
|
|
|
return;
|
|
|
|
out_resource:
|
|
put_device(&pdev->dev);
|
|
out_pdev:
|
|
memregion_free(id);
|
|
}
|
|
|
|
static __init int hmem_register_one(struct resource *res, void *data)
|
|
{
|
|
/*
|
|
* If the resource is not a top-level resource it was already
|
|
* assigned to a device by the HMAT parsing.
|
|
*/
|
|
if (res->parent != &iomem_resource) {
|
|
pr_info("HMEM: skip %pr, already claimed\n", res);
|
|
return 0;
|
|
}
|
|
|
|
hmem_register_device(phys_to_target_node(res->start), res);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static __init int hmem_init(void)
|
|
{
|
|
walk_iomem_res_desc(IORES_DESC_SOFT_RESERVED,
|
|
IORESOURCE_MEM, 0, -1, NULL, hmem_register_one);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* As this is a fallback for address ranges unclaimed by the ACPI HMAT
|
|
* parsing it must be at an initcall level greater than hmat_init().
|
|
*/
|
|
late_initcall(hmem_init);
|