device-dax: Support sub-dividing soft-reserved ranges
Subsystems (24)
v2 cover device-dax: Support sub-dividing soft-reserved ranges
Changes since v1 [1]:
- Combine this series with "Manual definition of Soft Reserved memory devices" [2] as the pre-requisites are required to test the device-dax facility, the device-dax changes are part of the justification for the numa-info reworks.
- Provide a generic version of numa data retrieval based on memblock for arm64 rather than adding a new / empty phys_to_target_node() stub alongside memory_add_physaddr_to_nid(). (Will)
- Fix several corner case allocation bugs and pass the unit test written by Joao.
- Lift the restriction that a 'seed' device must be activated before a new seed can be created. This minor sanity check was to prevent userspace spamming devices, but it gets in the way of some of allocation scenarios like allocating a memory-range that is guaranteed to never be evicted due to memory-side-cache conflicts. (Iqbal)
- Add debug prints for space allocation decisions (Joao)
- Rebased on v5.8-rc2 which included resolving conflicts in the kmem driver and memremap_pages().
[1]: http://lore.kernel.org/r/158500767138.2088294.17131646259803932461.stgit@dwillia2-desk3.amr.corp.intel.com
[2]: http://lore.kernel.org/r/158489354353.1457606.8327903161927980740.stgit@dwillia2-desk3.amr.corp.intel.com/
---
The device-dax facility allows an address range to be directly mapped through a chardev, or optionally hotplugged to the core kernel page allocator as System-RAM. It is the mechanism for converting persistent memory (pmem) to be used as another volatile memory pool i.e. the current Memory Tiering hot topic on linux-mm.
In the case of pmem the nvdimm-namespace-label mechanism can sub-divide it, but that labeling mechanism is not available / applicable to soft-reserved ("EFI specific purpose") memory [3]. This series provides a sysfs-mechanism for the daxctl utility to enable provisioning of volatile-soft-reserved memory ranges.
The motivations for this facility are:
1/ Allow performance differentiated memory ranges to be split between
kernel-managed and directly-accessed use cases.
2/ Allow physical memory to be provisioned along performance relevant
address boundaries. For example, divide a memory-side cache [4] along cache-color boundaries.
3/ Parcel out soft-reserved memory to VMs using device-dax as a security
/ permissions boundary [5]. Specifically I have seen people (ab)using memmap=nn!ss (mark System-RAM as Persistent Memory) just to get the device-dax interface on custom address ranges. A follow-on for the VM use case is to teach device-dax to dynamically allocate 'struct page' at runtime to reduce the duplication of 'struct page' space in both the guest and the host kernel for the same physical pages.
Given the intersections of arm64, x86, and core memremap_pages() changes I'd like to explore taking this through the libnvdimm tree, but that is step 2. Any concerns with the proposed infrastructure changes (memblock-numainfo and multi-range-memremap-pages)?
[3]: http://lore.kernel.org/r/157309097008.1579826.12818463304589384434.stgit@dwillia2-desk3.amr.corp.intel.com
[4]: http://lore.kernel.org/r/154899811738.3165233.12325692939590944259.stgit@dwillia2-desk3.amr.corp.intel.com
[5]: http://lore.kernel.org/r/[email protected]
---
Dan Williams (22):
x86/numa: Cleanup configuration dependent command-line options x86/numa: Add 'nohmat' option
efi/fake_mem: Arrange for a resource entry per efi_fake_mem instance
ACPI: HMAT: Refactor hmat_register_target_device to hmem_register_device
resource: Report parent to walk_iomem_res_desc() callback
x86: Move NUMA_KEEP_MEMINFO and related definition to x86-internals
numa: Introduce a generic memory_add_physaddr_to_nid()
memblock: Introduce a generic phys_addr_to_target_node()
arm64: Convert to generic memblock for numa-info
ACPI: HMAT: Attach a device for each soft-reserved range
device-dax: Drop the dax_region.pfn_flags attribute
device-dax: Move instance creation parameters to 'struct dev_dax_data'
device-dax: Make pgmap optional for instance creation
device-dax: Kill dax_kmem_res
device-dax: Add an allocation interface for device-dax instances
device-dax: Introduce 'seed' devices
drivers/base: Make device_find_child_by_name() compatible with sysfs inputs
device-dax: Add resize support
mm/memremap_pages: Convert to 'struct range' mm/memremap_pages: Support multiple ranges per invocation
device-dax: Add dis-contiguous resource support
device-dax: Introduce 'mapping' devices
arch/arm64/Kconfig | 1
arch/arm64/mm/numa.c | 10
arch/powerpc/kvm/book3s_hv_uvmem.c | 14
arch/x86/Kconfig | 7
arch/x86/include/asm/numa.h | 8
arch/x86/kernel/e820.c | 16 +
arch/x86/mm/numa.c | 12
arch/x86/mm/numa_emulation.c | 3
arch/x86/mm/numa_internal.h | 7
arch/x86/xen/enlighten_pv.c | 2
drivers/acpi/numa/hmat.c | 76 ---
drivers/acpi/numa/srat.c | 9
drivers/base/core.c | 2
drivers/dax/Kconfig | 6
drivers/dax/Makefile | 3
drivers/dax/bus.c | 902 ++++++++++++++++++++++++++++++--
drivers/dax/bus.h | 28 +
drivers/dax/dax-private.h | 39 +
drivers/dax/device.c | 97 ++-
drivers/dax/hmem/Makefile | 6
drivers/dax/hmem/device.c | 100 ++++
drivers/dax/hmem/hmem.c | 20 -
drivers/dax/kmem.c | 199 ++++---
drivers/dax/pmem/compat.c | 2
drivers/dax/pmem/core.c | 22 +
drivers/firmware/efi/x86_fake_mem.c | 12
drivers/gpu/drm/nouveau/nouveau_dmem.c | 4
drivers/nvdimm/badrange.c | 26 -
drivers/nvdimm/claim.c | 13
drivers/nvdimm/nd.h | 3
drivers/nvdimm/pfn_devs.c | 13
drivers/nvdimm/pmem.c | 27 +
drivers/nvdimm/region.c | 21 -
drivers/pci/p2pdma.c | 12
include/acpi/acpi_numa.h | 14
include/linux/dax.h | 8
include/linux/memblock.h | 4
include/linux/memremap.h | 11
include/linux/mm.h | 13
include/linux/numa.h | 9
include/linux/range.h | 6
kernel/resource.c | 11
mm/Kconfig | 7
mm/memblock.c | 22 +
mm/memremap.c | 300 ++++++-----
mm/page_alloc.c | 82 +++
tools/testing/nvdimm/dax-dev.c | 22 +
tools/testing/nvdimm/test/iomap.c | 2
48 files changed, 1705 insertions(+), 528 deletions(-)
create mode 100644 drivers/dax/hmem/Makefile
create mode 100644 drivers/dax/hmem/device.c
rename drivers/dax/{hmem.c => hmem/hmem.c} (74%)base-commit: 48778464bb7d346b47157d21ffde2af6b2d39110
PATCH v2 1/22 x86/numa: Cleanup configuration dependent command-line options
In preparation for adding a new numa= option clean up the existing ones to avoid ifdefs in numa_setup(), and provide feedback when the option is numa=fake= option is invalid due to kernel config. The same does not need to be done for numa=noacpi, since the capability is already hard disabled at compile-time.
--- arch/x86/include/asm/numa.h | 8 +++++++- arch/x86/mm/numa.c | 8 ++------ arch/x86/mm/numa_emulation.c | 3 ++- arch/x86/xen/enlighten_pv.c | 2 +- drivers/acpi/numa/srat.c | 9 +++++++-- include/acpi/acpi_numa.h | 6 +++++- 6 files changed, 24 insertions(+), 12 deletions(-)
arch/x86/include/asm/numa.h +7 -1
@@ -3,6 +3,7 @@#define _ASM_X86_NUMA_H#include <linux/nodemask.h> +#include <linux/errno.h> #include <asm/topology.h> #include <asm/apicdef.h>
@@ -77,7 +78,12 @@ void debug_cpumask_set_cpu(int cpu, int node, bool enable);#ifdef CONFIG_NUMA_EMU #define FAKE_NODE_MIN_SIZE ((u64)32 << 20)#define FAKE_NODE_MIN_HASH_MASK (~(FAKE_NODE_MIN_SIZE - 1UL)) -void numa_emu_cmdline (char *); +int numa_emu_cmdline (char *str); +#else /* CONFIG_NUMA_EMU */ +static inline int numa_emu_cmdline (char *str) +{ +return -EINVAL ; +}#endif /* CONFIG_NUMA_EMU */ #endif /* _ASM_X86_NUMA_H */
arch/x86/mm/numa.c +2 -6
@@ -37,14 +37,10 @@ static __init int numa_setup(char *opt)return -EINVAL ;if (!strncmp (opt,"off" ,3 )) numa_off =1 ; -#ifdef CONFIG_NUMA_EMU if (!strncmp (opt,"fake=" ,5 )) -numa_emu_cmdline (opt +5 ); -#endif -#ifdef CONFIG_ACPI_NUMA +return numa_emu_cmdline (opt +5 );if (!strncmp (opt,"noacpi" ,6 )) - acpi_numa =-1 ; -#endif +disable_srat ();return 0 ; }early_param ("numa" , numa_setup);
arch/x86/mm/numa_emulation.c +2 -1
@@ -13,9 +13,10 @@static int emu_nid_to_phys[MAX_NUMNODES ];static char *emu_cmdline__initdata ; -void __init numa_emu_cmdline (char *str) +int __init numa_emu_cmdline (char *str) { emu_cmdline = str; +return 0 ; }static int __init emu_find_memblk_by_nid (int nid,const struct numa_meminfo *mi)
arch/x86/xen/enlighten_pv.c +1 -1
@@ -1318,7 +1318,7 @@ asmlinkage __visible void __init xen_start_kernel(void)* any NUMA information the kernel tries to get from ACPI will * be meaningless. Prevent it from trying. */ - acpi_numa =-1 ; +disable_srat ();#endif WARN_ON (xen_cpuhp_setup (xen_cpu_up_prepare_pv, xen_cpu_dead_pv));
drivers/acpi/numa/srat.c +7 -2
@@ -27,7 +27,12 @@ static int node_to_pxm_map[MAX_NUMNODES] = { [0 ...MAX_NUMNODES -1 ] =PXM_INVAL };unsigned char acpi_srat_revision__initdata ; -int acpi_numa__initdata ; +static int acpi_numa__initdata ; + +void __init disable_srat (void ) +{ + acpi_numa =-1 ; +}int pxm_to_node (int pxm) {
@@ -163,7 +168,7 @@ static int __init slit_valid(struct acpi_table_slit *slit)void __init bad_srat (void ) {pr_err ("SRAT: SRAT not used.\n" ); - acpi_numa =-1 ; +disable_srat (); }int __init srat_disabled (void )
include/acpi/acpi_numa.h +5 -1
@@ -17,10 +17,14 @@ extern int pxm_to_node(int);extern int node_to_pxm (int );extern int acpi_map_pxm_to_node (int );extern unsigned char acpi_srat_revision; -extern int acpi_numa__initdata ; +extern void disable_srat (void );extern void bad_srat (void );extern int srat_disabled (void ); +#else /* CONFIG_ACPI_NUMA */ +static inline void disable_srat (void ) +{ +}#endif /* CONFIG_ACPI_NUMA */ #endif /* __ACP_NUMA_H */
PATCH v2 2/22 x86/numa: Add 'nohmat' option
In reply to Dan WilliamsDisable parsing of the HMAT for debug, to workaround broken platform instances, or cases where it is otherwise not wanted.
--- arch/x86/mm/numa.c | 2 ++ drivers/acpi/numa/hmat.c | 8 +++++++- include/acpi/acpi_numa.h | 8 ++++++++ 3 files changed, 17 insertions(+), 1 deletion(-)
arch/x86/mm/numa.c +2 -0
@@ -41,6 +41,8 @@ static __init int numa_setup(char *opt)return numa_emu_cmdline (opt +5 );if (!strncmp (opt,"noacpi" ,6 ))disable_srat (); +if (!strncmp (opt,"nohmat" ,6 )) +disable_hmat ();return 0 ; }early_param ("numa" , numa_setup);
drivers/acpi/numa/hmat.c +7 -1
@@ -26,6 +26,12 @@#include <linux/sysfs.h> static u8 hmat_revision; +static int hmat_disable__initdata ; + +void __init disable_hmat (void ) +{ + hmat_disable =1 ; +}static LIST_HEAD (targets);static LIST_HEAD (initiators);
@@ -814,7 +820,7 @@ static __init int hmat_init(void)enum acpi_hmat_type i;acpi_status status; -if (srat_disabled ()) +if (srat_disabled () || hmat_disable)return 0 ; status =acpi_get_table (ACPI_SIG_SRAT ,0 , &tbl);
include/acpi/acpi_numa.h +8 -0
@@ -27,4 +27,12 @@ static inline void disable_srat(void) { }#endif /* CONFIG_ACPI_NUMA */ + +#ifdef CONFIG_ACPI_HMAT +extern void disable_hmat (void ); +#else /* CONFIG_ACPI_HMAT */ +static inline void disable_hmat (void ) +{ +} +#endif /* CONFIG_ACPI_HMAT */ #endif /* __ACP_NUMA_H */
Re: [PATCH v2 02/22] x86/numa: Add 'nohmat' option
Quoted 24 lines · Dan Williams
Disable parsing of the HMAT for debug, to workaround broken platform instances, or cases where it is otherwise not wanted.
Cc "Rafael J. Wysocki" <[email protected]>Cc Dave Hansen <[email protected]>Cc Andy Lutomirski <[email protected]>Cc Peter Zijlstra <[email protected]>Cc Thomas Gleixner <[email protected]>Cc Ingo Molnar <[email protected]>Cc Borislav Petkov <[email protected]>Cc "H. Peter Anvin" <[email protected]>Signed-off-by Dan Williams <[email protected]>--- arch/x86/mm/numa.c | 2 ++ drivers/acpi/numa/hmat.c | 8 +++++++- include/acpi/acpi_numa.h | 8 ++++++++ 3 files changed, 17 insertions(+), 1 deletion(-)arch/x86/mm/numa.c +0
-0
arch/x86/mm/numa.c static __init int numa_setup(char *opt) · line 48
Quoted 8 lines
arch/x86/mm/numa.c +2
-0@@ -41,6 +41,8 @@ static __init int numa_setup(char *opt)return numa_emu_cmdline (opt +5 );if (!strncmp (opt,"noacpi" ,6 ))disable_srat (); +if (!strncmp (opt,"nohmat" ,6 )) +disable_hmat ();return 0 ; }early_param ("numa" , numa_setup);
Please add that toDocumentation/x86/x86_64/boot-options.rst.
thanks.
Signature · 1 line
~Randy
PATCH v2 3/22 efi/fake_mem: Arrange for a resource entry per efi_fake_mem instance
In reply to Dan WilliamsIn preparation for attaching a platform device per iomem resource teach the efi_fake_mem code to create an e820 entry per instance. Similar to E820_TYPE_PRAM, bypass merging resource when the e820 map is sanitized.
--- arch/x86/kernel/e820.c | 16 +++++++++++++++- drivers/firmware/efi/x86_fake_mem.c | 12 +++++++++--- 2 files changed, 24 insertions(+), 4 deletions(-)
arch/x86/kernel/e820.c +15 -1
@@ -305,6 +305,20 @@ static int __init cpcompare(const void *a, const void *b)return (ap->addr != ap->entry->addr) - (bp->addr != bp->entry->addr); } +static bool e820_nomerge (enum e820_type type) +{ +/* +* These types may indicate distinct platform ranges aligned to +* numa node, protection domain, performance domain, or other +* boundaries. Do not merge them. +*/ +if (type ==E820_TYPE_PRAM ) +return true; +if (type ==E820_TYPE_SOFT_RESERVED ) +return true; +return false; +} +int __init e820__update_table (struct e820_table *table) {struct e820_entry *entries = table->entries;
@@ -380,7 +394,7 @@ int __init e820__update_table(struct e820_table *table) }/* Continue building up new map based on this information: */ -if (current_type != last_type || current_type ==E820_TYPE_PRAM ) { +if (current_type != last_type ||e820_nomerge (current_type)) {if (last_type !=0 ) { new_entries[new_nr_entries].size = change_point[chg_idx]->addr - last_addr;/* Move forward only if the new size was non-zero: */
drivers/firmware/efi/x86_fake_mem.c +9 -3
@@ -38,7 +38,7 @@ void __init efi_fake_memmap_early(void) m_start = mem->range.start; m_end = mem->range.end;for_each_efi_memory_desc (md) { -u64 start, end; +u64 start, end, size;if (md->type !=EFI_CONVENTIONAL_MEMORY )continue ;
@@ -58,11 +58,17 @@ void __init efi_fake_memmap_early(void)*/ start =max (start, m_start); end =min (end, m_end); + size = end - start +1 ;if (end <= start)continue ; -e820__range_update (start, end - start +1 ,E820_TYPE_RAM , -E820_TYPE_SOFT_RESERVED ); + +/* +* Ensure each efi_fake_mem instance results in +* a unique e820 resource +*/ +e820__range_remove (start, size,E820_TYPE_RAM ,1 ); +e820__range_add (start, size,E820_TYPE_SOFT_RESERVED );e820__update_table (e820_table); } }
PATCH v2 4/22 ACPI: HMAT: Refactor hmat_register_target_device to hmem_register_device
In reply to Dan WilliamsIn preparation for exposing "Soft Reserved" memory ranges without an HMAT, move the hmem device registration to its own compilation unit and make the implementation generic.
The generic implementation drops usage acpi_map_pxm_to_online_node() that was translating ACPI proximity domain values and instead relies on numa_map_to_online_node() to determine the numa node for the device.
---
drivers/acpi/numa/hmat.c | 68 ++++-----------------------------------------
drivers/dax/Kconfig | 4 +++
drivers/dax/Makefile | 3 +-
drivers/dax/hmem/Makefile | 5 +++
drivers/dax/hmem/device.c | 65 +++++++++++++++++++++++++++++++++++++++++++
drivers/dax/hmem/hmem.c | 2 +
include/linux/dax.h | 8 +++++
7 files changed, 90 insertions(+), 65 deletions(-)
create mode 100644 drivers/dax/hmem/Makefile
create mode 100644 drivers/dax/hmem/device.c
rename drivers/dax/{hmem.c => hmem/hmem.c} (98%)drivers/acpi/numa/hmat.c +6 -62
@@ -24,6 +24,7 @@#include <linux/mutex.h> #include <linux/node.h> #include <linux/sysfs.h> +#include <linux/dax.h> static u8 hmat_revision;static int hmat_disable__initdata ;
@@ -640,66 +641,6 @@ static void hmat_register_target_perf(struct memory_target *target)node_set_perf_attrs (mem_nid, &target->hmem_attrs,0 ); } -static void hmat_register_target_device (struct memory_target *target, -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; - - 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 =acpi_map_pxm_to_online_node (target->memory_pxm); - info = (struct memregion_info ) { - .target_node =acpi_map_pxm_to_node (target->memory_pxm), - }; - 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 void hmat_register_target_devices (struct memory_target *target) {struct resource *res;
@@ -711,8 +652,11 @@ static void hmat_register_target_devices(struct memory_target *target)if (!IS_ENABLED (CONFIG_DEV_DAX_HMEM ))return ; -for (res = target->memregions.child; res; res = res->sibling) -hmat_register_target_device (target, res); +for (res = target->memregions.child; res; res = res->sibling) { +int target_nid =acpi_map_pxm_to_node (target->memory_pxm); + +hmem_register_device (target_nid, res); + } }static void hmat_register_target (struct memory_target *target)
drivers/dax/Kconfig +4 -0
@@ -48,6 +48,10 @@ config DEV_DAX_HMEM Say M if unsure. +config DEV_DAX_HMEM_DEVICES + depends on DEV_DAX_HMEM + def_bool y + config DEV_DAX_KMEM tristate "KMEM DAX: volatile-use of persistent memory" default DEV_DAX
drivers/dax/Makefile +1 -2
@@ -2,11 +2,10 @@ obj-$(CONFIG_DAX) += dax.o obj-$(CONFIG_DEV_DAX) += device_dax.o obj-$(CONFIG_DEV_DAX_KMEM) += kmem.o -obj-$(CONFIG_DEV_DAX_HMEM) += dax_hmem.o dax-y := super.o dax-y += bus.o device_dax-y := device.o -dax_hmem-y := hmem.o obj-y += pmem/ +obj-y += hmem/
drivers/dax/hmem/Makefile new file +5 -0
@@ -0,0 +1,5 @@ +# SPDX-License-Identifier: GPL-2.0 +obj-$(CONFIG_DEV_DAX_HMEM) += dax_hmem.o +obj-$(CONFIG_DEV_DAX_HMEM_DEVICES) += device.o + +dax_hmem-y := hmem.o
drivers/dax/hmem/device.c new file +65 -0
65 lines not on this page · raw message
drivers/dax/hmem/hmem.c renamed from drivers/dax/hmem.c +1 -1
@@ -3,7 +3,7 @@#include <linux/memregion.h> #include <linux/module.h> #include <linux/pfn_t.h> -#include "bus.h" +#include "../bus.h" static int dax_hmem_probe (struct platform_device *pdev) {
include/linux/dax.h +8 -0
@@ -221,4 +221,12 @@ static inline bool dax_mapping(struct address_space *mapping) return mapping->host && IS_DAX(mapping->host); } +#ifdef CONFIG_DEV_DAX_HMEM_DEVICES +void hmem_register_device (int target_nid,struct resource *r); +#else +static inline void hmem_register_device (int target_nid,struct resource *r) +{ +} +#endif +#endif
PATCH v2 5/22 resource: Report parent to walk_iomem_res_desc() callback
In reply to Dan WilliamsIn support of detecting whether a resource might have been been claimed, report the parent to the walk_iomem_res_desc() callback. For example, the ACPI HMAT parser publishes "hmem" platform devices per target range. However, if the HMAT is disabled / missing a fallback driver can attach devices to the raw memory ranges as a fallback if it sees unclaimed / orphan "Soft Reserved" resources in the resource tree.
Otherwise, find_next_iomem_res() returns a resource with garbage data from the stack allocation in __walk_iomem_res_desc() for the res->parent field.
There are currently no users that expect ->child and ->sibling to be valid, and the resource_lock would be needed to traverse them. Use a compound literal to implicitly zero initialize the fields that are not being returned in addition to setting ->parent.
--- kernel/resource.c | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)
kernel/resource.c +7 -4
@@ -382,10 +382,13 @@ static int find_next_iomem_res(resource_size_t start, resource_size_t end,if (p) {/* copy data */ - res->start =max (start, p->start); - res->end =min (end, p->end); - res->flags = p->flags; - res->desc = p->desc; + *res = (struct resource ) { + .start =max (start, p->start), + .end =min (end, p->end), + .flags = p->flags, + .desc = p->desc, + .parent = p->parent, + }; }read_unlock (&resource_lock);
_______________________________________________
Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v2 6/22 x86: Move NUMA_KEEP_MEMINFO and related definition to x86-internals
In reply to Dan Williamsx86 is the lone architecture that uses numa_meminfo. Move and rename NUMA_KEEP_MEMINFO from the core mm/Kconfig to X86_NUMA_KEEP_MEMINFO in arch/x86/mm/Kconfig. This is in preparation for defining a generic memblock based implementation of memory_add_physaddr_to_nid() and phys_to_target_node().
--- arch/x86/Kconfig | 7 ++++++- arch/x86/mm/numa.c | 2 +- arch/x86/mm/numa_internal.h | 7 +++++++ include/linux/numa.h | 7 ------- mm/Kconfig | 5 ----- 5 files changed, 14 insertions(+), 14 deletions(-)
arch/x86/Kconfig +6 -1
@@ -1560,6 +1560,11 @@ config NUMA Otherwise, you should say N. +# Keep NUMA mapping infrastructure post-init. +config X86_NUMA_KEEP_MEMINFO + def_bool MEMORY_HOTPLUG + depends on NUMA + config AMD_NUMA def_bool y prompt "Old style AMD Opteron NUMA detection"
@@ -1640,7 +1645,7 @@ config X86_PMEM_LEGACY depends on PHYS_ADDR_T_64BIT depends on BLK_DEV select X86_PMEM_LEGACY_DEVICE - select NUMA_KEEP_MEMINFO if NUMA + select X86_NUMA_KEEP_MEMINFO if NUMA select LIBNVDIMM help Treat memory marked using the non-standard e820 type of 12 as used
arch/x86/mm/numa.c +1 -1
@@ -893,7 +893,7 @@ EXPORT_SYMBOL(cpumask_of_node);#endif /* !CONFIG_DEBUG_PER_CPU_MAPS */ -#ifdef CONFIG_NUMA_KEEP_MEMINFO +#ifdef CONFIG_X86_NUMA_KEEP_MEMINFO static int meminfo_to_nid (struct numa_meminfo *mi,u64 start) {int i;
arch/x86/mm/numa_internal.h +7 -0
@@ -11,6 +11,13 @@ struct numa_memblk {int nid; }; +/* optionally keep NUMA memory info available post init */ +#ifdef CONFIG_X86_NUMA_KEEP_MEMINFO +#define __initdata_or_meminfo +#else +#define __initdata_or_meminfo __initdata +#endif +struct numa_meminfo {int nr_blks;struct numa_memblk blk[NR_NODE_MEMBLKS ];
include/linux/numa.h +0 -7
@@ -13,13 +13,6 @@#define NUMA_NO_NODE (-1) -/* optionally keep NUMA memory info available post init */ -#ifdef CONFIG_NUMA_KEEP_MEMINFO -#define __initdata_or_meminfo -#else -#define __initdata_or_meminfo __initdata -#endif -#ifdef CONFIG_NUMA /* Generic implementation available */ int numa_map_to_online_node (int node);
mm/Kconfig +0 -5
@@ -139,10 +139,6 @@ config HAVE_FAST_GUP config ARCH_KEEP_MEMBLOCK bool -# Keep arch NUMA mapping infrastructure post-init. -config NUMA_KEEP_MEMINFO - bool - config MEMORY_ISOLATION bool
@@ -159,7 +155,6 @@ config MEMORY_HOTPLUG depends on SPARSEMEM || X86_64_ACPI_NUMA depends on ARCH_ENABLE_MEMORY_HOTPLUG depends on 64BIT || BROKEN - select NUMA_KEEP_MEMINFO if NUMA config MEMORY_HOTPLUG_SPARSE def_bool y
_______________________________________________
Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v2 7/22 numa: Introduce a generic memory_add_physaddr_to_nid()
In reply to Dan WilliamsFor architectures that opt into storing their numa data in memblock (only ARM64 currently), add a memblock generic way to interrogate that data for memory_add_physaddr_to_nid(). This requires ARCH_KEEP_MEMBLOCK to keep memblock text and data around after boot.
--- include/linux/mm.h | 11 +++++++++++ mm/Kconfig | 6 ++++++ mm/page_alloc.c | 23 ++++++++++++++++++++++- 3 files changed, 39 insertions(+), 1 deletion(-)
include/linux/mm.h +11 -0
@@ -2425,6 +2425,17 @@ unsigned long __absent_pages_in_range(int nid, unsigned long start_pfn, unsigned long end_pfn);extern unsigned long absent_pages_in_range (unsigned long start_pfn,unsigned long end_pfn); + +/* +* Allow archs to opt-in to keeping get_pfn_range_for_nid() available +* after boot. +*/ +#ifdef CONFIG_ARCH_KEEP_MEMBLOCK +#define __init_or_memblock +#else +#define __init_or_memblock __init +#endif +extern void get_pfn_range_for_nid (unsigned int nid,unsigned long *start_pfn,unsigned long *end_pfn);extern unsigned long find_min_pfn_with_active_regions (void );
mm/Kconfig +6 -0
@@ -139,6 +139,12 @@ config HAVE_FAST_GUP config ARCH_KEEP_MEMBLOCK bool +# If the arch populates numa data into memblock, it can use memblock +# apis to interrogate that data at runtime. +config MEMBLOCK_NUMA_INFO + bool + depends on ARCH_KEEP_MEMBLOCK + config MEMORY_ISOLATION bool
mm/page_alloc.c +22 -1
@@ -6351,7 +6351,7 @@ void __init sparse_memory_present_with_active_regions(int nid)* with no available memory, a warning is printed and the start and end * PFNs will be 0. */ -void __init get_pfn_range_for_nid (unsigned int nid, +void __init_or_memblock get_pfn_range_for_nid(unsigned int nid,unsigned long *start_pfn,unsigned long *end_pfn) {unsigned long this_start_pfn, this_end_pfn;
@@ -6369,6 +6369,27 @@ void __init get_pfn_range_for_nid(unsigned int nid, *start_pfn =0 ; } +/* +* Generic implementation of memory_add_physaddr_to_nid() depends on +* architecture using memblock data for numa information. +*/ +#ifdef CONFIG_MEMBLOCK_NUMA_INFO +int __init_or_memblock memory_add_physaddr_to_nid(u64 addr) +{ +unsigned long start_pfn, end_pfn, pfn =PHYS_PFN (addr); +int nid; + +for_each_online_node (nid) { +get_pfn_range_for_nid (nid, &start_pfn, &end_pfn); +if (pfn >= start_pfn && pfn <= end_pfn) +return nid; + } +/* Default to node0 as not all callers are prepared for this to fail */ +return 0 ; +} +EXPORT_SYMBOL_GPL (memory_add_physaddr_to_nid); +#endif /* CONFIG_MEMBLOCK_NUMA_INFO */ +/* * This finds a zone that can be used for ZONE_MOVABLE pages. The * assumption is made that zones within a node are ordered in monotonic
Re: [PATCH v2 07/22] numa: Introduce a generic memory_add_physaddr_to_nid()
Hi Dan,
Quoted 4 lines · Dan Williams
For architectures that opt into storing their numa data in memblock (only ARM64 currently), add a memblock generic way to interrogate that data for
memory_add_physaddr_to_nid(). This requiresARCH_KEEP_MEMBLOCKto keep memblock text and data around after boot.
I afraid we are too far from using memblock as a generic placeholder for numa data. Although all architectures now have the numa info in memblock, only arm64 uses memblock as the primary source of that data.
I'd rather prefer Jia's solution [1] to have a weak default for memory_add_physaddr_to_nid() and let architectures override it.
[1] https://lore.kernel.org/lkml/[email protected]
Quoted 12 lines
Cc Mike Rapoport <[email protected]>Cc Jia He <[email protected]>Cc Will Deacon <[email protected]>Cc David Hildenbrand <[email protected]>Cc Andrew Morton <[email protected]>Signed-off-by Dan Williams <[email protected]>--- include/linux/mm.h | 11 +++++++++++ mm/Kconfig | 6 ++++++ mm/page_alloc.c | 23 ++++++++++++++++++++++- 3 files changed, 39 insertions(+), 1 deletion(-)
Signature · 2 lines
Sincerely yours, Mike.
Re: [PATCH v2 07/22] numa: Introduce a generic memory_add_physaddr_to_nid()
Quoted 9 lines · Mike Rapoport
Hi Dan,
Quoted 4 lines · Dan Williams
For architectures that opt into storing their numa data in memblock (only ARM64 currently), add a memblock generic way to interrogate that data for
memory_add_physaddr_to_nid(). This requiresARCH_KEEP_MEMBLOCKto keep memblock text and data around after boot.
Quoted 6 lines
I afraid we are too far from using memblock as a generic placeholder for numa data. Although all architectures now have the numa info in memblock, only arm64 uses memblock as the primary source of that data.
I'd rather prefer Jia's solution [1] to have a weak default for
memory_add_physaddr_to_nid()and let architectures override it.
I'm ok with that as long as we do the same for phys_to_target_node().
Will had the concern about adding a generic numa-info facility the last I tried this. I just don't see a practical way to get there in the near term.
PATCH v2 8/22 memblock: Introduce a generic phys_addr_to_target_node()
In reply to Dan WilliamsSimilar to how generic memory_add_physaddr_to_nid() interrogates memblock data for numa information, introduce get_reserved_pfn_range_from_nid() to enable the same operation for reserved memory ranges. Example memory ranges that are reserved, but still have associated numa-info are persistent memory or Soft Reserved (EFI_MEMORY_SP) memory.
--- include/linux/memblock.h | 4 +++ include/linux/mm.h | 2 + include/linux/numa.h | 2 + mm/memblock.c | 22 ++++++++++++++-- mm/page_alloc.c | 63 +++++++++++++++++++++++++++++++++++++++++++++- 5 files changed, 87 insertions(+), 6 deletions(-)
include/linux/memblock.h +4 -0
@@ -234,6 +234,10 @@ void __next_mem_pfn_range(int *idx, int nid, unsigned long *out_start_pfn,for (i =-1 ,__next_mem_pfn_range (&i, nid, p_start, p_end, p_nid); \ i >= 0; __next_mem_pfn_range(&i, nid, p_start, p_end, p_nid)) +#define for_each_reserved_pfn_range (i, nid, p_start, p_end, p_nid) \ + for (i = -1, __next_reserved_pfn_range(&i, nid, p_start, p_end, p_nid); \ + i >= 0; __next_reserved_pfn_range(&i, nid, p_start, p_end, p_nid)) +#ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT void __next_mem_pfn_range_in_zone(u64 *idx, struct zone *zone, unsigned long *out_spfn,
include/linux/mm.h +2 -0
@@ -2438,6 +2438,8 @@ extern unsigned long absent_pages_in_range(unsigned long start_pfn,extern void get_pfn_range_for_nid (unsigned int nid,unsigned long *start_pfn,unsigned long *end_pfn); +extern void get_reserved_pfn_range_for_nid (unsigned int nid, +unsigned long *start_pfn,unsigned long *end_pfn);extern unsigned long find_min_pfn_with_active_regions (void );extern void sparse_memory_present_with_active_regions (int nid);
include/linux/numa.h +1 -1
@@ -19,7 +19,7 @@ int numa_map_to_online_node(int node);/* * Optional architecture specific implementation, users need a "depends -* on $ARCH" +* on $ARCH" or depends on CONFIG_MEMBLOCK_NUMA_INFO */ int phys_to_target_node (phys_addr_t addr);#else
mm/memblock.c +19 -3
@@ -1200,11 +1200,11 @@ void __init_memblock __next_mem_range_rev(u64 *idx, int nid,/* * Common iterator interface used to define for_each_mem_pfn_range(). */ -void __init_memblock __next_mem_pfn_range(int *idx, int nid, +static void __init_memblock __next_memblock_pfn_range(int *idx, int nid,unsigned long *out_start_pfn, -unsigned long *out_end_pfn,int *out_nid) +unsigned long *out_end_pfn,int *out_nid, +struct memblock_type *type) { -struct memblock_type *type = &memblock.memory;struct memblock_region *r;int r_nid;
@@ -1230,6 +1230,22 @@ void __init_memblock __next_mem_pfn_range(int *idx, int nid, *out_nid = r_nid; } +void __init_memblock __next_mem_pfn_range(int *idx, int nid, +unsigned long *out_start_pfn, +unsigned long *out_end_pfn,int *out_nid) +{ +__next_memblock_pfn_range (idx, nid, out_start_pfn, out_end_pfn, out_nid, + &memblock.memory); +} + +void __init_memblock __next_reserved_pfn_range(int *idx, int nid, +unsigned long *out_start_pfn, +unsigned long *out_end_pfn,int *out_nid) +{ +__next_memblock_pfn_range (idx, nid, out_start_pfn, out_end_pfn, out_nid, + &memblock.reserved); +} +/** * memblock_set_node - set node ID on memblock regions * @base: base of area to set node ID for
mm/page_alloc.c +61 -2
83 lines not on this page · raw message
Re: [PATCH v2 08/22] memblock: Introduce a generic phys_addr_to_target_node()
Hi Dan,
Quoted 6 lines · Dan Williams
Similar to how generic
memory_add_physaddr_to_nid()interrogates memblock data for numa information, introduceget_reserved_pfn_range_from_nid()to enable the same operation for reserved memory ranges. Example memory ranges that are reserved, but still have associated numa-info are persistent memory or Soft Reserved (EFI_MEMORY_SP) memory.
Here again, I would prefer to add a weak default for phys_to_target_node() because the "generic" implementation is not really generic.
The fallback to reserved ranges is x86 specfic because on x86 most of the reserved areas is not in memblock.memory. AFAIK, no other architecture does this.
And x86 anyway has implementation of phys_to_target_node().
Quoted 187 lines
Cc Mike Rapoport <[email protected]>Cc Jia He <[email protected]>Cc Will Deacon <[email protected]>Cc David Hildenbrand <[email protected]>Cc Andrew Morton <[email protected]>Signed-off-by Dan Williams <[email protected]>--- include/linux/memblock.h | 4 +++ include/linux/mm.h | 2 + include/linux/numa.h | 2 + mm/memblock.c | 22 ++++++++++++++-- mm/page_alloc.c | 63 +++++++++++++++++++++++++++++++++++++++++++++- 5 files changed, 87 insertions(+), 6 deletions(-)include/linux/memblock.h +4
-0@@ -234,6 +234,10 @@ void __next_mem_pfn_range(int *idx, int nid, unsigned long *out_start_pfn,for (i =-1 ,__next_mem_pfn_range (&i, nid, p_start, p_end, p_nid); \ i >= 0; __next_mem_pfn_range(&i, nid, p_start, p_end, p_nid)) +#define for_each_reserved_pfn_range (i, nid, p_start, p_end, p_nid) \ + for (i = -1, __next_reserved_pfn_range(&i, nid, p_start, p_end, p_nid); \ + i >= 0; __next_reserved_pfn_range(&i, nid, p_start, p_end, p_nid)) +#ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT void __next_mem_pfn_range_in_zone(u64 *idx, struct zone *zone, unsigned long *out_spfn,include/linux/mm.h +2
-0@@ -2438,6 +2438,8 @@ extern unsigned long absent_pages_in_range(unsigned long start_pfn,extern void get_pfn_range_for_nid (unsigned int nid,unsigned long *start_pfn,unsigned long *end_pfn); +extern void get_reserved_pfn_range_for_nid (unsigned int nid, +unsigned long *start_pfn,unsigned long *end_pfn);extern unsigned long find_min_pfn_with_active_regions (void );extern void sparse_memory_present_with_active_regions (int nid);include/linux/numa.h +1
-1@@ -19,7 +19,7 @@ int numa_map_to_online_node(int node);/* * Optional architecture specific implementation, users need a "depends -* on $ARCH" +* on $ARCH" or depends on CONFIG_MEMBLOCK_NUMA_INFO */ int phys_to_target_node (phys_addr_t addr);#else mm/memblock.c +19
-3@@ -1200,11 +1200,11 @@ void __init_memblock __next_mem_range_rev(u64 *idx, int nid,/* * Common iterator interface used to define for_each_mem_pfn_range(). */ -void __init_memblock __next_mem_pfn_range(int *idx, int nid, +static void __init_memblock __next_memblock_pfn_range(int *idx, int nid,unsigned long *out_start_pfn, -unsigned long *out_end_pfn,int *out_nid) +unsigned long *out_end_pfn,int *out_nid, +struct memblock_type *type) { -struct memblock_type *type = &memblock.memory;struct memblock_region *r;int r_nid;@@ -1230,6 +1230,22 @@ void __init_memblock __next_mem_pfn_range(int *idx, int nid, *out_nid = r_nid; } +void __init_memblock __next_mem_pfn_range(int *idx, int nid, +unsigned long *out_start_pfn, +unsigned long *out_end_pfn,int *out_nid) +{ +__next_memblock_pfn_range (idx, nid, out_start_pfn, out_end_pfn, out_nid, + &memblock.memory); +} + +void __init_memblock __next_reserved_pfn_range(int *idx, int nid, +unsigned long *out_start_pfn, +unsigned long *out_end_pfn,int *out_nid) +{ +__next_memblock_pfn_range (idx, nid, out_start_pfn, out_end_pfn, out_nid, + &memblock.reserved); +} +/** * memblock_set_node - set node ID on memblock regions * @base: base of area to set node ID for mm/page_alloc.c +61
-2@@ -6369,12 +6369,39 @@ void __init_or_memblock get_pfn_range_for_nid(unsigned int nid, *start_pfn =0 ; } +/** +* get_reserved_pfn_range_for_nid - Return the start and end page frames for a node +* @nid: The nid to return the range for. If MAX_NUMNODES, the min and max PFN are returned. +* @start_pfn: Passed by reference. On return, it will have the node start_pfn. +* @end_pfn: Passed by reference. On return, it will have the node end_pfn. +* +* Mostly identical to get_pfn_range_for_nid() except it operates on +* reserved ranges rather than online memory. +*/ +void __init_or_memblock get_reserved_pfn_range_for_nid(unsigned int nid, +unsigned long *start_pfn,unsigned long *end_pfn) +{ +unsigned long this_start_pfn, this_end_pfn; +int i; + + *start_pfn =-1UL ; + *end_pfn =0 ; + +for_each_mem_pfn_range (i, nid, &this_start_pfn, &this_end_pfn,NULL ) { + *start_pfn =min (*start_pfn, this_start_pfn); + *end_pfn =max (*end_pfn, this_end_pfn); + } + +if (*start_pfn ==-1UL ) + *start_pfn =0 ; +} +/* * Generic implementation of memory_add_physaddr_to_nid() depends on * architecture using memblock data for numa information. */ #ifdef CONFIG_MEMBLOCK_NUMA_INFO -int __init_or_memblock memory_add_physaddr_to_nid(u64 addr) +static int __init_or_memblock __memory_add_physaddr_to_nid(u64 addr) {unsigned long start_pfn, end_pfn, pfn =PHYS_PFN (addr);int nid;@@ -6384,10 +6411,42 @@ int __init_or_memblock memory_add_physaddr_to_nid(u64 addr)if (pfn >= start_pfn && pfn <= end_pfn) return nid; } +return NUMA_NO_NODE ; +} + +int __init_or_memblock memory_add_physaddr_to_nid(u64 addr) +{ +int nid =__memory_add_physaddr_to_nid (addr); +/* Default to node0 as not all callers are prepared for this to fail */ -return 0 ; +if (nid ==NUMA_NO_NODE ) +return 0 ; +return nid; }EXPORT_SYMBOL_GPL (memory_add_physaddr_to_nid); + +int __init_or_memblock phys_to_target_node(u64 addr) +{ +unsigned long start_pfn, end_pfn, pfn =PHYS_PFN (addr); +int nid =__memory_add_physaddr_to_nid (addr); + +if (nid !=NUMA_NO_NODE ) +return nid; + +/* +* Search reserved memory ranges since the memory address does +* not appear to be online +*/ +for_each_possible_node (nid) { +if (node_online (nid)) +continue ; +get_reserved_pfn_range_for_nid (nid, &start_pfn, &end_pfn); +if (pfn >= start_pfn && pfn <= end_pfn) +return nid; + } +return NUMA_NO_NODE ; +} +EXPORT_SYMBOL_GPL (phys_to_target_node);#endif /* CONFIG_MEMBLOCK_NUMA_INFO */ /*
Signature · 2 lines
Sincerely yours, Mike.
Re: [PATCH v2 08/22] memblock: Introduce a generic phys_addr_to_target_node()
Quoted 11 lines · Mike Rapoport
Hi Dan,
Quoted 6 lines · Dan Williams
Similar to how generic
memory_add_physaddr_to_nid()interrogates memblock data for numa information, introduceget_reserved_pfn_range_from_nid()to enable the same operation for reserved memory ranges. Example memory ranges that are reserved, but still have associated numa-info are persistent memory or Soft Reserved (EFI_MEMORY_SP) memory.
Quoted 7 lines
Here again, I would prefer to add a weak default for
phys_to_target_node()because the "generic" implementation is not really generic.The fallback to reserved ranges is x86 specfic because on x86 most of the reserved areas is not in memblock.memory. AFAIK, no other architecture does this.
True, I was pre-fetching ARM using the new EFI "Special Purpose" memory attribute. However, until that becomes something that platforms deploy in practice I'm ok with not solving that problem for now.
Quoted 1 line
And x86 anyway has implementation of
phys_to_target_node().
Sure, let's go with the default stub for non-x86.
Justin, do you think it would make sense to fold your dax_kmem enabling for arm64 series into my enabling of dax_hmem for all memory-hotplug archs?
RE: [PATCH v2 08/22] memblock: Introduce a generic phys_addr_to_target_node()
Hi Dan
Quoted 41 lines
-----Original Message-----
From: Dan Williams <[email protected]>
Sent: Monday, July 13, 2020 11:48 PM
To: Mike Rapoport <[email protected]>
Cc: linux-nvdimm <[email protected]>; Justin He <[email protected]>; Will Deacon <[email protected]>; David Hildenbrand <[email protected]>; Andrew Morton <[email protected]>; Peter Zijlstra <[email protected]>; Vishal L Verma <[email protected]>; Dave Hansen <[email protected]>; Ard Biesheuvel <[email protected]>; Linux MM <[email protected]>; Linux Kernel Mailing List <[email protected]>; Linux ACPI <linux- [email protected]>; Christoph Hellwig <[email protected]>; Joao Martins <[email protected]>
Subject: Re: [PATCH v2 08/22] memblock: Introduce a genericphys_addr_to_target_node()Quoted 11 lines · Mike Rapoport
Hi Dan,
Quoted 6 lines · Dan Williams
Similar to how generic
memory_add_physaddr_to_nid()interrogates memblock data for numa information, introduceget_reserved_pfn_range_from_nid()to enable the same operation for reserved memory ranges. Example memory ranges that are reserved, but still have associated numa-info are persistent memory or Soft Reserved (EFI_MEMORY_SP) memory.Quoted 5 lines
Here again, I would prefer to add a weak default for
phys_to_target_node()because the "generic" implementation is not really generic.The fallback to reserved ranges is x86 specfic because on x86 most of
the
Quoted 2 lines
reserved areas is not in memblock.memory. AFAIK, no other architecture does this.
True, I was pre-fetching ARM using the new EFI "Special Purpose" memory attribute. However, until that becomes something that platforms deploy in practice I'm ok with not solving that problem for now.
Quoted 7 lines
Quoted 1 line
And x86 anyway has implementation of
phys_to_target_node().Sure, let's go with the default stub for non-x86.
Justin, do you think it would make sense to fold your
dax_kmemenabling for arm64 series into my enabling ofdax_hmemfor all memory-hotplug archs?
It is ok with me, thanks for the folding 😊
--
Cheers,
Justin (Jia He)
IMPORTANT NOTICE: The contents of this email and any attachments are confidential and may also be privileged. If you are not the intended recipient, please notify the sender immediately and do not disclose the contents to any other person, use it for any purpose, or store or copy the information in any medium. Thank you.
PATCH v2 9/22 arm64: Convert to generic memblock for numa-info
In reply to Dan WilliamsDrop the existing memory_add_physaddr_to_nid() stub and add support for phys_to_target_node() by selecting the generic CONFIG_MEMBLOCK_NUMAINFO mechanism for querying firmware numa data at runtime.
--- arch/arm64/Kconfig | 1 + arch/arm64/mm/numa.c | 10 ---------- 2 files changed, 1 insertion(+), 10 deletions(-)
arch/arm64/Kconfig +1 -0
@@ -65,6 +65,7 @@ config ARM64 select ARCH_INLINE_SPIN_UNLOCK_IRQ if !PREEMPTION select ARCH_INLINE_SPIN_UNLOCK_IRQRESTORE if !PREEMPTION select ARCH_KEEP_MEMBLOCK + select MEMBLOCK_NUMA_INFO select ARCH_USE_CMPXCHG_LOCKREF select ARCH_USE_GNU_PROPERTY select ARCH_USE_QUEUED_RWLOCKS
arch/arm64/mm/numa.c +0 -10
@@ -461,13 +461,3 @@ void __init arm64_numa_init(void)numa_init (dummy_numa_init); } - -/* -* We hope that we will be hotplugging memory on nodes we already know about, -* such that acpi_get_node() succeeds and we never fall back to this... -*/ -int memory_add_physaddr_to_nid (u64 addr) -{ -pr_warn ("Unknown node for memory at 0x%llx, assuming node 0\n" , addr); -return 0 ; -}
PATCH v2 10/22 ACPI: HMAT: Attach a device for each soft-reserved range
In reply to Dan WilliamsThe hmem enabling in commit 'cf8741ac57ed ("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.
--- drivers/dax/Kconfig | 2 ++ drivers/dax/hmem/Makefile | 3 ++- drivers/dax/hmem/device.c | 35 +++++++++++++++++++++++++++++++++++ 3 files changed, 39 insertions(+), 1 deletion(-)
drivers/dax/Kconfig +2 -0
@@ -50,6 +50,8 @@ config DEV_DAX_HMEM config DEV_DAX_HMEM_DEVICES depends on DEV_DAX_HMEM + # requires phys_to_target_node() support + depends on X86_NUMA_KEEP_MEMINFO || MEMBLOCK_NUMA_INFO def_bool y config DEV_DAX_KMEM
drivers/dax/hmem/Makefile +2 -1
@@ -1,5 +1,6 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_DEV_DAX_HMEM) += dax_hmem.o -obj-$(CONFIG_DEV_DAX_HMEM_DEVICES) += device.o +obj-$(CONFIG_DEV_DAX_HMEM_DEVICES) += device_hmem.o +device_hmem-y := device.o dax_hmem-y := hmem.o
drivers/dax/hmem/device.c +35 -0
@@ -5,6 +5,9 @@#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 */
@@ -17,6 +20,9 @@ void hmem_register_device(int target_nid, struct resource *r)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 )
@@ -63,3 +69,32 @@ void hmem_register_device(int target_nid, struct resource *r) 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);
PATCH v2 11/22 device-dax: Drop the dax_region.pfn_flags attribute
In reply to Dan WilliamsAll callers specify the same flags to alloc_dax_region(), so there is no need to allow for anything other than PFN_DEV|PFN_MAP, or carry a ->pfn_flags around on the region. Device-dax instances are always page backed.
--- drivers/dax/bus.c | 4 +--- drivers/dax/bus.h | 3 +-- drivers/dax/dax-private.h | 2 -- drivers/dax/device.c | 26 +++----------------------- drivers/dax/hmem/hmem.c | 2 +- drivers/dax/pmem/core.c | 3 +-- 6 files changed, 7 insertions(+), 33 deletions(-)
drivers/dax/bus.c +1 -3
@@ -226,8 +226,7 @@ static void dax_region_unregister(void *region) }struct dax_region *alloc_dax_region (struct device *parent,int region_id, -struct resource *res,int target_node,unsigned int align, -unsigned long long pfn_flags) +struct resource *res,int target_node,unsigned int align) {struct dax_region *dax_region;
@@ -251,7 +250,6 @@ struct dax_region *alloc_dax_region(struct device *parent, int region_id,dev_set_drvdata (parent, dax_region);memcpy (&dax_region->res, res,sizeof (*res)); - dax_region->pfn_flags = pfn_flags;kref_init (&dax_region->kref); dax_region->id = region_id; dax_region->align = align;
drivers/dax/bus.h +1 -2
@@ -10,8 +10,7 @@ struct dax_device;struct dax_region ;void dax_region_put (struct dax_region *dax_region);struct dax_region *alloc_dax_region (struct device *parent,int region_id, -struct resource *res,int target_node,unsigned int align, -unsigned long long flags); +struct resource *res,int target_node,unsigned int align);enum dev_dax_subsys {DEV_DAX_BUS ,
drivers/dax/dax-private.h +0 -2
@@ -23,7 +23,6 @@ void dax_bus_exit(void);* @dev: parent device backing this region * @align: allocation and mapping alignment for child dax devices * @res: physical address range of the region -* @pfn_flags: identify whether the pfns are paged back or not */ struct dax_region {int id;
@@ -32,7 +31,6 @@ struct dax_region {struct device *dev;unsigned int align;struct resource res; -unsigned long long pfn_flags; };/**
drivers/dax/device.c +3 -23
@@ -41,14 +41,6 @@ static int check_vma(struct dev_dax *dev_dax, struct vm_area_struct *vma,return -EINVAL ; } -if ((dax_region->pfn_flags & (PFN_DEV |PFN_MAP )) ==PFN_DEV - && (vma->vm_flags &VM_DONTCOPY ) ==0 ) { -dev_info_ratelimited (dev, -"%s: %s: fail, dax range requires MADV_DONTFORK\n" , - current->comm, func); -return -EINVAL ; - } -if (!vma_is_dax (vma)) { dev_info_ratelimited(dev, "%s: %s: fail, vma is not DAX capable\n",
@@ -102,7 +94,7 @@ static vm_fault_t __dev_dax_pte_fault(struct dev_dax *dev_dax,return VM_FAULT_SIGBUS ; } - *pfn =phys_to_pfn_t (phys, dax_region->pfn_flags); + *pfn =phys_to_pfn_t (phys,PFN_DEV |PFN_MAP );return vmf_insert_mixed (vmf->vma, vmf->address, *pfn); }
@@ -127,12 +119,6 @@ static vm_fault_t __dev_dax_pmd_fault(struct dev_dax *dev_dax,return VM_FAULT_SIGBUS ; } -/* dax pmd mappings require pfn_t_devmap() */ -if ((dax_region->pfn_flags & (PFN_DEV |PFN_MAP )) != (PFN_DEV |PFN_MAP )) { -dev_dbg (dev,"region lacks devmap flags\n" ); -return VM_FAULT_SIGBUS ; - } -if (fault_size < dax_region->align)return VM_FAULT_SIGBUS ;else if (fault_size > dax_region->align)
@@ -150,7 +136,7 @@ static vm_fault_t __dev_dax_pmd_fault(struct dev_dax *dev_dax,return VM_FAULT_SIGBUS ; } - *pfn =phys_to_pfn_t (phys, dax_region->pfn_flags); + *pfn =phys_to_pfn_t (phys,PFN_DEV |PFN_MAP );return vmf_insert_pfn_pmd (vmf, *pfn, vmf->flags &FAULT_FLAG_WRITE ); }
@@ -177,12 +163,6 @@ static vm_fault_t __dev_dax_pud_fault(struct dev_dax *dev_dax,return VM_FAULT_SIGBUS ; } -/* dax pud mappings require pfn_t_devmap() */ -if ((dax_region->pfn_flags & (PFN_DEV |PFN_MAP )) != (PFN_DEV |PFN_MAP )) { -dev_dbg (dev,"region lacks devmap flags\n" ); -return VM_FAULT_SIGBUS ; - } -if (fault_size < dax_region->align)return VM_FAULT_SIGBUS ;else if (fault_size > dax_region->align)
@@ -200,7 +180,7 @@ static vm_fault_t __dev_dax_pud_fault(struct dev_dax *dev_dax,return VM_FAULT_SIGBUS ; } - *pfn =phys_to_pfn_t (phys, dax_region->pfn_flags); + *pfn =phys_to_pfn_t (phys,PFN_DEV |PFN_MAP );return vmf_insert_pfn_pud (vmf, *pfn, vmf->flags &FAULT_FLAG_WRITE ); }
drivers/dax/hmem/hmem.c +1 -1
@@ -22,7 +22,7 @@ static int dax_hmem_probe(struct platform_device *pdev)memcpy (&pgmap.res, res,sizeof (*res)); dax_region =alloc_dax_region (dev, pdev->id, res, mri->target_node, -PMD_SIZE ,PFN_DEV |PFN_MAP ); +PMD_SIZE );if (!dax_region)return -ENOMEM ;
drivers/dax/pmem/core.c +1 -2
@@ -53,8 +53,7 @@ struct dev_dax *__dax_pmem_probe(struct device *dev, enum dev_dax_subsys subsys)memcpy (&res, &pgmap.res,sizeof (res)); res.start += offset; dax_region =alloc_dax_region (dev, region_id, &res, - nd_region->target_node,le32_to_cpu (pfn_sb->align), -PFN_DEV |PFN_MAP ); + nd_region->target_node,le32_to_cpu (pfn_sb->align));if (!dax_region)return ERR_PTR (-ENOMEM );
_______________________________________________
Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v2 12/22 device-dax: Move instance creation parameters to 'struct dev_dax_data'
In reply to Dan WilliamsIn preparation for adding more parameters to instance creation, move existing parameters to a new struct.
--- drivers/dax/bus.c | 14 +++++++------- drivers/dax/bus.h | 16 ++++++++-------- drivers/dax/hmem/hmem.c | 8 +++++++- drivers/dax/pmem/core.c | 9 ++++++++- 4 files changed, 30 insertions(+), 17 deletions(-)
drivers/dax/bus.c +7 -7
@@ -395,9 +395,9 @@ static void unregister_dev_dax(void *dev)put_device (dev); } -struct dev_dax *__devm_create_dev_dax (struct dax_region *dax_region,int id, -struct dev_pagemap *pgmap,enum dev_dax_subsys subsys) +struct dev_dax *devm_create_dev_dax (struct dev_dax_data *data) { +struct dax_region *dax_region = data->dax_region;struct device *parent = dax_region->dev;struct dax_device *dax_dev;struct dev_dax *dev_dax;
@@ -405,14 +405,14 @@ struct dev_dax *__devm_create_dev_dax(struct dax_region *dax_region, int id,struct device *dev;int rc = -ENOMEM ; -if (id <0 ) +if (data->id <0 )return ERR_PTR (-EINVAL ); dev_dax =kzalloc (sizeof (*dev_dax),GFP_KERNEL );if (!dev_dax)return ERR_PTR (-ENOMEM ); -memcpy (&dev_dax->pgmap, pgmap,sizeof (*pgmap)); +memcpy (&dev_dax->pgmap, data->pgmap,sizeof (struct dev_pagemap ));/* * No 'host' or dax_operations since there is no access to this
@@ -438,13 +438,13 @@ struct dev_dax *__devm_create_dev_dax(struct dax_region *dax_region, int id, inode =dax_inode (dax_dev); dev->devt = inode->i_rdev; -if (subsys ==DEV_DAX_BUS ) +if (data->subsys ==DEV_DAX_BUS ) dev->bus = &dax_bus_type;else dev->class = dax_class; dev->parent = parent; dev->type = &dev_dax_type; -dev_set_name (dev,"dax%d.%d" , dax_region->id, id); +dev_set_name (dev,"dax%d.%d" , dax_region->id, data->id); rc =device_add (dev);if (rc) {
@@ -464,7 +464,7 @@ struct dev_dax *__devm_create_dev_dax(struct dax_region *dax_region, int id,return ERR_PTR (rc); } -EXPORT_SYMBOL_GPL (__devm_create_dev_dax); +EXPORT_SYMBOL_GPL (devm_create_dev_dax);static int match_always_count;
drivers/dax/bus.h +8 -8
@@ -13,18 +13,18 @@ struct dax_region *alloc_dax_region(struct device *parent, int region_id, struct resource *res, int target_node, unsigned int align);enum dev_dax_subsys { -DEV_DAX_BUS , +DEV_DAX_BUS =0 ,/* zeroed dev_dax_data picks this by default */ DEV_DAX_CLASS , }; -struct dev_dax *__devm_create_dev_dax (struct dax_region *dax_region,int id, -struct dev_pagemap *pgmap,enum dev_dax_subsys subsys); +struct dev_dax_data { +struct dax_region *dax_region; +struct dev_pagemap *pgmap; +enum dev_dax_subsys subsys; +int id; +}; -static inline struct dev_dax *devm_create_dev_dax (struct dax_region *dax_region, -int id,struct dev_pagemap *pgmap) -{ -return __devm_create_dev_dax (dax_region, id, pgmap,DEV_DAX_BUS ); -} +struct dev_dax *devm_create_dev_dax (struct dev_dax_data *data);/* to be deleted when DEV_DAX_CLASS is removed */ struct dev_dax *__dax_pmem_probe (struct device *dev,enum dev_dax_subsys subsys);
drivers/dax/hmem/hmem.c +7 -1
@@ -11,6 +11,7 @@ static int dax_hmem_probe(struct platform_device *pdev)struct dev_pagemap pgmap = { };struct dax_region *dax_region;struct memregion_info *mri; +struct dev_dax_data data;struct dev_dax *dev_dax;struct resource *res;
@@ -26,7 +27,12 @@ static int dax_hmem_probe(struct platform_device *pdev)if (!dax_region)return -ENOMEM ; - dev_dax =devm_create_dev_dax (dax_region,0 , &pgmap); + data = (struct dev_dax_data ) { + .dax_region = dax_region, + .id =0 , + .pgmap = &pgmap, + }; + dev_dax =devm_create_dev_dax (&data);if (IS_ERR (dev_dax))return PTR_ERR (dev_dax);
drivers/dax/pmem/core.c +8 -1
@@ -14,6 +14,7 @@ struct dev_dax *__dax_pmem_probe(struct device *dev, enum dev_dax_subsys subsys)resource_size_t offset;struct nd_pfn_sb *pfn_sb;struct dev_dax *dev_dax; +struct dev_dax_data data;struct nd_namespace_io *nsio;struct dax_region *dax_region;struct dev_pagemap pgmap = { };
@@ -57,7 +58,13 @@ struct dev_dax *__dax_pmem_probe(struct device *dev, enum dev_dax_subsys subsys)if (!dax_region)return ERR_PTR (-ENOMEM ); - dev_dax =__devm_create_dev_dax (dax_region, id, &pgmap, subsys); + data = (struct dev_dax_data ) { + .dax_region = dax_region, + .id = id, + .pgmap = &pgmap, + .subsys = subsys, + }; + dev_dax =devm_create_dev_dax (&data);/* child dev_dax instances now own the lifetime of the dax_region */ dax_region_put (dax_region);
PATCH v2 13/22 device-dax: Make pgmap optional for instance creation
In reply to Dan WilliamsThe passed in dev_pagemap is only required in the pmem case as the libnvdimm core may have reserved a vmem_altmap for dev_memremap_pages() to place the memmap in pmem directly. In the hmem case there is no agent reserving an altmap so it can all be handled by a core internal default.
Pass the resource range via a new @range property of 'struct dev_dax_data'.
--- drivers/dax/bus.c | 29 +++++++++++++++-------------- drivers/dax/bus.h | 2 ++ drivers/dax/dax-private.h | 9 ++++++++- drivers/dax/device.c | 28 +++++++++++++++++++--------- drivers/dax/hmem/hmem.c | 8 ++++---- drivers/dax/kmem.c | 12 ++++++------ drivers/dax/pmem/core.c | 4 ++++ tools/testing/nvdimm/dax-dev.c | 8 ++++---- 8 files changed, 62 insertions(+), 38 deletions(-)
drivers/dax/bus.c +15 -14
@@ -271,7 +271,7 @@ static ssize_t size_show(struct device *dev, struct device_attribute *attr, char *buf) { struct dev_dax *dev_dax = to_dev_dax(dev); -unsigned long long size =resource_size (&dev_dax->region->res); +unsigned long long size =range_len (&dev_dax->range);return sprintf (buf,"%llu\n" , size); }
@@ -293,19 +293,12 @@ static ssize_t target_node_show(struct device *dev, }static DEVICE_ATTR_RO (target_node); -static unsigned long long dev_dax_resource (struct dev_dax *dev_dax) -{ -struct dax_region *dax_region = dev_dax->region; - -return dax_region->res.start; -} -static ssize_t resource_show (struct device *dev,struct device_attribute *attr,char *buf) {struct dev_dax *dev_dax =to_dev_dax (dev); -return sprintf (buf,"%#llx\n" ,dev_dax_resource (dev_dax)); +return sprintf (buf,"%#llx\n" , dev_dax->range.start); } static DEVICE_ATTR(resource, 0400, resource_show, NULL);
@@ -376,6 +369,7 @@ static void dev_dax_release(struct device *dev)dax_region_put (dax_region);put_dax (dax_dev); +kfree (dev_dax->pgmap);kfree (dev_dax); }
@@ -412,7 +406,12 @@ struct dev_dax *devm_create_dev_dax(struct dev_dax_data *data)if (!dev_dax)return ERR_PTR (-ENOMEM ); -memcpy (&dev_dax->pgmap, data->pgmap,sizeof (struct dev_pagemap )); +if (data->pgmap) { + dev_dax->pgmap =kmemdup (data->pgmap, +sizeof (struct dev_pagemap ),GFP_KERNEL ); +if (!dev_dax->pgmap) + goto err_pgmap; + }/* * No 'host' or dax_operations since there is no access to this
@@ -421,18 +420,19 @@ struct dev_dax *devm_create_dev_dax(struct dev_dax_data *data) dax_dev =alloc_dax (dev_dax,NULL ,NULL ,DAXDEV_F_SYNC );if (IS_ERR (dax_dev)) { rc =PTR_ERR (dax_dev); - goto err; + goto err_alloc_dax; }/* a device_dax instance is dead while the driver is not attached */ kill_dax (dax_dev); -/* from here on we're committed to teardown via dax_dev_release() */ +/* from here on we're committed to teardown via dev_dax_release() */ dev = &dev_dax->dev;device_initialize (dev); dev_dax->dax_dev = dax_dev; dev_dax->region = dax_region; + dev_dax->range = data->range; dev_dax->target_node = dax_region->target_node;kref_get (&dax_region->kref);
@@ -458,8 +458,9 @@ struct dev_dax *devm_create_dev_dax(struct dev_dax_data *data)return ERR_PTR (rc);return dev_dax; - - err: +err_alloc_dax: +kfree (dev_dax->pgmap); +err_pgmap:kfree (dev_dax);return ERR_PTR (rc);
drivers/dax/bus.h +2 -0
@@ -3,6 +3,7 @@#ifndef __DAX_BUS_H__#define __DAX_BUS_H__#include <linux/device.h> +#include <linux/range.h> struct dev_dax ;struct resource ;
@@ -21,6 +22,7 @@ struct dev_dax_data {struct dax_region *dax_region;struct dev_pagemap *pgmap;enum dev_dax_subsys subsys; +struct range range;int id; };
drivers/dax/dax-private.h +8 -1
@@ -41,6 +41,7 @@ struct dax_region {* @target_node: effective numa node if dev_dax memory range is onlined * @dev - device core * @pgmap - pgmap for memmap setup / lifetime (driver owned) +* @range: resource range for the instance * @dax_mem_res: physical address range of hotadded DAX memory * @dax_mem_name: name for hotadded DAX memory via add_memory_driver_managed() */
@@ -49,10 +50,16 @@ struct dev_dax {struct dax_device *dax_dev;int target_node;struct device dev; -struct dev_pagemap pgmap; +struct dev_pagemap *pgmap; +struct range range;struct resource *dax_kmem_res; }; +static inline u64 range_len (struct range *range) +{ +return range->end - range->start +1 ; +} +static inline struct dev_dax *to_dev_dax (struct device *dev) { return container_of(dev, struct dev_dax, dev);
drivers/dax/device.c +19 -9
@@ -55,12 +55,12 @@ static int check_vma(struct dev_dax *dev_dax, struct vm_area_struct *vma,__weak phys_addr_t dax_pgoff_to_phys (struct dev_dax *dev_dax,pgoff_t pgoff,unsigned long size) { -struct resource *res = &dev_dax->region->res; +struct range *range = &dev_dax->range;phys_addr_t phys; - phys = pgoff *PAGE_SIZE + res->start; -if (phys >= res->start && phys <= res->end) { -if (phys + size -1 <= res->end) + phys = pgoff *PAGE_SIZE + range->start; +if (phys >= range->start && phys <= range->end) { +if (phys + size -1 <= range->end)return phys; }
@@ -396,21 +396,31 @@ int dev_dax_probe(struct device *dev) {struct dev_dax *dev_dax =to_dev_dax (dev);struct dax_device *dax_dev = dev_dax->dax_dev; -struct resource *res = &dev_dax->region->res; +struct range *range = &dev_dax->range; +struct dev_pagemap *pgmap;struct inode *inode;struct cdev *cdev;void *addr;int rc;/* 1:1 map region resource range to device-dax instance range */ -if (!devm_request_mem_region (dev, res->start,resource_size (res), +if (!devm_request_mem_region (dev, range->start,range_len (range),dev_name (dev))) { -dev_warn (dev,"could not reserve region %pR\n" , res); +dev_warn (dev,"could not reserve range: %#llx - %#llx\n" , + range->start, range->end);return -EBUSY ; } - dev_dax->pgmap.type =MEMORY_DEVICE_DEVDAX ; - addr =devm_memremap_pages (dev, &dev_dax->pgmap); + pgmap = dev_dax->pgmap; +if (!pgmap) { + pgmap =devm_kzalloc (dev,sizeof (*pgmap),GFP_KERNEL ); +if (!pgmap) +return -ENOMEM ; + pgmap->res.start = range->start; + pgmap->res.end = range->end; + } + pgmap->type =MEMORY_DEVICE_DEVDAX ; + addr =devm_memremap_pages (dev, pgmap);if (IS_ERR (addr))return PTR_ERR (addr);
drivers/dax/hmem/hmem.c +4 -4
@@ -8,7 +8,6 @@static int dax_hmem_probe (struct platform_device *pdev) {struct device *dev = &pdev->dev; -struct dev_pagemap pgmap = { };struct dax_region *dax_region;struct memregion_info *mri;struct dev_dax_data data;
@@ -20,8 +19,6 @@ static int dax_hmem_probe(struct platform_device *pdev)return -ENOMEM ; mri = dev->platform_data; -memcpy (&pgmap.res, res,sizeof (*res)); - dax_region =alloc_dax_region (dev, pdev->id, res, mri->target_node,PMD_SIZE );if (!dax_region)
@@ -30,7 +27,10 @@ static int dax_hmem_probe(struct platform_device *pdev) data = (struct dev_dax_data ) { .dax_region = dax_region, .id =0 , - .pgmap = &pgmap, + .range = { + .start = res->start, + .end = res->end, + }, }; dev_dax =devm_create_dev_dax (&data);if (IS_ERR (dev_dax))
drivers/dax/kmem.c +6 -6
@@ -22,7 +22,7 @@ static bool any_hotremove_failed;int dev_dax_kmem_probe (struct device *dev) {struct dev_dax *dev_dax =to_dev_dax (dev); -struct resource *res = &dev_dax->region->res; +struct range *range = &dev_dax->range;resource_size_t kmem_start;resource_size_t kmem_size;resource_size_t kmem_end;
@@ -39,17 +39,17 @@ int dev_dax_kmem_probe(struct device *dev)*/ numa_node = dev_dax->target_node;if (numa_node <0 ) { -dev_warn (dev,"rejecting DAX region %pR with invalid node: %d\n" , - res, numa_node); +dev_warn (dev,"rejecting DAX region with invalid node: %d\n" , + numa_node);return -EINVAL ; }/* Hotplug starting at the beginning of the next block: */ - kmem_start =ALIGN (res->start,memory_block_size_bytes ()); + kmem_start =ALIGN (range->start,memory_block_size_bytes ()); - kmem_size =resource_size (res); + kmem_size =range_len (range);/* Adjust the size down to compensate for moving up kmem_start: */ - kmem_size -= kmem_start - res->start; + kmem_size -= kmem_start - range->start;/* Align the size down to cover only complete blocks: */ kmem_size &= ~(memory_block_size_bytes () -1 ); kmem_end = kmem_start + kmem_size;
drivers/dax/pmem/core.c +4 -0
@@ -63,6 +63,10 @@ struct dev_dax *__dax_pmem_probe(struct device *dev, enum dev_dax_subsys subsys) .id = id, .pgmap = &pgmap, .subsys = subsys, + .range = { + .start = res.start, + .end = res.end, + }, }; dev_dax =devm_create_dev_dax (&data);
tools/testing/nvdimm/dax-dev.c +4 -4
@@ -9,12 +9,12 @@phys_addr_t dax_pgoff_to_phys (struct dev_dax *dev_dax,pgoff_t pgoff,unsigned long size) { -struct resource *res = &dev_dax->region->res; +struct range *range = &dev_dax->range;phys_addr_t addr; - addr = pgoff *PAGE_SIZE + res->start; -if (addr >= res->start && addr <= res->end) { -if (addr + size -1 <= res->end) { + addr = pgoff *PAGE_SIZE + range->start; +if (addr >= range->start && addr <= range->end) { +if (addr + size -1 <= range->end) {if (get_nfit_res (addr)) {struct page *page;
PATCH v2 14/22 device-dax: Kill dax_kmem_res
In reply to Dan WilliamsSeveral related issues around this unneeded attribute:
- The dax_kmem_res property allows the kmem driver to stash the adjusted resource range that was used for the hotplug operation, but that can be recalculated from the original base range.
- kmem is using an open coded release_resource() + kfree() when an idiomatic release_mem_region() is sufficient.
- The driver managed resource need only manage the busy flag. Other flags are of no concern to the kmem driver. In fact if kmem inherits some memory range that add_memory_driver_managed() rejects that is a memory-hotplug-core policy that the driver is in no position to override.
- The implementation trusts that failed remove_memory() results in the entire resource range remaining pinned busy. The driver need not make that layering violation assumption and just maintain the busy state in its local resource.
- The "Hot-remove not yet implemented." comment is stale since hotremove support is now included.
--- drivers/dax/dax-private.h | 3 - drivers/dax/kmem.c | 123 +++++++++++++++++++++------------------------ 2 files changed, 58 insertions(+), 68 deletions(-)
drivers/dax/dax-private.h +0 -3
@@ -42,8 +42,6 @@ struct dax_region {* @dev - device core * @pgmap - pgmap for memmap setup / lifetime (driver owned) * @range: resource range for the instance -* @dax_mem_res: physical address range of hotadded DAX memory -* @dax_mem_name: name for hotadded DAX memory via add_memory_driver_managed() */ struct dev_dax {struct dax_region *region;
@@ -52,7 +50,6 @@ struct dev_dax {struct device dev;struct dev_pagemap *pgmap;struct range range; -struct resource *dax_kmem_res; };static inline u64 range_len (struct range *range)
drivers/dax/kmem.c +58 -65
183 lines not on this page · raw message
_______________________________________________
Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v2 15/22 device-dax: Add an allocation interface for device-dax instances
In reply to Dan WilliamsIn preparation for a facility that enables dax regions to be sub-divided, introduce infrastructure to track and allocate region capacity.
The new dax_region/available_size attribute is only enabled for volatile hmem devices, not pmem devices that are defined by nvdimm namespace boundaries. This is per Jeff's feedback the last time dynamic device-dax capacity allocation support was discussed.
--- drivers/dax/bus.c | 120 +++++++++++++++++++++++++++++++++++++++++---- drivers/dax/bus.h | 7 ++- drivers/dax/dax-private.h | 2 - drivers/dax/hmem/hmem.c | 7 +-- drivers/dax/pmem/core.c | 8 +-- 5 files changed, 121 insertions(+), 23 deletions(-)
drivers/dax/bus.c +110 -10
@@ -130,6 +130,11 @@ ATTRIBUTE_GROUPS(dax_drv);static int dax_bus_match (struct device *dev,struct device_driver *drv); +static bool is_static (struct dax_region *dax_region) +{ +return (dax_region->res.flags &IORESOURCE_DAX_STATIC ) !=0 ; +} +static struct bus_type dax_bus_type = { .name ="dax" , .uevent = dax_bus_uevent,
@@ -185,7 +190,48 @@ static ssize_t align_show(struct device *dev, }static DEVICE_ATTR_RO (align); +#define for_each_dax_region_resource (dax_region, res) \ + for (res = (dax_region)->res.child; res; res = res->sibling) + +static unsigned long long dax_region_avail_size (struct dax_region *dax_region) +{ +resource_size_t size =resource_size (&dax_region->res); +struct resource *res; + +device_lock_assert (dax_region->dev); + +for_each_dax_region_resource (dax_region, res) + size -=resource_size (res); +return size; +} + +static ssize_t available_size_show (struct device *dev, +struct device_attribute *attr,char *buf) +{ +struct dax_region *dax_region =dev_get_drvdata (dev); +unsigned long long size; + +device_lock (dev); + size =dax_region_avail_size (dax_region); +device_unlock (dev); + +return sprintf (buf,"%llu\n" , size); +} +static DEVICE_ATTR_RO (available_size); + +static umode_t dax_region_visible (struct kobject *kobj,struct attribute *a, +int n) +{ + struct device *dev = container_of(kobj, struct device, kobj); +struct dax_region *dax_region =dev_get_drvdata (dev); + +if (is_static (dax_region) && a == &dev_attr_available_size.attr) +return 0 ; +return a->mode; +} +static struct attribute *dax_region_attributes[] = { + &dev_attr_available_size.attr, &dev_attr_region_size.attr, &dev_attr_align.attr, &dev_attr_id.attr,
@@ -195,6 +241,7 @@ static struct attribute *dax_region_attributes[] = {static const struct attribute_group dax_region_attribute_group = { .name ="dax_region" , .attrs = dax_region_attributes, + .is_visible = dax_region_visible, };static const struct attribute_group *dax_region_attribute_groups[] = {
@@ -226,7 +273,8 @@ static void dax_region_unregister(void *region) }struct dax_region *alloc_dax_region (struct device *parent,int region_id, -struct resource *res,int target_node,unsigned int align) +struct resource *res,int target_node,unsigned int align, +unsigned long flags) {struct dax_region *dax_region;
@@ -249,12 +297,17 @@ struct dax_region *alloc_dax_region(struct device *parent, int region_id,return NULL ;dev_set_drvdata (parent, dax_region); -memcpy (&dax_region->res, res,sizeof (*res));kref_init (&dax_region->kref); dax_region->id = region_id; dax_region->align = align; dax_region->dev = parent; dax_region->target_node = target_node; + dax_region->res = (struct resource ) { + .start = res->start, + .end = res->end, + .flags =IORESOURCE_MEM | flags, + }; +if (sysfs_create_groups (&parent->kobj, dax_region_attribute_groups)) {kfree (dax_region);return NULL ;
@@ -267,6 +320,32 @@ struct dax_region *alloc_dax_region(struct device *parent, int region_id, }EXPORT_SYMBOL_GPL (alloc_dax_region); +static int alloc_dev_dax_range (struct dev_dax *dev_dax,resource_size_t size) +{ +struct dax_region *dax_region = dev_dax->region; +struct resource *res = &dax_region->res; +struct device *dev = &dev_dax->dev; +struct resource *alloc; + +device_lock_assert (dax_region->dev); + +/* TODO: handle multiple allocations per region */ +if (res->child) +return -ENOMEM ; + + alloc =__request_region (res, res->start, size,dev_name (dev),0 ); + +if (!alloc) +return -ENOMEM ; + + dev_dax->range = (struct range ) { + .start = alloc->start, + .end = alloc->end, + }; + +return 0 ; +} +static ssize_t size_show (struct device *dev,struct device_attribute *attr,char *buf) {
@@ -361,6 +440,15 @@ void kill_dev_dax(struct dev_dax *dev_dax) }EXPORT_SYMBOL_GPL (kill_dev_dax); +static void free_dev_dax_range (struct dev_dax *dev_dax) +{ +struct dax_region *dax_region = dev_dax->region; +struct range *range = &dev_dax->range; + +device_lock_assert (dax_region->dev); +__release_region (&dax_region->res, range->start,range_len (range)); +} +static void dev_dax_release (struct device *dev) {struct dev_dax *dev_dax =to_dev_dax (dev);
@@ -385,6 +473,7 @@ static void unregister_dev_dax(void *dev)dev_dbg (dev,"%s\n" , __func__);kill_dev_dax (dev_dax); +free_dev_dax_range (dev_dax);device_del (dev);put_device (dev); }
@@ -397,7 +486,7 @@ struct dev_dax *devm_create_dev_dax(struct dev_dax_data *data)struct dev_dax *dev_dax;struct inode *inode;struct device *dev; -int rc = -ENOMEM ; +int rc;if (data->id <0 )return ERR_PTR (-EINVAL );
@@ -406,11 +495,25 @@ struct dev_dax *devm_create_dev_dax(struct dev_dax_data *data)if (!dev_dax)return ERR_PTR (-ENOMEM ); + dev_dax->region = dax_region; + dev = &dev_dax->dev; +device_initialize (dev); +dev_set_name (dev,"dax%d.%d" , dax_region->id, data->id); + + rc =alloc_dev_dax_range (dev_dax, data->size); +if (rc) + goto err_range; +if (data->pgmap) { +dev_WARN_ONCE (parent, !is_static (dax_region), +"custom dev_pagemap requires a static dax_region\n" ); + dev_dax->pgmap =kmemdup (data->pgmap,sizeof (struct dev_pagemap ),GFP_KERNEL ); -if (!dev_dax->pgmap) +if (!dev_dax->pgmap) { + rc = -ENOMEM ; goto err_pgmap; + } }/*
@@ -427,12 +530,7 @@ struct dev_dax *devm_create_dev_dax(struct dev_dax_data *data)kill_dax (dax_dev);/* from here on we're committed to teardown via dev_dax_release() */ - dev = &dev_dax->dev; -device_initialize (dev); - dev_dax->dax_dev = dax_dev; - dev_dax->region = dax_region; - dev_dax->range = data->range; dev_dax->target_node = dax_region->target_node;kref_get (&dax_region->kref);
@@ -444,7 +542,6 @@ struct dev_dax *devm_create_dev_dax(struct dev_dax_data *data) dev->class = dax_class; dev->parent = parent; dev->type = &dev_dax_type; -dev_set_name (dev,"dax%d.%d" , dax_region->id, data->id); rc =device_add (dev);if (rc) {
@@ -458,9 +555,12 @@ struct dev_dax *devm_create_dev_dax(struct dev_dax_data *data)return ERR_PTR (rc);return dev_dax; + err_alloc_dax:kfree (dev_dax->pgmap); err_pgmap: +free_dev_dax_range (dev_dax); +err_range:kfree (dev_dax);return ERR_PTR (rc);
drivers/dax/bus.h +5 -2
@@ -10,8 +10,11 @@ struct resource;struct dax_device ;struct dax_region ;void dax_region_put (struct dax_region *dax_region); + +#define IORESOURCE_DAX_STATIC (1UL << 0)struct dax_region *alloc_dax_region (struct device *parent,int region_id, -struct resource *res,int target_node,unsigned int align); +struct resource *res,int target_node,unsigned int align, +unsigned long flags);enum dev_dax_subsys {DEV_DAX_BUS =0 ,/* zeroed dev_dax_data picks this by default */
@@ -22,7 +25,7 @@ struct dev_dax_data {struct dax_region *dax_region;struct dev_pagemap *pgmap;enum dev_dax_subsys subsys; -struct range range; +resource_size_t size;int id; };
drivers/dax/dax-private.h +1 -1
@@ -22,7 +22,7 @@ void dax_bus_exit(void);* @kref: to pin while other agents have a need to do lookups * @dev: parent device backing this region * @align: allocation and mapping alignment for child dax devices -* @res: physical address range of the region +* @res: resource tree to track instance allocations */ struct dax_region {int id;
drivers/dax/hmem/hmem.c +2 -5
@@ -20,17 +20,14 @@ static int dax_hmem_probe(struct platform_device *pdev) mri = dev->platform_data; dax_region =alloc_dax_region (dev, pdev->id, res, mri->target_node, -PMD_SIZE ); +PMD_SIZE ,0 );if (!dax_region)return -ENOMEM ; data = (struct dev_dax_data ) { .dax_region = dax_region, .id =0 , - .range = { - .start = res->start, - .end = res->end, - }, + .size =resource_size (res), }; dev_dax =devm_create_dev_dax (&data);if (IS_ERR (dev_dax))
drivers/dax/pmem/core.c +3 -5
@@ -54,7 +54,8 @@ struct dev_dax *__dax_pmem_probe(struct device *dev, enum dev_dax_subsys subsys)memcpy (&res, &pgmap.res,sizeof (res)); res.start += offset; dax_region =alloc_dax_region (dev, region_id, &res, - nd_region->target_node,le32_to_cpu (pfn_sb->align)); + nd_region->target_node,le32_to_cpu (pfn_sb->align), +IORESOURCE_DAX_STATIC );if (!dax_region)return ERR_PTR (-ENOMEM );
@@ -63,10 +64,7 @@ struct dev_dax *__dax_pmem_probe(struct device *dev, enum dev_dax_subsys subsys) .id = id, .pgmap = &pgmap, .subsys = subsys, - .range = { - .start = res.start, - .end = res.end, - }, + .size = resource_size(&res), }; dev_dax =devm_create_dev_dax (&data);
_______________________________________________
Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v2 16/22 device-dax: Introduce 'seed' devices
In reply to Dan WilliamsAdd a seed device concept for dynamic dax regions to be able to split the region amongst multiple sub-instances. The seed device, similar to libnvdimm seed devices, is a device that starts with zero capacity allocated and unbound to a driver. In contrast to libnvdimm seed devices explicit 'create' and 'delete' interfaces are added to the region to trigger seeds to be created and unused devices to be reclaimed. The explicit create and delete replaces implicit create as a side effect of probe and implicit delete when writing 0 to the size that libnvdimm implements.
Delete can be performed on any 0-sized and idle device. This avoids the gymnastics of needing to move device_unregister() to its own async context. Specifically, it avoids the deadlock of deleting a device via one of its own attributes. It is also less surprising to userspace which never sees an extra device it did not request.
For now just add the device creation, teardown, and ->probe() prevention. A later patch will arrange for the 'dax/size' attribute to be writable to allocate capacity from the region.
--- drivers/dax/bus.c | 317 ++++++++++++++++++++++++++++++++++++++++----- drivers/dax/bus.h | 4 - drivers/dax/dax-private.h | 9 + drivers/dax/device.c | 12 +- drivers/dax/hmem/hmem.c | 2 drivers/dax/kmem.c | 14 +- drivers/dax/pmem/compat.c | 2 7 files changed, 304 insertions(+), 56 deletions(-)
drivers/dax/bus.c +279 -38
@@ -135,10 +135,46 @@ static bool is_static(struct dax_region *dax_region)return (dax_region->res.flags &IORESOURCE_DAX_STATIC ) !=0 ; } +static int dax_bus_probe (struct device *dev) +{ +struct dax_device_driver *dax_drv =to_dax_drv (dev->driver); +struct dev_dax *dev_dax =to_dev_dax (dev); +struct dax_region *dax_region = dev_dax->region; +struct range *range = &dev_dax->range; +int rc; + +if (range_len (range) ==0 || dev_dax->id <0 ) +return -ENXIO ; + + rc = dax_drv->probe (dev_dax); + +if (rc ||is_static (dax_region)) +return rc; + +/* +* Track new seed creation only after successful probe of the +* previous seed. +*/ +if (dax_region->seed == dev) + dax_region->seed =NULL ; + +return 0 ; +} + +static int dax_bus_remove (struct device *dev) +{ +struct dax_device_driver *dax_drv =to_dax_drv (dev->driver); +struct dev_dax *dev_dax =to_dev_dax (dev); + +return dax_drv->remove (dev_dax); +} +static struct bus_type dax_bus_type = { .name ="dax" , .uevent = dax_bus_uevent, .match = dax_bus_match, + .probe = dax_bus_probe, + .remove = dax_bus_remove, .drv_groups = dax_drv_groups, };
@@ -219,14 +255,216 @@ static ssize_t available_size_show(struct device *dev, }static DEVICE_ATTR_RO (available_size); +static ssize_t seed_show (struct device *dev, +struct device_attribute *attr,char *buf) +{ +struct dax_region *dax_region =dev_get_drvdata (dev); +struct device *seed; +ssize_t rc; + +if (is_static (dax_region)) +return -EINVAL ; + +device_lock (dev); + seed = dax_region->seed; + rc =sprintf (buf,"%s\n" , seed ?dev_name (seed) :"" ); +device_unlock (dev); + +return rc; +} +static DEVICE_ATTR_RO (seed); + +static ssize_t create_show (struct device *dev, +struct device_attribute *attr,char *buf) +{ +struct dax_region *dax_region =dev_get_drvdata (dev); +struct device *youngest; +ssize_t rc; + +if (is_static (dax_region)) +return -EINVAL ; + +device_lock (dev); + youngest = dax_region->youngest; + rc =sprintf (buf,"%s\n" , youngest ?dev_name (youngest) :"" ); +device_unlock (dev); + +return rc; +} + +static ssize_t create_store (struct device *dev,struct device_attribute *attr, +const char *buf,size_t len) +{ +struct dax_region *dax_region =dev_get_drvdata (dev); +unsigned long long avail; +ssize_t rc; +int val; + +if (is_static (dax_region)) +return -EINVAL ; + + rc =kstrtoint (buf,0 , &val); +if (rc) +return rc; +if (val !=1 ) +return -EINVAL ; + +device_lock (dev); + avail =dax_region_avail_size (dax_region); +if (avail ==0 ) + rc = -ENOSPC ; +else { +struct dev_dax_data data = { + .dax_region = dax_region, + .size =0 , + .id =-1 , + }; +struct dev_dax *dev_dax =devm_create_dev_dax (&data); + +if (IS_ERR (dev_dax)) + rc =PTR_ERR (dev_dax); +else { +/* +* In support of crafting multiple new devices +* simultaneously multiple seeds can be created, +* but only the first one that has not been +* successfully bound is tracked as the region +* seed. +*/ +if (!dax_region->seed) + dax_region->seed = &dev_dax->dev; + dax_region->youngest = &dev_dax->dev; + rc = len; + } + } +device_unlock (dev); + +return rc; +} +static DEVICE_ATTR_RW (create); + +void kill_dev_dax (struct dev_dax *dev_dax) +{ +struct dax_device *dax_dev = dev_dax->dax_dev; +struct inode *inode =dax_inode (dax_dev); + +kill_dax (dax_dev); +unmap_mapping_range (inode->i_mapping,0 ,0 ,1 ); +} +EXPORT_SYMBOL_GPL (kill_dev_dax); + +static void free_dev_dax_range (struct dev_dax *dev_dax) +{ +struct dax_region *dax_region = dev_dax->region; +struct range *range = &dev_dax->range; + +device_lock_assert (dax_region->dev); +if (range_len (range)) +__release_region (&dax_region->res, range->start, +range_len (range)); +} + +static void unregister_dev_dax (void *dev) +{ +struct dev_dax *dev_dax =to_dev_dax (dev); + +dev_dbg (dev,"%s\n" , __func__); + +kill_dev_dax (dev_dax); +free_dev_dax_range (dev_dax); +device_del (dev); +put_device (dev); +} + +/* a return value >= 0 indicates this invocation invalidated the id */ +static int __free_dev_dax_id (struct dev_dax *dev_dax) +{ +struct dax_region *dax_region = dev_dax->region; +struct device *dev = &dev_dax->dev; +int rc = dev_dax->id; + +device_lock_assert (dev); + +if (is_static (dax_region) || dev_dax->id <0 ) +return -1 ; +ida_free (&dax_region->ida, dev_dax->id); + dev_dax->id =-1 ; +return rc; +} + +static int free_dev_dax_id (struct dev_dax *dev_dax) +{ +struct device *dev = &dev_dax->dev; +int rc; + +device_lock (dev); + rc =__free_dev_dax_id (dev_dax); +device_unlock (dev); +return rc; +} + +static ssize_t delete_store (struct device *dev,struct device_attribute *attr, +const char *buf,size_t len) +{ +struct dax_region *dax_region =dev_get_drvdata (dev); +struct dev_dax *dev_dax; +struct device *victim; +bool do_del = false; +int rc; + +if (is_static (dax_region)) +return -EINVAL ; + + victim =device_find_child_by_name (dax_region->dev, buf); +if (!victim) +return -ENXIO ; + +device_lock (dev); +device_lock (victim); + dev_dax =to_dev_dax (victim); +if (victim->driver ||range_len (&dev_dax->range)) + rc = -EBUSY ; +else { +/* +* Invalidate the device so it does not become active +* again, but always preserve device-id-0 so that +* /sys/bus/dax/ is guaranteed to be populated while any +* dax_region is registered. +*/ +if (dev_dax->id >0 ) { + do_del =__free_dev_dax_id (dev_dax) >=0 ; + rc = len; +if (dax_region->seed == victim) + dax_region->seed =NULL ; +if (dax_region->youngest == victim) + dax_region->youngest =NULL ; + }else + rc = -EBUSY ; + } +device_unlock (victim); + +/* won the race to invalidate the device, clean it up */ +if (do_del) +devm_release_action (dev, unregister_dev_dax, victim); +device_unlock (dev); +put_device (victim); + +return rc; +} +static DEVICE_ATTR_WO (delete); +static umode_t dax_region_visible (struct kobject *kobj,struct attribute *a,int n) { struct device *dev = container_of(kobj, struct device, kobj);struct dax_region *dax_region =dev_get_drvdata (dev); -if (is_static (dax_region) && a == &dev_attr_available_size.attr) -return 0 ; +if (is_static (dax_region)) +if (a == &dev_attr_available_size.attr + || a == &dev_attr_create.attr + || a == &dev_attr_seed.attr + || a == &dev_attr_delete.attr) +return 0 ;return a->mode; }
@@ -234,6 +472,9 @@ static struct attribute *dax_region_attributes[] = { &dev_attr_available_size.attr, &dev_attr_region_size.attr, &dev_attr_align.attr, + &dev_attr_create.attr, + &dev_attr_seed.attr, + &dev_attr_delete.attr, &dev_attr_id.attr, NULL, };
@@ -302,6 +543,7 @@ struct dax_region *alloc_dax_region(struct device *parent, int region_id, dax_region->align = align; dax_region->dev = parent; dax_region->target_node = target_node; +ida_init (&dax_region->ida); dax_region->res = (struct resource ) { .start = res->start, .end = res->end,
@@ -329,6 +571,15 @@ static int alloc_dev_dax_range(struct dev_dax *dev_dax, resource_size_t size)device_lock_assert (dax_region->dev); +/* handle the seed alloc special case */ +if (!size) { + dev_dax->range = (struct range ) { + .start = res->start, + .end = res->start -1 , + }; +return 0 ; + } +/* TODO: handle multiple allocations per region */ if (res->child)return -ENOMEM ;
@@ -430,33 +681,15 @@ static const struct attribute_group *dax_attribute_groups[] = { NULL, }; -void kill_dev_dax (struct dev_dax *dev_dax) -{ -struct dax_device *dax_dev = dev_dax->dax_dev; -struct inode *inode =dax_inode (dax_dev); - -kill_dax (dax_dev); -unmap_mapping_range (inode->i_mapping,0 ,0 ,1 ); -} -EXPORT_SYMBOL_GPL (kill_dev_dax); - -static void free_dev_dax_range (struct dev_dax *dev_dax) -{ -struct dax_region *dax_region = dev_dax->region; -struct range *range = &dev_dax->range; - -device_lock_assert (dax_region->dev); -__release_region (&dax_region->res, range->start,range_len (range)); -} -static void dev_dax_release (struct device *dev) {struct dev_dax *dev_dax =to_dev_dax (dev);struct dax_region *dax_region = dev_dax->region;struct dax_device *dax_dev = dev_dax->dax_dev; -dax_region_put (dax_region);put_dax (dax_dev); +free_dev_dax_id (dev_dax); +dax_region_put (dax_region);kfree (dev_dax->pgmap);kfree (dev_dax); }
@@ -466,18 +699,6 @@ static const struct device_type dev_dax_type = { .groups = dax_attribute_groups, }; -static void unregister_dev_dax (void *dev) -{ -struct dev_dax *dev_dax =to_dev_dax (dev); - -dev_dbg (dev,"%s\n" , __func__); - -kill_dev_dax (dev_dax); -free_dev_dax_range (dev_dax); -device_del (dev); -put_device (dev); -} -struct dev_dax *devm_create_dev_dax (struct dev_dax_data *data) {struct dax_region *dax_region = data->dax_region;
@@ -488,17 +709,35 @@ struct dev_dax *devm_create_dev_dax(struct dev_dax_data *data)struct device *dev;int rc; -if (data->id <0 ) -return ERR_PTR (-EINVAL ); - dev_dax =kzalloc (sizeof (*dev_dax),GFP_KERNEL );if (!dev_dax)return ERR_PTR (-ENOMEM ); +if (is_static (dax_region)) { +if (dev_WARN_ONCE (parent, data->id <0 , +"dynamic id specified to static region\n" )) { + rc = -EINVAL ; + goto err_id; + } + + dev_dax->id = data->id; + }else { +if (dev_WARN_ONCE (parent, data->id >=0 , +"static id specified to dynamic region\n" )) { + rc = -EINVAL ; + goto err_id; + } + + rc =ida_alloc (&dax_region->ida,GFP_KERNEL ); +if (rc <0 ) + goto err_id; + dev_dax->id = rc; + } + dev_dax->region = dax_region; dev = &dev_dax->dev;device_initialize (dev); -dev_set_name (dev,"dax%d.%d" , dax_region->id, data->id); +dev_set_name (dev,"dax%d.%d" , dax_region->id, dev_dax->id); rc =alloc_dev_dax_range (dev_dax, data->size);if (rc)
@@ -561,6 +800,8 @@ struct dev_dax *devm_create_dev_dax(struct dev_dax_data *data) err_pgmap:free_dev_dax_range (dev_dax); err_range: +free_dev_dax_id (dev_dax); +err_id:kfree (dev_dax);return ERR_PTR (rc);
drivers/dax/bus.h +3 -1
@@ -38,6 +38,8 @@ struct dax_device_driver {struct device_driver drv;struct list_head ids;int match_always; +int (*probe)(struct dev_dax *dev); +int (*remove)(struct dev_dax *dev); }; int __dax_driver_register(struct dax_device_driver *dax_drv,
@@ -48,7 +50,7 @@ void dax_driver_unregister(struct dax_device_driver *dax_drv);void kill_dev_dax (struct dev_dax *dev_dax);#if IS_ENABLED (CONFIG_DEV_DAX_PMEM_COMPAT ) -int dev_dax_probe (struct device *dev); +int dev_dax_probe (struct dev_dax *dev_dax);#endif /*
drivers/dax/dax-private.h +9 -0
@@ -7,6 +7,7 @@#include <linux/device.h> #include <linux/cdev.h> +#include <linux/idr.h> /* private routines between core files */ struct dax_device ;
@@ -22,7 +23,10 @@ void dax_bus_exit(void);* @kref: to pin while other agents have a need to do lookups * @dev: parent device backing this region * @align: allocation and mapping alignment for child dax devices +* @ida: instance id allocator * @res: resource tree to track instance allocations +* @seed: allow userspace to find the first unbound seed device +* @youngest: allow userspace to find the most recently created device */ struct dax_region {int id;
@@ -30,7 +34,10 @@ struct dax_region {struct kref kref;struct device *dev;unsigned int align; +struct ida ida;struct resource res; +struct device *seed; +struct device *youngest; };/**
@@ -39,6 +46,7 @@ struct dax_region {* @region - parent region * @dax_dev - core dax functionality * @target_node: effective numa node if dev_dax memory range is onlined +* @id: ida allocated id * @dev - device core * @pgmap - pgmap for memmap setup / lifetime (driver owned) * @range: resource range for the instance
@@ -47,6 +55,7 @@ struct dev_dax {struct dax_region *region;struct dax_device *dax_dev;int target_node; +int id;struct device dev;struct dev_pagemap *pgmap;struct range range;
drivers/dax/device.c +5 -7
@@ -392,11 +392,11 @@ static void dev_dax_kill(void *dev_dax)kill_dev_dax (dev_dax); } -int dev_dax_probe (struct device *dev) +int dev_dax_probe (struct dev_dax *dev_dax) { -struct dev_dax *dev_dax =to_dev_dax (dev);struct dax_device *dax_dev = dev_dax->dax_dev;struct range *range = &dev_dax->range; +struct device *dev = &dev_dax->dev;struct dev_pagemap *pgmap;struct inode *inode;struct cdev *cdev;
@@ -446,17 +446,15 @@ int dev_dax_probe(struct device *dev) }EXPORT_SYMBOL_GPL (dev_dax_probe); -static int dev_dax_remove (struct device *dev) +static int dev_dax_remove (struct dev_dax *dev_dax) {/* all probe actions are unwound by devm */ return 0 ; }static struct dax_device_driver device_dax_driver = { - .drv = { - .probe = dev_dax_probe, - .remove = dev_dax_remove, - }, + .probe = dev_dax_probe, + .remove = dev_dax_remove, .match_always =1 , };
drivers/dax/hmem/hmem.c +1 -1
@@ -26,7 +26,7 @@ static int dax_hmem_probe(struct platform_device *pdev) data = (struct dev_dax_data ) { .dax_region = dax_region, - .id =0 , + .id =-1 , .size =resource_size (res), }; dev_dax =devm_create_dev_dax (&data);
drivers/dax/kmem.c +6 -8
@@ -30,11 +30,11 @@ static struct range dax_kmem_range(struct dev_dax *dev_dax)return range; } -int dev_dax_kmem_probe (struct device *dev) +int dev_dax_kmem_probe (struct dev_dax *dev_dax) { -struct dev_dax *dev_dax =to_dev_dax (dev);struct range range =dax_kmem_range (dev_dax);int numa_node = dev_dax->target_node; +struct device *dev = &dev_dax->dev;struct resource *res;char *res_name;int rc;
@@ -127,17 +127,15 @@ static void dax_kmem_release(struct dev_dax *dev_dax) }#endif /* CONFIG_MEMORY_HOTREMOVE */ -static int dev_dax_kmem_remove (struct device *dev) +static int dev_dax_kmem_remove (struct dev_dax *dev_dax) { -dax_kmem_release (to_dev_dax (dev)); +dax_kmem_release (dev_dax);return 0 ; }static struct dax_device_driver device_dax_kmem_driver = { - .drv = { - .probe = dev_dax_kmem_probe, - .remove = dev_dax_kmem_remove, - }, + .probe = dev_dax_kmem_probe, + .remove = dev_dax_kmem_remove, };static int __init dax_kmem_init (void )
drivers/dax/pmem/compat.c +1 -1
@@ -22,7 +22,7 @@ static int dax_pmem_compat_probe(struct device *dev)return -ENOMEM ;device_lock (&dev_dax->dev); - rc =dev_dax_probe (&dev_dax->dev); + rc =dev_dax_probe (dev_dax);device_unlock (&dev_dax->dev);devres_close_group (&dev_dax->dev, dev_dax);
_______________________________________________
Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v2 17/22 drivers/base: Make device_find_child_by_name() compatible with sysfs inputs
In reply to Dan WilliamsUse sysfs_streq() in device_find_child_by_name() to allow it to use a sysfs input string that might contain a trailing newline.
The other "device by name" interfaces, {bus,driver,class}_find_device_by_name(), already account for sysfs strings.
--- drivers/base/core.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/base/core.c +1 -1
@@ -3078,7 +3078,7 @@ struct device *device_find_child_by_name(struct device *parent,klist_iter_init (&parent->p->klist_children, &i);while ((child =next_device (&i))) -if (!strcmp (dev_name (child), name) &&get_device (child)) +if (sysfs_streq (dev_name (child), name) &&get_device (child))break ;klist_iter_exit (&i);return child;
Greg Kroah-Hartman
maintainerRe: [PATCH v2 17/22] drivers/base: Make device_find_child_by_name() compatible with sysfs inputs
Quoted 19 lines · Dan Williams
Use
sysfs_streq()indevice_find_child_by_name()to allow it to use a sysfs input string that might contain a trailing newline.The other "device by name" interfaces, {bus,driver,class}_find_device_by_name(), already account for sysfs strings.
Cc Greg Kroah-Hartman <[email protected]>Cc "Rafael J. Wysocki" <[email protected]>Signed-off-by Dan Williams <[email protected]>--- drivers/base/core.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)drivers/base/core.c +0
-0
drivers/base/core.c struct device *device_find_child_by_name(struct device *parent, · line 3081
Quoted 5 lines
drivers/base/core.c +1
-1@@ -3078,7 +3078,7 @@ struct device *device_find_child_by_name(struct device *parent,klist_iter_init (&parent->p->klist_children, &i);while ((child =next_device (&i))) -if (!strcmp (dev_name (child), name) &&get_device (child)) +if (sysfs_streq (dev_name (child), name) &&get_device (child))
Who wants to call this function with a name passed from userspace?
Not objecting to it, just curious...
thanks,
greg k-h
Re: [PATCH v2 17/22] drivers/base: Make device_find_child_by_name() compatible with sysfs inputs
Quoted 22 lines · Greg Kroah-Hartman
Quoted 20 lines · Dan Williams
Use
sysfs_streq()indevice_find_child_by_name()to allow it to use a sysfs input string that might contain a trailing newline.The other "device by name" interfaces, {bus,driver,class}_find_device_by_name(), already account for sysfs strings.
Cc Greg Kroah-Hartman <[email protected]>Cc "Rafael J. Wysocki" <[email protected]>Signed-off-by Dan Williams <[email protected]>--- drivers/base/core.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)drivers/base/core.c +0
-0@@ -3078,7 +3078,7 @@ struct device *device_find_child_by_name(struct device *parent,
Quoted 9 lines
drivers/base/core.c struct device *device_find_child_by_name(struct device *parent, · line 3081
Quoted 4 lines
drivers/base/core.c +1
-1klist_iter_init (&parent->p->klist_children, &i);while ((child =next_device (&i))) -if (!strcmp (dev_name (child), name) &&get_device (child)) +if (sysfs_streq (dev_name (child), name) &&get_device (child))Who wants to call this function with a name passed from userspace?
Not objecting to it, just curious...
The series that incorporates this patch adds a partitioning mechanism to "device-dax region" devices with an:
"echo 1 > regionX/create" to create a new partition / sub-instance
of a region, and...
"echo $devname > regionX/delete" to delete. Where $devname is
searched in the child devices of regionX to trigger device_del().
This arrangement avoids one of the design mistakes of libnvdimm which uses a sysfs attribute of the device to delete itself. Parent-device triggered deletion rather than self-deletion avoids those locking entanglements.
Greg Kroah-Hartman
maintainerRe: [PATCH v2 17/22] drivers/base: Make device_find_child_by_name() compatible with sysfs inputs
Quoted 34 lines · Dan Williams
Quoted 22 lines · Greg Kroah-Hartman
Quoted 20 lines · Dan Williams
Use
sysfs_streq()indevice_find_child_by_name()to allow it to use a sysfs input string that might contain a trailing newline.The other "device by name" interfaces, {bus,driver,class}_find_device_by_name(), already account for sysfs strings.
Cc Greg Kroah-Hartman <[email protected]>Cc "Rafael J. Wysocki" <[email protected]>Signed-off-by Dan Williams <[email protected]>--- drivers/base/core.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)drivers/base/core.c +0
-0@@ -3078,7 +3078,7 @@ struct device *device_find_child_by_name(struct device *parent,Quoted 9 lines
drivers/base/core.c struct device *device_find_child_by_name(struct device *parent, · line 3081
Quoted 4 lines
drivers/base/core.c +1
-1klist_iter_init (&parent->p->klist_children, &i);while ((child =next_device (&i))) -if (!strcmp (dev_name (child), name) &&get_device (child)) +if (sysfs_streq (dev_name (child), name) &&get_device (child))Who wants to call this function with a name passed from userspace?
Not objecting to it, just curious...
Quoted 6 lines
The series that incorporates this patch adds a partitioning mechanism to "device-dax region" devices with an:
"echo 1 > regionX/create" to create a new partition / sub-instance
of a region, and...
"echo $devname > regionX/delete" to delete. Where $devname is
searched in the child devices of regionX to triggerdevice_del().
Shouldn't that be done in configfs, not sysfs?
Quoted 4 lines
This arrangement avoids one of the design mistakes of libnvdimm which uses a sysfs attribute of the device to delete itself. Parent-device triggered deletion rather than self-deletion avoids those locking entanglements.
Ugh, yeah, getting rid of that would be great, it's a mess. I think scsi still does that :(
thanks,
greg k-h
_______________________________________________
Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
Re: [PATCH v2 17/22] drivers/base: Make device_find_child_by_name() compatible with sysfs inputs
Quoted 36 lines · Greg Kroah-Hartman
Quoted 34 lines · Dan Williams
Quoted 31 lines · Greg Kroah-Hartman
Quoted 19 lines · Dan Williams
Use
sysfs_streq()indevice_find_child_by_name()to allow it to use a sysfs input string that might contain a trailing newline.The other "device by name" interfaces, {bus,driver,class}_find_device_by_name(), already account for sysfs strings.
Cc Greg Kroah-Hartman <[email protected]>Cc "Rafael J. Wysocki" <[email protected]>Signed-off-by Dan Williams <[email protected]>--- drivers/base/core.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)drivers/base/core.c +0
-0drivers/base/core.c struct device *device_find_child_by_name(struct device *parent, · line 3081
Quoted 5 lines
drivers/base/core.c +1
-1@@ -3078,7 +3078,7 @@ struct device *device_find_child_by_name(struct device *parent,klist_iter_init (&parent->p->klist_children, &i);while ((child =next_device (&i))) -if (!strcmp (dev_name (child), name) &&get_device (child)) +if (sysfs_streq (dev_name (child), name) &&get_device (child))Who wants to call this function with a name passed from userspace?
Not objecting to it, just curious...
Quoted 8 lines
Quoted 6 lines
The series that incorporates this patch adds a partitioning mechanism to "device-dax region" devices with an:
"echo 1 > regionX/create" to create a new partition / sub-instance
of a region, and...
"echo $devname > regionX/delete" to delete. Where $devname is
searched in the child devices of regionX to triggerdevice_del().Shouldn't that be done in configfs, not sysfs?
I see configfs as an awkward fit for this situation. configfs wants to software define kernel objects whereas this facility wants to augment existing kernel enumerated device objects. The region device is created by firmware policy and is optionally partitioned, configfs objects don't exist at all until created. So for this I see sysfs + 'scheme to trigger child device creation' as just enough mechanism that does not warrant full blown configfs.
I believe it was debates like this [1] that have led me to the camp of sysfs being capable of some device creation dynamism and leave configfs for purely software constructed objects.
[1]: https://lore.kernel.org/lkml/[email protected]/
Quoted 7 lines
Quoted 4 lines
This arrangement avoids one of the design mistakes of libnvdimm which uses a sysfs attribute of the device to delete itself. Parent-device triggered deletion rather than self-deletion avoids those locking entanglements.
Ugh, yeah, getting rid of that would be great, it's a mess. I think scsi still does that :(
Yeah, both nvdimm and scsi both end up need to delay device deletion to its own thread, and it has led to bugs in the nvdimm case.
Re: [PATCH v2 17/22] drivers/base: Make device_find_child_by_name() compatible with sysfs inputs
Quoted 55 lines · Dan Williams
Quoted 36 lines · Greg Kroah-Hartman
Quoted 34 lines · Dan Williams
Quoted 31 lines · Greg Kroah-Hartman
Quoted 19 lines · Dan Williams
Use
sysfs_streq()indevice_find_child_by_name()to allow it to use a sysfs input string that might contain a trailing newline.The other "device by name" interfaces, {bus,driver,class}_find_device_by_name(), already account for sysfs strings.
Cc Greg Kroah-Hartman <[email protected]>Cc "Rafael J. Wysocki" <[email protected]>Signed-off-by Dan Williams <[email protected]>--- drivers/base/core.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)drivers/base/core.c +0
-0drivers/base/core.c struct device *device_find_child_by_name(struct device *parent, · line 3081
Quoted 5 lines
drivers/base/core.c +1
-1@@ -3078,7 +3078,7 @@ struct device *device_find_child_by_name(struct device *parent,klist_iter_init (&parent->p->klist_children, &i);while ((child =next_device (&i))) -if (!strcmp (dev_name (child), name) &&get_device (child)) +if (sysfs_streq (dev_name (child), name) &&get_device (child))Who wants to call this function with a name passed from userspace?
Not objecting to it, just curious...
Quoted 8 lines
Quoted 6 lines
The series that incorporates this patch adds a partitioning mechanism to "device-dax region" devices with an:
"echo 1 > regionX/create" to create a new partition / sub-instance
of a region, and...
"echo $devname > regionX/delete" to delete. Where $devname is
searched in the child devices of regionX to triggerdevice_del().Shouldn't that be done in configfs, not sysfs?
I see configfs as an awkward fit for this situation. configfs wants to software define kernel objects whereas this facility wants to augment existing kernel enumerated device objects. The region device is created by firmware policy and is optionally partitioned, configfs objects don't exist at all until created. So for this I see sysfs + 'scheme to trigger child device creation' as just enough mechanism that does not warrant full blown configfs.
Quoted 5 lines
I believe it was debates like this [1] that have led me to the camp of sysfs being capable of some device creation dynamism and leave configfs for purely software constructed objects.
"some" :)
And that was from 2006, ugh, how did you find that...
Ok, that's fine, no objection from me for this patch:
Re: [PATCH v2 17/22] drivers/base: Make device_find_child_by_name() compatible with sysfs inputs
Quoted 57 lines · Greg Kroah-Hartman
Quoted 55 lines · Dan Williams
Quoted 36 lines · Greg Kroah-Hartman
Quoted 34 lines · Dan Williams
Quoted 31 lines · Greg Kroah-Hartman
Quoted 19 lines · Dan Williams
Use
sysfs_streq()indevice_find_child_by_name()to allow it to use a sysfs input string that might contain a trailing newline.The other "device by name" interfaces, {bus,driver,class}_find_device_by_name(), already account for sysfs strings.
Cc Greg Kroah-Hartman <[email protected]>Cc "Rafael J. Wysocki" <[email protected]>Signed-off-by Dan Williams <[email protected]>--- drivers/base/core.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)drivers/base/core.c +0
-0drivers/base/core.c struct device *device_find_child_by_name(struct device *parent, · line 3081
Quoted 5 lines
drivers/base/core.c +1
-1@@ -3078,7 +3078,7 @@ struct device *device_find_child_by_name(struct device *parent,klist_iter_init (&parent->p->klist_children, &i);while ((child =next_device (&i))) -if (!strcmp (dev_name (child), name) &&get_device (child)) +if (sysfs_streq (dev_name (child), name) &&get_device (child))Who wants to call this function with a name passed from userspace?
Not objecting to it, just curious...
Quoted 8 lines
Quoted 6 lines
The series that incorporates this patch adds a partitioning mechanism to "device-dax region" devices with an:
"echo 1 > regionX/create" to create a new partition / sub-instance
of a region, and...
"echo $devname > regionX/delete" to delete. Where $devname is
searched in the child devices of regionX to triggerdevice_del().Shouldn't that be done in configfs, not sysfs?
I see configfs as an awkward fit for this situation. configfs wants to software define kernel objects whereas this facility wants to augment existing kernel enumerated device objects. The region device is created by firmware policy and is optionally partitioned, configfs objects don't exist at all until created. So for this I see sysfs + 'scheme to trigger child device creation' as just enough mechanism that does not warrant full blown configfs.
Quoted 7 lines
Quoted 5 lines
I believe it was debates like this [1] that have led me to the camp of sysfs being capable of some device creation dynamism and leave configfs for purely software constructed objects.
"some" :)
Yes, lowercase and quoted: "some" :).
Quoted 1 line
And that was from 2006, ugh, how did you find that...
Oh, public-inbox is a wonderful thing. "I kinda sort of remember Neil laying out a configfs vs sysfs argument", /me searches for "f:neil configfs" and voila.
Quoted 3 lines
Ok, that's fine, no objection from me for this patch:
Reviewed-by Greg Kroah-Hartman <[email protected]>
Thanks, Greg.
PATCH v2 18/22 device-dax: Add resize support
In reply to Dan WilliamsMake the device-dax 'size' attribute writable to allow capacity to be split between multiple instances in a region. The intended consumers of this capability are users that want to split a scarce memory resource between device-dax and System-RAM access, or users that want to have multiple security domains for a large region.
By default the hmem instance provider allocates an entire region to the first instance. The process of creating a new instance (assuming a region-id of 0) is find the region and trigger the 'create' attribute which yields an empty instance to configure. For example:
cd /sys/bus/dax/devices
echo dax0.0 > dax0.0/driver/unbind
echo $new_size > dax0.0/size
echo 1 > $(readlink -f dax0.0)../dax_region/create
seed=$(cat $(readlink -f dax0.0)../dax_region/seed)
echo $new_size > $seed/size
echo dax0.0 > ../drivers/{device_dax,kmem}/bind
echo dax0.1 > ../drivers/{device_dax,kmem}/bindInstances can be destroyed by:
echo $device > $(readlink -f $device)../dax_region/delete
--- drivers/dax/bus.c | 161 ++++++++++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 152 insertions(+), 9 deletions(-)
drivers/dax/bus.c +152 -9
@@ -6,6 +6,7 @@#include <linux/list.h> #include <linux/slab.h> #include <linux/dax.h> +#include <linux/io.h> #include "dax-private.h" #include "bus.h"
@@ -562,7 +563,8 @@ struct dax_region *alloc_dax_region(struct device *parent, int region_id, }EXPORT_SYMBOL_GPL (alloc_dax_region); -static int alloc_dev_dax_range (struct dev_dax *dev_dax,resource_size_t size) +static int alloc_dev_dax_range (struct dev_dax *dev_dax,u64 start, +resource_size_t size) {struct dax_region *dax_region = dev_dax->region;struct resource *res = &dax_region->res;
@@ -580,12 +582,7 @@ static int alloc_dev_dax_range(struct dev_dax *dev_dax, resource_size_t size)return 0 ; } -/* TODO: handle multiple allocations per region */ -if (res->child) -return -ENOMEM ; - - alloc =__request_region (res, res->start, size,dev_name (dev),0 ); - + alloc =__request_region (res, start, size,dev_name (dev),0 );if (!alloc)return -ENOMEM ;
@@ -597,6 +594,29 @@ static int alloc_dev_dax_range(struct dev_dax *dev_dax, resource_size_t size)return 0 ; } +static int adjust_dev_dax_range (struct dev_dax *dev_dax,struct resource *res,resource_size_t size) +{ +struct dax_region *dax_region = dev_dax->region; +struct range *range = &dev_dax->range; +int rc =0 ; + +device_lock_assert (dax_region->dev); + +if (size) + rc =adjust_resource (res, range->start, size); +else +__release_region (&dax_region->res, range->start,range_len (range)); +if (rc) +return rc; + + dev_dax->range = (struct range ) { + .start = range->start, + .end = range->start + size -1 , + }; + +return 0 ; +} +static ssize_t size_show (struct device *dev,struct device_attribute *attr,char *buf) {
@@ -605,7 +625,127 @@ static ssize_t size_show(struct device *dev,return sprintf (buf,"%llu\n" , size); } -static DEVICE_ATTR_RO (size); + +static bool alloc_is_aligned (struct dax_region *dax_region, +resource_size_t size) +{ +/* +* The minimum mapping granularity for a device instance is a +* single subsection, unless the arch says otherwise. +*/ + return IS_ALIGNED(size, max_t(unsigned long, dax_region->align, +memremap_compat_align ())); +} + +static int dev_dax_shrink (struct dev_dax *dev_dax,resource_size_t size) +{ +struct dax_region *dax_region = dev_dax->region; +struct range *range = &dev_dax->range; +struct resource *res, *adjust =NULL ; +struct device *dev = &dev_dax->dev; + +for_each_dax_region_resource (dax_region, res) +if (strcmp (res->name,dev_name (dev)) ==0 + && res->start == range->start) { + adjust = res; +break ; + } + +if (dev_WARN_ONCE (dev, !adjust,"failed to find matching resource\n" )) +return -ENXIO ; +return __adjust_dev_dax_range (dev_dax, adjust, size); +} + +static ssize_t dev_dax_resize (struct dax_region *dax_region, +struct dev_dax *dev_dax,resource_size_t size) +{ +resource_size_t avail =dax_region_avail_size (dax_region), to_alloc; +resource_size_t dev_size =range_len (&dev_dax->range); +struct resource *region_res = &dax_region->res; +struct device *dev = &dev_dax->dev; +const char *name =dev_name (dev); +struct resource *res, *first; + +if (dev->driver) +return -EBUSY ; +if (size == dev_size) +return 0 ; +if (size > dev_size && size - dev_size > avail) +return -ENOSPC ; +if (size < dev_size) +return dev_dax_shrink (dev_dax, size); + + to_alloc = size - dev_size; +if (dev_WARN_ONCE (dev, !alloc_is_aligned (dax_region, to_alloc), +"resize of %pa misaligned\n" , &to_alloc)) +return -ENXIO ; + +/* +* Expand the device into the unused portion of the region. This +* may involve adjusting the end of an existing resource, or +* allocating a new resource. +*/ + first = region_res->child; +if (!first) +return alloc_dev_dax_range (dev_dax, dax_region->res.start, to_alloc); +for (res = first; to_alloc && res; res = res->sibling) { +struct resource *next = res->sibling; +resource_size_t free; + +/* space at the beginning of the region */ + free =0 ; +if (res == first && res->start > dax_region->res.start) + free = res->start - dax_region->res.start; +if (free >= to_alloc && dev_size ==0 ) +return alloc_dev_dax_range (dev_dax, dax_region->res.start, to_alloc); + + free =0 ; +/* space between allocations */ +if (next && next->start > res->end +1 ) + free = next->start - res->end +1 ; + +/* space at the end of the region */ +if (free < to_alloc && !next && res->end < region_res->end) + free = region_res->end - res->end; + +if (free >= to_alloc &&strcmp (name, res->name) ==0 ) +return adjust_dev_dax_range (dev_dax, res,resource_size (res) + to_alloc); +else if (free >= to_alloc && dev_size ==0 ) +return alloc_dev_dax_range (dev_dax, res->end +1 , to_alloc); + } +return -ENOSPC ; +} + +static ssize_t size_store (struct device *dev,struct device_attribute *attr, +const char *buf,size_t len) +{ +ssize_t rc; +unsigned long long val; +struct dev_dax *dev_dax =to_dev_dax (dev); +struct dax_region *dax_region = dev_dax->region; + + rc =kstrtoull (buf,0 , &val); +if (rc) +return rc; + +if (!alloc_is_aligned (dax_region, val)) { +dev_dbg (dev,"%s: size: %lld misaligned\n" , __func__, val); +return -EINVAL ; + } + +device_lock (dax_region->dev); +if (!dax_region->dev->driver) { +device_unlock (dax_region->dev); +return -ENXIO ; + } +device_lock (dev); + rc =dev_dax_resize (dax_region, dev_dax, val); +device_unlock (dev); +device_unlock (dax_region->dev); + +return rc ==0 ? len : rc; +} +static DEVICE_ATTR_RW (size);static int dev_dax_target_node (struct dev_dax *dev_dax) {
@@ -654,11 +794,14 @@ static umode_t dev_dax_visible(struct kobject *kobj, struct attribute *a, int n) { struct device *dev = container_of(kobj, struct device, kobj);struct dev_dax *dev_dax =to_dev_dax (dev); +struct dax_region *dax_region = dev_dax->region;if (a == &dev_attr_target_node.attr &&dev_dax_target_node (dev_dax) <0 )return 0 ;if (a == &dev_attr_numa_node.attr && !IS_ENABLED (CONFIG_NUMA ))return 0 ; +if (a == &dev_attr_size.attr &&is_static (dax_region)) +return 0444 ;return a->mode; }
@@ -739,7 +882,7 @@ struct dev_dax *devm_create_dev_dax(struct dev_dax_data *data)device_initialize (dev);dev_set_name (dev,"dax%d.%d" , dax_region->id, dev_dax->id); - rc =alloc_dev_dax_range (dev_dax, data->size); + rc =alloc_dev_dax_range (dev_dax, dax_region->res.start, data->size);if (rc) goto err_range;
_______________________________________________
Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v2 19/22 mm/memremap_pages: Convert to 'struct range'
In reply to Dan WilliamsThe 'struct resource' in 'struct dev_pagemap' is only used for holding resource span information. The other fields, 'name', 'flags', 'desc', 'parent', 'sibling', and 'child' are all unused wasted space.
This is in preparation for introducing a multi-range extension of devm_memremap_pages().
The bulk of this change is unwinding all the places internal to libnvdimm that used 'struct resource' unnecessarily.
P2PDMA had a minor usage of the flags field, but only to report failures with "%pR". That is replaced with an open coded print of the range.
--- arch/powerpc/kvm/book3s_hv_uvmem.c | 13 +++-- drivers/dax/bus.c | 10 ++-- drivers/dax/bus.h | 2 - drivers/dax/dax-private.h | 5 -- drivers/dax/device.c | 3 - drivers/dax/hmem/hmem.c | 5 ++ drivers/dax/pmem/core.c | 12 ++--- drivers/gpu/drm/nouveau/nouveau_dmem.c | 3 + drivers/nvdimm/badrange.c | 26 +++++------ drivers/nvdimm/claim.c | 13 +++-- drivers/nvdimm/nd.h | 3 + drivers/nvdimm/pfn_devs.c | 12 ++--- drivers/nvdimm/pmem.c | 26 ++++++----- drivers/nvdimm/region.c | 21 +++++---- drivers/pci/p2pdma.c | 11 ++--- include/linux/memremap.h | 5 +- include/linux/range.h | 6 ++ mm/memremap.c | 77 ++++++++++++++++---------------- tools/testing/nvdimm/test/iomap.c | 2 - 19 files changed, 135 insertions(+), 120 deletions(-)
arch/powerpc/kvm/book3s_hv_uvmem.c +7 -6
@@ -343,9 +343,9 @@ static struct page *kvmppc_uvmem_get_page(unsigned long gpa, struct kvm *kvm)struct kvmppc_uvmem_page_pvt *pvt;unsigned long pfn_last, pfn_first; - pfn_first = kvmppc_uvmem_pgmap.res.start >>PAGE_SHIFT ; + pfn_first = kvmppc_uvmem_pgmap.range.start >>PAGE_SHIFT ; pfn_last = pfn_first + - (resource_size (&kvmppc_uvmem_pgmap.res) >>PAGE_SHIFT ); + (range_len (&kvmppc_uvmem_pgmap.range) >>PAGE_SHIFT );spin_lock (&kvmppc_uvmem_bitmap_lock); bit = find_first_zero_bit(kvmppc_uvmem_bitmap,
@@ -661,7 +661,7 @@ static vm_fault_t kvmppc_uvmem_migrate_to_ram(struct vm_fault *vmf)static void kvmppc_uvmem_page_free (struct page *page) {unsigned long pfn =page_to_pfn (page) - - (kvmppc_uvmem_pgmap.res.start >>PAGE_SHIFT ); + (kvmppc_uvmem_pgmap.range.start >>PAGE_SHIFT );struct kvmppc_uvmem_page_pvt *pvt;spin_lock (&kvmppc_uvmem_bitmap_lock);
@@ -806,7 +806,8 @@ int kvmppc_uvmem_init(void) } kvmppc_uvmem_pgmap.type =MEMORY_DEVICE_PRIVATE ; - kvmppc_uvmem_pgmap.res = *res; + kvmppc_uvmem_pgmap.range.start = res->start; + kvmppc_uvmem_pgmap.range.end = res->end; kvmppc_uvmem_pgmap.ops = &kvmppc_uvmem_ops;/* just one global instance: */ kvmppc_uvmem_pgmap.owner = &kvmppc_uvmem_pgmap;
@@ -841,7 +842,7 @@ void kvmppc_uvmem_free(void)return ;memunmap_pages (&kvmppc_uvmem_pgmap); -release_mem_region (kvmppc_uvmem_pgmap.res.start, -resource_size (&kvmppc_uvmem_pgmap.res)); +release_mem_region (kvmppc_uvmem_pgmap.range.start, +range_len (&kvmppc_uvmem_pgmap.range));kfree (kvmppc_uvmem_bitmap); }
drivers/dax/bus.c +5 -5
@@ -515,7 +515,7 @@ static void dax_region_unregister(void *region) }struct dax_region *alloc_dax_region (struct device *parent,int region_id, -struct resource *res,int target_node,unsigned int align, +struct range *range,int target_node,unsigned int align,unsigned long flags) {struct dax_region *dax_region;
@@ -530,8 +530,8 @@ struct dax_region *alloc_dax_region(struct device *parent, int region_id,return NULL ; } -if (!IS_ALIGNED (res->start, align) - || !IS_ALIGNED (resource_size (res), align)) +if (!IS_ALIGNED (range->start, align) + || !IS_ALIGNED (range_len (range), align))return NULL ; dax_region =kzalloc (sizeof (*dax_region),GFP_KERNEL );
@@ -546,8 +546,8 @@ struct dax_region *alloc_dax_region(struct device *parent, int region_id, dax_region->target_node = target_node;ida_init (&dax_region->ida); dax_region->res = (struct resource ) { - .start = res->start, - .end = res->end, + .start = range->start, + .end = range->end, .flags =IORESOURCE_MEM | flags, };
drivers/dax/bus.h +1 -1
@@ -13,7 +13,7 @@ void dax_region_put(struct dax_region *dax_region);#define IORESOURCE_DAX_STATIC (1UL << 0)struct dax_region *alloc_dax_region (struct device *parent,int region_id, -struct resource *res,int target_node,unsigned int align, +struct range *range,int target_node,unsigned int align,unsigned long flags);enum dev_dax_subsys {
drivers/dax/dax-private.h +0 -5
@@ -61,11 +61,6 @@ struct dev_dax {struct range range; }; -static inline u64 range_len (struct range *range) -{ -return range->end - range->start +1 ; -} -static inline struct dev_dax *to_dev_dax (struct device *dev) { return container_of(dev, struct dev_dax, dev);
drivers/dax/device.c +1 -2
@@ -416,8 +416,7 @@ int dev_dax_probe(struct dev_dax *dev_dax) pgmap =devm_kzalloc (dev,sizeof (*pgmap),GFP_KERNEL );if (!pgmap)return -ENOMEM ; - pgmap->res.start = range->start; - pgmap->res.end = range->end; + pgmap->range = *range; } pgmap->type =MEMORY_DEVICE_DEVDAX ; addr =devm_memremap_pages (dev, pgmap);
drivers/dax/hmem/hmem.c +4 -1
@@ -13,13 +13,16 @@ static int dax_hmem_probe(struct platform_device *pdev)struct dev_dax_data data;struct dev_dax *dev_dax;struct resource *res; +struct range range; res =platform_get_resource (pdev,IORESOURCE_MEM ,0 );if (!res)return -ENOMEM ; mri = dev->platform_data; - dax_region =alloc_dax_region (dev, pdev->id, res, mri->target_node, + range.start = res->start; + range.end = res->end; + dax_region =alloc_dax_region (dev, pdev->id, &range, mri->target_node,PMD_SIZE ,0 );if (!dax_region)return -ENOMEM ;
drivers/dax/pmem/core.c +6 -6
@@ -9,7 +9,7 @@struct dev_dax *__dax_pmem_probe (struct device *dev,enum dev_dax_subsys subsys) { -struct resource res; +struct range range;int rc, id, region_id;resource_size_t offset;struct nd_pfn_sb *pfn_sb;
@@ -50,10 +50,10 @@ struct dev_dax *__dax_pmem_probe(struct device *dev, enum dev_dax_subsys subsys)if (rc !=2 )return ERR_PTR (-EINVAL ); -/* adjust the dax_region resource to the start of data */ -memcpy (&res, &pgmap.res,sizeof (res)); - res.start += offset; - dax_region =alloc_dax_region (dev, region_id, &res, +/* adjust the dax_region range to the start of data */ + range = pgmap.range; + range.start += offset, + dax_region =alloc_dax_region (dev, region_id, &range, nd_region->target_node,le32_to_cpu (pfn_sb->align),IORESOURCE_DAX_STATIC );if (!dax_region)
@@ -64,7 +64,7 @@ struct dev_dax *__dax_pmem_probe(struct device *dev, enum dev_dax_subsys subsys) .id = id, .pgmap = &pgmap, .subsys = subsys, - .size = resource_size(&res), + .size = range_len(&range), }; dev_dax =devm_create_dev_dax (&data);
drivers/gpu/drm/nouveau/nouveau_dmem.c +2 -1
@@ -239,7 +239,8 @@ nouveau_dmem_chunk_alloc(struct nouveau_drm *drm, struct page **ppage) chunk->drm = drm; chunk->pagemap.type =MEMORY_DEVICE_PRIVATE ; - chunk->pagemap.res = *res; + chunk->pagemap.range.start = res->start; + chunk->pagemap.range.end = res->end; chunk->pagemap.ops = &nouveau_dmem_pagemap_ops; chunk->pagemap.owner = drm->dev;
drivers/nvdimm/badrange.c +13 -13
@@ -211,7 +211,7 @@ static void __add_badblock_range(struct badblocks *bb, u64 ns_offset, u64 len) }static void badblocks_populate (struct badrange *badrange, -struct badblocks *bb,const struct resource *res) +struct badblocks *bb,const struct range *range) {struct badrange_entry *bre;
@@ -222,34 +222,34 @@ static void badblocks_populate(struct badrange *badrange,u64 bre_end = bre->start + bre->length -1 ;/* Discard intervals with no intersection */ -if (bre_end < res->start) +if (bre_end < range->start)continue ; -if (bre->start > res->end) +if (bre->start > range->end)continue ;/* Deal with any overlap after start of the namespace */ -if (bre->start >= res->start) { +if (bre->start >= range->start) {u64 start = bre->start;u64 len; -if (bre_end <= res->end) +if (bre_end <= range->end) len = bre->length;else - len = res->start +resource_size (res) + len = range->start +range_len (range) - bre->start; -__add_badblock_range (bb, start - res->start, len); +__add_badblock_range (bb, start - range->start, len);continue ; }/* * Deal with overlap for badrange starting before * the namespace. */ -if (bre->start < res->start) { +if (bre->start < range->start) {u64 len; -if (bre_end < res->end) - len = bre->start + bre->length - res->start; +if (bre_end < range->end) + len = bre->start + bre->length - range->start;else - len =resource_size (res); + len =range_len (range);__add_badblock_range (bb,0 , len); } }
@@ -267,7 +267,7 @@ static void badblocks_populate(struct badrange *badrange,* and add badblocks entries for all matching sub-ranges */ void nvdimm_badblocks_populate (struct nd_region *nd_region, -struct badblocks *bb,const struct resource *res) +struct badblocks *bb,const struct range *range) {struct nvdimm_bus *nvdimm_bus;
@@ -279,7 +279,7 @@ void nvdimm_badblocks_populate(struct nd_region *nd_region, nvdimm_bus =walk_to_nvdimm_bus (&nd_region->dev);nvdimm_bus_lock (&nvdimm_bus->dev); -badblocks_populate (&nvdimm_bus->badrange, bb, res); +badblocks_populate (&nvdimm_bus->badrange, bb, range);nvdimm_bus_unlock (&nvdimm_bus->dev); }EXPORT_SYMBOL_GPL (nvdimm_badblocks_populate);
drivers/nvdimm/claim.c +8 -5
@@ -303,13 +303,16 @@ static int nsio_rw_bytes(struct nd_namespace_common *ndns,int devm_nsio_enable (struct device *dev,struct nd_namespace_io *nsio,resource_size_t size) { -struct resource *res = &nsio->res;struct nd_namespace_common *ndns = &nsio->common; +struct range range = { + .start = nsio->res.start, + .end = nsio->res.end, + }; nsio->size = size; -if (!devm_request_mem_region (dev, res->start, size, +if (!devm_request_mem_region (dev, range.start, size,dev_name (&ndns->dev))) { -dev_warn (dev,"could not reserve region %pR\n" , res); +dev_warn (dev,"could not reserve region %pR\n" , &nsio->res);return -EBUSY ; }
@@ -317,9 +320,9 @@ int devm_nsio_enable(struct device *dev, struct nd_namespace_io *nsio,if (devm_init_badblocks (dev, &nsio->bb))return -ENOMEM ;nvdimm_badblocks_populate (to_nd_region (ndns->dev.parent), &nsio->bb, - &nsio->res); + &range); - nsio->addr =devm_memremap (dev, res->start, size,ARCH_MEMREMAP_PMEM ); + nsio->addr =devm_memremap (dev, range.start, size,ARCH_MEMREMAP_PMEM );return PTR_ERR_OR_ZERO (nsio->addr); }
drivers/nvdimm/nd.h +2 -1
@@ -377,8 +377,9 @@ int nvdimm_namespace_detach_btt(struct nd_btt *nd_btt);const char *nvdimm_namespace_disk_name (struct nd_namespace_common *ndns,char *name);unsigned int pmem_sector_size (struct nd_namespace_common *ndns); +struct range ;void nvdimm_badblocks_populate (struct nd_region *nd_region, -struct badblocks *bb,const struct resource *res); +struct badblocks *bb,const struct range *range);int devm_namespace_enable (struct device *dev,struct nd_namespace_common *ndns,resource_size_t size); void devm_namespace_disable(struct device *dev,
drivers/nvdimm/pfn_devs.c +6 -6
@@ -672,7 +672,7 @@ static unsigned long init_altmap_reserve(resource_size_t base)static int __nvdimm_setup_pfn (struct nd_pfn *nd_pfn,struct dev_pagemap *pgmap) { -struct resource *res = &pgmap->res; +struct range *range = &pgmap->range;struct vmem_altmap *altmap = &pgmap->altmap;struct nd_pfn_sb *pfn_sb = nd_pfn->pfn_sb;u64 offset =le64_to_cpu (pfn_sb->dataoff);
@@ -689,16 +689,16 @@ static int __nvdimm_setup_pfn(struct nd_pfn *nd_pfn, struct dev_pagemap *pgmap) .end_pfn = PHYS_PFN(end), }; -memcpy (res, &nsio->res,sizeof (*res)); - res->start += start_pad; - res->end -= end_trunc; - + *range = (struct range ) { + .start = nsio->res.start + start_pad, + .end = nsio->res.end - end_trunc, + };if (nd_pfn->mode ==PFN_MODE_RAM ) {if (offset < reserve)return -EINVAL ; nd_pfn->npfns =le64_to_cpu (pfn_sb->npfns); }else if (nd_pfn->mode ==PFN_MODE_PMEM ) { - nd_pfn->npfns =PHYS_PFN ((resource_size (res) - offset)); + nd_pfn->npfns =PHYS_PFN ((range_len (range) - offset));if (le64_to_cpu (nd_pfn->pfn_sb->npfns) > nd_pfn->npfns) dev_info(&nd_pfn->dev, "number of pfns truncated from %lld to %ld\n",
drivers/nvdimm/pmem.c +14 -12
@@ -377,7 +377,7 @@ static int pmem_attach_disk(struct device *dev,struct nd_region *nd_region =to_nd_region (dev->parent);int nid =dev_to_node (dev), fua;struct resource *res = &nsio->res; -struct resource bb_res; +struct range bb_range;struct nd_pfn *nd_pfn =NULL ;struct dax_device *dax_dev;struct nd_pfn_sb *pfn_sb;
@@ -436,24 +436,26 @@ static int pmem_attach_disk(struct device *dev, pfn_sb = nd_pfn->pfn_sb; pmem->data_offset =le64_to_cpu (pfn_sb->dataoff); pmem->pfn_pad =resource_size (res) - -resource_size (&pmem->pgmap.res); +range_len (&pmem->pgmap.range); pmem->pfn_flags |=PFN_MAP ; -memcpy (&bb_res, &pmem->pgmap.res,sizeof (bb_res)); - bb_res.start += pmem->data_offset; + bb_range = pmem->pgmap.range; + bb_range.start += pmem->data_offset; }else if (pmem_should_map_pages (dev)) { -memcpy (&pmem->pgmap.res, &nsio->res,sizeof (pmem->pgmap.res)); + pmem->pgmap.range.start = res->start; + pmem->pgmap.range.end = res->end; pmem->pgmap.type =MEMORY_DEVICE_FS_DAX ; pmem->pgmap.ops = &fsdax_pagemap_ops; addr =devm_memremap_pages (dev, &pmem->pgmap); pmem->pfn_flags |=PFN_MAP ; -memcpy (&bb_res, &pmem->pgmap.res,sizeof (bb_res)); + bb_range = pmem->pgmap.range; }else {if (devm_add_action_or_reset (dev, pmem_release_queue, &pmem->pgmap))return -ENOMEM ; addr =devm_memremap (dev, pmem->phys_addr, pmem->size,ARCH_MEMREMAP_PMEM ); -memcpy (&bb_res, &nsio->res,sizeof (bb_res)); + bb_range.start = res->start; + bb_range.end = res->end; }if (IS_ERR (addr))
@@ -483,7 +485,7 @@ static int pmem_attach_disk(struct device *dev, / 512);if (devm_init_badblocks (dev, &pmem->bb))return -ENOMEM ; -nvdimm_badblocks_populate (nd_region, &pmem->bb, &bb_res); +nvdimm_badblocks_populate (nd_region, &pmem->bb, &bb_range); disk->bb = &pmem->bb;if (is_nvdimm_sync (nd_region))
@@ -594,8 +596,8 @@ static void nd_pmem_notify(struct device *dev, enum nvdimm_event event)resource_size_t offset =0 , end_trunc =0 ;struct nd_namespace_common *ndns;struct nd_namespace_io *nsio; -struct resource res;struct badblocks *bb; +struct range range;struct kernfs_node *bb_state;if (event !=NVDIMM_REVALIDATE_POISON )
@@ -631,9 +633,9 @@ static void nd_pmem_notify(struct device *dev, enum nvdimm_event event) nsio =to_nd_namespace_io (&ndns->dev); } - res.start = nsio->res.start + offset; - res.end = nsio->res.end - end_trunc; -nvdimm_badblocks_populate (nd_region, bb, &res); + range.start = nsio->res.start + offset; + range.end = nsio->res.end - end_trunc; +nvdimm_badblocks_populate (nd_region, bb, &range);if (bb_state)sysfs_notify_dirent (bb_state); }
drivers/nvdimm/region.c +12 -9
@@ -35,7 +35,10 @@ static int nd_region_probe(struct device *dev)return rc;if (is_memory (&nd_region->dev)) { -struct resource ndr_res; +struct range range = { + .start = nd_region->ndr_start, + .end = nd_region->ndr_start + nd_region->ndr_size -1 , + };if (devm_init_badblocks (dev, &nd_region->bb))return -ENODEV ;
@@ -44,9 +47,7 @@ static int nd_region_probe(struct device *dev)if (!nd_region->bb_state)dev_warn (&nd_region->dev,"'badblocks' notification disabled\n" ); - ndr_res.start = nd_region->ndr_start; - ndr_res.end = nd_region->ndr_start + nd_region->ndr_size -1 ; -nvdimm_badblocks_populate (nd_region, &nd_region->bb, &ndr_res); +nvdimm_badblocks_populate (nd_region, &nd_region->bb, &range); } rc =nd_region_register_namespaces (nd_region, &err);
@@ -121,14 +122,16 @@ static void nd_region_notify(struct device *dev, enum nvdimm_event event) {if (event ==NVDIMM_REVALIDATE_POISON ) {struct nd_region *nd_region =to_nd_region (dev); -struct resource res;if (is_memory (&nd_region->dev)) { - res.start = nd_region->ndr_start; - res.end = nd_region->ndr_start + - nd_region->ndr_size -1 ; +struct range range = { + .start = nd_region->ndr_start, + .end = nd_region->ndr_start + + nd_region->ndr_size -1 , + }; +nvdimm_badblocks_populate (nd_region, - &nd_region->bb, &res); + &nd_region->bb, &range);if (nd_region->bb_state)sysfs_notify_dirent (nd_region->bb_state); }
drivers/pci/p2pdma.c +5 -6
@@ -185,9 +185,8 @@ int pci_p2pdma_add_resource(struct pci_dev *pdev, int bar, size_t size,return -ENOMEM ; pgmap = &p2p_pgmap->pgmap; - pgmap->res.start =pci_resource_start (pdev, bar) + offset; - pgmap->res.end = pgmap->res.start + size -1 ; - pgmap->res.flags =pci_resource_flags (pdev, bar); + pgmap->range.start =pci_resource_start (pdev, bar) + offset; + pgmap->range.end = pgmap->range.start + size -1 ; pgmap->type =MEMORY_DEVICE_PCI_P2PDMA ; p2p_pgmap->provider = pdev;
@@ -202,13 +201,13 @@ int pci_p2pdma_add_resource(struct pci_dev *pdev, int bar, size_t size, error =gen_pool_add_owner (pdev->p2pdma->pool, (unsigned long )addr,pci_bus_address (pdev, bar) + offset, -resource_size (&pgmap->res),dev_to_node (&pdev->dev), +range_len (&pgmap->range),dev_to_node (&pdev->dev), pgmap->ref);if (error) goto pages_free; -pci_info (pdev,"added peer-to-peer DMA memory %pR\n" , - &pgmap->res); +pci_info (pdev,"added peer-to-peer DMA memory %#llx-%#llx\n" , + pgmap->range.start, pgmap->range.end);return 0 ;
include/linux/memremap.h +3 -2
@@ -1,6 +1,7 @@/* SPDX-License-Identifier: GPL-2.0 */ #ifndef _LINUX_MEMREMAP_H_#define _LINUX_MEMREMAP_H_ +#include <linux/range.h> #include <linux/ioport.h> #include <linux/percpu-refcount.h>
@@ -94,7 +95,7 @@ struct dev_pagemap_ops {/** * struct dev_pagemap - metadata for ZONE_DEVICE mappings * @altmap: pre-allocated/reserved memory for vmemmap allocations -* @res: physical address range covered by @ref +* @range: physical address range covered by @ref * @ref: reference count that pins the devm_memremap_pages() mapping * @internal_ref: internal reference if @ref is not provided by the caller * @done: completion for @internal_ref
@@ -107,7 +108,7 @@ struct dev_pagemap_ops {*/ struct dev_pagemap {struct vmem_altmap altmap; -struct resource res; +struct range range;struct percpu_ref *ref;struct percpu_ref internal_ref;struct completion done;
include/linux/range.h +6 -0
@@ -1,12 +1,18 @@/* SPDX-License-Identifier: GPL-2.0 */ #ifndef _LINUX_RANGE_H#define _LINUX_RANGE_H +#include <linux/types.h> struct range {u64 start;u64 end; }; +static inline u64 range_len (const struct range *range) +{ +return range->end - range->start +1 ; +} +int add_range (struct range *range,int az,int nr_range,u64 start,u64 end);
mm/memremap.c +39 -38
192 lines not on this page · raw message
tools/testing/nvdimm/test/iomap.c +1 -1
@@ -126,7 +126,7 @@ static void dev_pagemap_percpu_release(struct percpu_ref *ref)void *__wrap_devm_memremap_pages (struct device *dev,struct dev_pagemap *pgmap) {int error; -resource_size_t offset = pgmap->res.start; +resource_size_t offset = pgmap->range.start;struct nfit_test_resource *nfit_res =get_nfit_res (offset);if (!nfit_res)
Re: [PATCH v2 19/22] mm/memremap_pages: Convert to 'struct range'
Quoted 38 lines · Dan Williams
The 'struct resource' in 'struct
dev_pagemap' is only used for holding resource span information. The other fields, 'name', 'flags', 'desc', 'parent', 'sibling', and 'child' are all unused wasted space.This is in preparation for introducing a multi-range extension of
devm_memremap_pages().The bulk of this change is unwinding all the places internal to libnvdimm that used 'struct resource' unnecessarily.
P2PDMA had a minor usage of the flags field, but only to report failures with "%pR". That is replaced with an open coded print of the range.
Cc Paul Mackerras <[email protected]>Cc Michael Ellerman <[email protected]>Cc Benjamin Herrenschmidt <[email protected]>Cc Dan Williams <[email protected]>Cc Vishal Verma <[email protected]>Cc Dave Jiang <[email protected]>Cc Ben Skeggs <[email protected]>Cc David Airlie <[email protected]>Cc Daniel Vetter <[email protected]>Cc Ira Weiny <[email protected]>Cc Jason Gunthorpe <[email protected]>Signed-off-by Dan Williams <[email protected]>--- arch/powerpc/kvm/book3s_hv_uvmem.c | 13 +++-- drivers/dax/bus.c | 10 ++-- drivers/dax/bus.h | 2 - drivers/dax/dax-private.h | 5 -- drivers/dax/device.c | 3 - drivers/dax/hmem/hmem.c | 5 ++ drivers/dax/pmem/core.c | 12 ++--- drivers/gpu/drm/nouveau/nouveau_dmem.c | 3 + drivers/nvdimm/badrange.c | 26 +++++------ drivers/nvdimm/claim.c | 13 +++-- drivers/nvdimm/nd.h | 3 + drivers/nvdimm/pfn_devs.c | 12 ++---
Quoted 8 lines
drivers/nvdimm/pmem.c | 26 ++++++----- drivers/nvdimm/region.c | 21 +++++---- drivers/pci/p2pdma.c | 11 ++--- include/linux/memremap.h | 5 +- include/linux/range.h | 6 ++ mm/memremap.c | 77 ++++++++++++++++---------------- tools/testing/nvdimm/test/iomap.c | 2 - 19 files changed, 135 insertions(+), 120 deletions(-)
I think you are missing a call to memremap_pages() in lib/test_hmm.c and a call to release_mem_region() that need to be converted too. Try setting CONFIG_TEST_HMM=m.
Also, what about the call to release_mem_region() in drivers/gpu/drm/nouveau/nouveau_dmem.c? Doesn't that need a small change too?
_______________________________________________
Linux-nvdimm mailing list -- [email protected]
To unsubscribe send an email to [email protected]
Re: [PATCH v2 19/22] mm/memremap_pages: Convert to 'struct range'
Quoted 50 lines · Ralph Campbell
Quoted 38 lines · Dan Williams
The 'struct resource' in 'struct
dev_pagemap' is only used for holding resource span information. The other fields, 'name', 'flags', 'desc', 'parent', 'sibling', and 'child' are all unused wasted space.This is in preparation for introducing a multi-range extension of
devm_memremap_pages().The bulk of this change is unwinding all the places internal to libnvdimm that used 'struct resource' unnecessarily.
P2PDMA had a minor usage of the flags field, but only to report failures with "%pR". That is replaced with an open coded print of the range.
Cc Paul Mackerras <[email protected]>Cc Michael Ellerman <[email protected]>Cc Benjamin Herrenschmidt <[email protected]>Cc Dan Williams <[email protected]>Cc Vishal Verma <[email protected]>Cc Dave Jiang <[email protected]>Cc Ben Skeggs <[email protected]>Cc David Airlie <[email protected]>Cc Daniel Vetter <[email protected]>Cc Ira Weiny <[email protected]>Cc Jason Gunthorpe <[email protected]>Signed-off-by Dan Williams <[email protected]>--- arch/powerpc/kvm/book3s_hv_uvmem.c | 13 +++-- drivers/dax/bus.c | 10 ++-- drivers/dax/bus.h | 2 - drivers/dax/dax-private.h | 5 -- drivers/dax/device.c | 3 - drivers/dax/hmem/hmem.c | 5 ++ drivers/dax/pmem/core.c | 12 ++--- drivers/gpu/drm/nouveau/nouveau_dmem.c | 3 + drivers/nvdimm/badrange.c | 26 +++++------ drivers/nvdimm/claim.c | 13 +++-- drivers/nvdimm/nd.h | 3 + drivers/nvdimm/pfn_devs.c | 12 ++---Quoted 8 lines
drivers/nvdimm/pmem.c | 26 ++++++----- drivers/nvdimm/region.c | 21 +++++---- drivers/pci/p2pdma.c | 11 ++--- include/linux/memremap.h | 5 +- include/linux/range.h | 6 ++ mm/memremap.c | 77 ++++++++++++++++---------------- tools/testing/nvdimm/test/iomap.c | 2 - 19 files changed, 135 insertions(+), 120 deletions(-)
Quoted 3 lines
I think you are missing a call to
memremap_pages()inlib/test_hmm.cand a call torelease_mem_region()that need to be converted too. Try settingCONFIG_TEST_HMM=m.
Thanks Ralph, looks like I overlooked these changes since the rebase.
Quoted 2 lines
Also, what about the call to
release_mem_region()indrivers/gpu/drm/nouveau/nouveau_dmem.c? Doesn't that need a small change too?
I'll double check my config, that one should have been flagged at build time.
PATCH v2 20/22 mm/memremap_pages: Support multiple ranges per invocation
In reply to Dan WilliamsIn support of device-dax growing the ability to front physically dis-contiguous ranges of memory, update devm_memremap_pages() to track multiple ranges with a single reference counter and devm instance.
--- arch/powerpc/kvm/book3s_hv_uvmem.c | 1 drivers/dax/device.c | 1 drivers/gpu/drm/nouveau/nouveau_dmem.c | 1 drivers/nvdimm/pfn_devs.c | 1 drivers/nvdimm/pmem.c | 1 drivers/pci/p2pdma.c | 1 include/linux/memremap.h | 10 + mm/memremap.c | 259 +++++++++++++++++++------------- 8 files changed, 165 insertions(+), 110 deletions(-)
arch/powerpc/kvm/book3s_hv_uvmem.c +1 -0
@@ -808,6 +808,7 @@ int kvmppc_uvmem_init(void) kvmppc_uvmem_pgmap.type =MEMORY_DEVICE_PRIVATE ; kvmppc_uvmem_pgmap.range.start = res->start; kvmppc_uvmem_pgmap.range.end = res->end; + kvmppc_uvmem_pgmap.nr_range =1 ; kvmppc_uvmem_pgmap.ops = &kvmppc_uvmem_ops;/* just one global instance: */ kvmppc_uvmem_pgmap.owner = &kvmppc_uvmem_pgmap;
drivers/dax/device.c +1 -0
@@ -417,6 +417,7 @@ int dev_dax_probe(struct dev_dax *dev_dax)if (!pgmap)return -ENOMEM ; pgmap->range = *range; + pgmap->nr_range =1 ; } pgmap->type =MEMORY_DEVICE_DEVDAX ; addr =devm_memremap_pages (dev, pgmap);
drivers/gpu/drm/nouveau/nouveau_dmem.c +1 -0
@@ -241,6 +241,7 @@ nouveau_dmem_chunk_alloc(struct nouveau_drm *drm, struct page **ppage) chunk->pagemap.type =MEMORY_DEVICE_PRIVATE ; chunk->pagemap.range.start = res->start; chunk->pagemap.range.end = res->end; + chunk->pagemap.nr_range =1 ; chunk->pagemap.ops = &nouveau_dmem_pagemap_ops; chunk->pagemap.owner = drm->dev;
drivers/nvdimm/pfn_devs.c +1 -0
@@ -693,6 +693,7 @@ static int __nvdimm_setup_pfn(struct nd_pfn *nd_pfn, struct dev_pagemap *pgmap) .start = nsio->res.start + start_pad, .end = nsio->res.end - end_trunc, }; + pgmap->nr_range =1 ;if (nd_pfn->mode ==PFN_MODE_RAM ) {if (offset < reserve)return -EINVAL ;
drivers/nvdimm/pmem.c +1 -0
@@ -443,6 +443,7 @@ static int pmem_attach_disk(struct device *dev, }else if (pmem_should_map_pages (dev)) { pmem->pgmap.range.start = res->start; pmem->pgmap.range.end = res->end; + pmem->pgmap.nr_range =1 ; pmem->pgmap.type =MEMORY_DEVICE_FS_DAX ; pmem->pgmap.ops = &fsdax_pagemap_ops; addr =devm_memremap_pages (dev, &pmem->pgmap);
drivers/pci/p2pdma.c +1 -0
@@ -187,6 +187,7 @@ int pci_p2pdma_add_resource(struct pci_dev *pdev, int bar, size_t size, pgmap = &p2p_pgmap->pgmap; pgmap->range.start =pci_resource_start (pdev, bar) + offset; pgmap->range.end = pgmap->range.start + size -1 ; + pgmap->nr_range =1 ; pgmap->type =MEMORY_DEVICE_PCI_P2PDMA ; p2p_pgmap->provider = pdev;
include/linux/memremap.h +8 -2
@@ -95,7 +95,6 @@ struct dev_pagemap_ops {/** * struct dev_pagemap - metadata for ZONE_DEVICE mappings * @altmap: pre-allocated/reserved memory for vmemmap allocations -* @range: physical address range covered by @ref * @ref: reference count that pins the devm_memremap_pages() mapping * @internal_ref: internal reference if @ref is not provided by the caller * @done: completion for @internal_ref
@@ -105,10 +104,12 @@ struct dev_pagemap_ops {* @owner: an opaque pointer identifying the entity that manages this * instance. Used by various helpers to make sure that no * foreign ZONE_DEVICE memory is accessed. +* @nr_range: number of ranges to be mapped +* @range: range to be mapped when nr_range == 1 +* @ranges: array of ranges to be mapped when nr_range > 1 */ struct dev_pagemap {struct vmem_altmap altmap; -struct range range;struct percpu_ref *ref;struct percpu_ref internal_ref;struct completion done;
@@ -116,6 +117,11 @@ struct dev_pagemap {unsigned int flags;const struct dev_pagemap_ops *ops;void *owner; +int nr_range; +union { +struct range range; +struct range ranges[0 ]; + }; };static inline struct vmem_altmap *pgmap_altmap (struct dev_pagemap *pgmap)
mm/memremap.c +151 -108
356 lines not on this page · raw message
PATCH v2 21/22 device-dax: Add dis-contiguous resource support
In reply to Dan WilliamsBreak the requirement that device-dax instances are physically contiguous. With this constraint removed it allows fragmented available capacity to be fully allocated.
This capability is useful to mitigate the "noisy neighbor" problem with memory-side-cache management for virtual machines, or any other scenario where a platform address boundary also designates a performance boundary. For example a direct mapped memory side cache might rotate cache colors at 1GB boundaries. With dis-contiguous allocations a device-dax instance could be configured to contain only 1 cache color.
It also satisfies Joao's use case (see link) for partitioning memory for exclusive guest access. It allows for a future potential mode where the host kernel need not allocate 'struct page' capacity up-front.
--- drivers/dax/bus.c | 230 +++++++++++++++++++++++++++++++--------- drivers/dax/dax-private.h | 9 +- drivers/dax/device.c | 55 ++++++---- drivers/dax/kmem.c | 132 +++++++++++++++-------- tools/testing/nvdimm/dax-dev.c | 20 ++- 5 files changed, 319 insertions(+), 127 deletions(-)
drivers/dax/bus.c +176 -54
@@ -136,15 +136,27 @@ static bool is_static(struct dax_region *dax_region)return (dax_region->res.flags &IORESOURCE_DAX_STATIC ) !=0 ; } +static u64 dev_dax_size (struct dev_dax *dev_dax) +{ +u64 size =0 ; +int i; + +device_lock_assert (&dev_dax->dev); + +for (i =0 ; i < dev_dax->nr_range; i++) + size +=range_len (&dev_dax->ranges[i].range); + +return size; +} +static int dax_bus_probe (struct device *dev) {struct dax_device_driver *dax_drv =to_dax_drv (dev->driver);struct dev_dax *dev_dax =to_dev_dax (dev);struct dax_region *dax_region = dev_dax->region; -struct range *range = &dev_dax->range;int rc; -if (range_len (range) ==0 || dev_dax->id <0 ) +if (dev_dax_size (dev_dax) ==0 || dev_dax->id <0 )return -ENXIO ; rc = dax_drv->probe (dev_dax);
@@ -354,15 +366,19 @@ void kill_dev_dax(struct dev_dax *dev_dax) }EXPORT_SYMBOL_GPL (kill_dev_dax); -static void free_dev_dax_range (struct dev_dax *dev_dax) +static void free_dev_dax_ranges (struct dev_dax *dev_dax) {struct dax_region *dax_region = dev_dax->region; -struct range *range = &dev_dax->range; +int i;device_lock_assert (dax_region->dev); -if (range_len (range)) +for (i =0 ; i < dev_dax->nr_range; i++) { +struct range *range = &dev_dax->ranges[i].range; +__release_region (&dax_region->res, range->start,range_len (range)); + } + dev_dax->nr_range =0 ; }static void unregister_dev_dax (void *dev)
@@ -372,7 +388,7 @@ static void unregister_dev_dax(void *dev)dev_dbg (dev,"%s\n" , __func__);kill_dev_dax (dev_dax); -free_dev_dax_range (dev_dax); +free_dev_dax_ranges (dev_dax);device_del (dev);put_device (dev); }
@@ -423,7 +439,7 @@ static ssize_t delete_store(struct device *dev, struct device_attribute *attr,device_lock (dev);device_lock (victim); dev_dax =to_dev_dax (victim); -if (victim->driver ||range_len (&dev_dax->range)) +if (victim->driver ||dev_dax_size (dev_dax)) rc = -EBUSY ;else {/*
@@ -569,51 +585,83 @@ static int alloc_dev_dax_range(struct dev_dax *dev_dax, u64 start,struct dax_region *dax_region = dev_dax->region;struct resource *res = &dax_region->res;struct device *dev = &dev_dax->dev; +struct dev_dax_range *ranges; +unsigned long pgoff =0 ;struct resource *alloc; +int i;device_lock_assert (dax_region->dev);/* handle the seed alloc special case */ if (!size) { - dev_dax->range = (struct range ) { - .start = res->start, - .end = res->start -1 , - }; +if (dev_WARN_ONCE (dev, dev_dax->nr_range, +"0-size allocation must be first\n" )) +return -EBUSY ; +/* nr_range == 0 is elsewhere special cased as 0-size device */ return 0 ; } + ranges =krealloc (dev_dax->ranges,sizeof (*ranges) + * (dev_dax->nr_range +1 ),GFP_KERNEL ); +if (!ranges) +return -ENOMEM ; + alloc =__request_region (res, start, size,dev_name (dev),0 ); -if (!alloc) +if (!alloc && !dev_dax->nr_range) { +/* +* If we adjusted an existing @ranges leave it alone, +* but if this was an empty set of ranges nothing else +* will release @ranges, so do it now. +*/ +kfree (ranges);return -ENOMEM ; + } - dev_dax->range = (struct range ) { - .start = alloc->start, - .end = alloc->end, +for (i =0 ; i < dev_dax->nr_range; i++) + pgoff +=PHYS_PFN (range_len (&ranges[i].range)); + dev_dax->ranges = ranges; + ranges[dev_dax->nr_range++] = (struct dev_dax_range ) { + .pgoff = pgoff, + .range = { + .start = alloc->start, + .end = alloc->end, + }, }; +dev_dbg (dev,"alloc range[%d]: %pa:%pa\n" , dev_dax->nr_range -1 , + &alloc->start, &alloc->end); +return 0 ; }static int adjust_dev_dax_range (struct dev_dax *dev_dax,struct resource *res,resource_size_t size) { +int last_range = dev_dax->nr_range -1 ; +struct dev_dax_range *dax_range = &dev_dax->ranges[last_range];struct dax_region *dax_region = dev_dax->region; -struct range *range = &dev_dax->range; -int rc =0 ; +bool is_shrink =resource_size (res) > size; +struct range *range = &dax_range->range; +struct device *dev = &dev_dax->dev; +int rc;device_lock_assert (dax_region->dev); -if (size) - rc =adjust_resource (res, range->start, size); -else -__release_region (&dax_region->res, range->start,range_len (range)); +if (dev_WARN_ONCE (dev, !size,"deletion is handled by dev_dax_shrink\n" )) +return -EINVAL ; + + rc =adjust_resource (res, range->start, size);if (rc)return rc; - dev_dax->range = (struct range ) { + *range = (struct range ) { .start = range->start, .end = range->start + size -1 , }; +dev_dbg (dev,"%s range[%d]: %#llx:%#llx\n" , is_shrink ?"shrink" :"extend" , + last_range, (unsigned long long ) range->start, + (unsigned long long ) range->end); +return 0 ; }
@@ -621,7 +669,11 @@ static ssize_t size_show(struct device *dev, struct device_attribute *attr, char *buf) { struct dev_dax *dev_dax = to_dev_dax(dev); -unsigned long long size =range_len (&dev_dax->range); +unsigned long long size; + +device_lock (dev); + size =dev_dax_size (dev_dax); +device_unlock (dev);return sprintf (buf,"%llu\n" , size); }
@@ -639,32 +691,82 @@ static bool alloc_is_aligned(struct dax_region *dax_region,static int dev_dax_shrink (struct dev_dax *dev_dax,resource_size_t size) { +resource_size_t to_shrink =dev_dax_size (dev_dax) - size;struct dax_region *dax_region = dev_dax->region; -struct range *range = &dev_dax->range; -struct resource *res, *adjust =NULL ;struct device *dev = &dev_dax->dev; - -for_each_dax_region_resource (dax_region, res) -if (strcmp (res->name,dev_name (dev)) ==0 - && res->start == range->start) { - adjust = res; -break ; +int i; + +for (i = dev_dax->nr_range -1 ; i >=0 ; i--) { +struct range *range = &dev_dax->ranges[i].range; +struct resource *adjust =NULL , *res; +resource_size_t shrink; + + shrink =min (to_shrink,range_len (range)); +if (shrink >=range_len (range)) { +__release_region (&dax_region->res, range->start, +range_len (range)); + dev_dax->nr_range--; +dev_dbg (dev,"delete range[%d]: %#llx:%#llx\n" , i, + (unsigned long long ) range->start, + (unsigned long long ) range->end); + to_shrink -= shrink; +if (!to_shrink) +break ; +continue ; } -if (dev_WARN_ONCE (dev, !adjust,"failed to find matching resource\n" )) -return -ENXIO ; -return __adjust_dev_dax_range (dev_dax, adjust, size); +for_each_dax_region_resource (dax_region, res) +if (strcmp (res->name,dev_name (dev)) ==0 + && res->start == range->start) { + adjust = res; +break ; + } + +if (dev_WARN_ONCE (dev, !adjust || i != dev_dax->nr_range -1 , +"failed to find matching resource\n" )) +return -ENXIO ; +return adjust_dev_dax_range (dev_dax, adjust,range_len (range) + - shrink); + } +return 0 ; +} + +/* +* Only allow adjustments that preserve the relative pgoff of existing +* allocations. I.e. the dev_dax->ranges array is ordered by increasing pgoff. +*/ +static bool adjust_ok (struct dev_dax *dev_dax,struct resource *res) +{ +struct dev_dax_range *last; +int i; + +if (dev_dax->nr_range ==0 ) +return false; +if (strcmp (res->name,dev_name (&dev_dax->dev)) !=0 ) +return false; + last = &dev_dax->ranges[dev_dax->nr_range -1 ]; +if (last->range.start != res->start || last->range.end != res->end) +return false; +for (i =0 ; i < dev_dax->nr_range -1 ; i++) { +struct dev_dax_range *dax_range = &dev_dax->ranges[i]; + +if (dax_range->pgoff > last->pgoff) +return false; + } + +return true; }static ssize_t dev_dax_resize (struct dax_region *dax_region,struct dev_dax *dev_dax,resource_size_t size) {resource_size_t avail =dax_region_avail_size (dax_region), to_alloc; -resource_size_t dev_size =range_len (&dev_dax->range); +resource_size_t dev_size =dev_dax_size (dev_dax);struct resource *region_res = &dax_region->res;struct device *dev = &dev_dax->dev; -const char *name =dev_name (dev);struct resource *res, *first; +resource_size_t alloc =0 ; +int rc;if (dev->driver)return -EBUSY ;
@@ -685,35 +787,47 @@ static ssize_t dev_dax_resize(struct dax_region *dax_region,* may involve adjusting the end of an existing resource, or * allocating a new resource. */ +retry: first = region_res->child;if (!first)return alloc_dev_dax_range (dev_dax, dax_region->res.start, to_alloc); -for (res = first; to_alloc && res; res = res->sibling) { + + rc = -ENOSPC ; +for (res = first; res; res = res->sibling) {struct resource *next = res->sibling; -resource_size_t free;/* space at the beginning of the region */ - free =0 ; -if (res == first && res->start > dax_region->res.start) - free = res->start - dax_region->res.start; -if (free >= to_alloc && dev_size ==0 ) -return alloc_dev_dax_range (dev_dax, dax_region->res.start, to_alloc); +if (res == first && res->start > dax_region->res.start) { + alloc =min (res->start - dax_region->res.start, to_alloc); + rc =alloc_dev_dax_range (dev_dax, dax_region->res.start, alloc); +break ; + } - free =0 ; + alloc =0 ;/* space between allocations */ if (next && next->start > res->end +1 ) - free = next->start - res->end +1 ; + alloc =min (next->start - (res->end +1 ), to_alloc);/* space at the end of the region */ -if (free < to_alloc && !next && res->end < region_res->end) - free = region_res->end - res->end; +if (!alloc && !next && res->end < region_res->end) + alloc =min (region_res->end - res->end, to_alloc); -if (free >= to_alloc &&strcmp (name, res->name) ==0 ) -return adjust_dev_dax_range (dev_dax, res,resource_size (res) + to_alloc); -else if (free >= to_alloc && dev_size ==0 ) -return alloc_dev_dax_range (dev_dax, res->end +1 , to_alloc); +if (!alloc) +continue ; + +if (adjust_ok (dev_dax, res)) { + rc =adjust_dev_dax_range (dev_dax, res,resource_size (res) + alloc); +break ; + } + rc =alloc_dev_dax_range (dev_dax, res->end +1 , alloc); +break ; } -return -ENOSPC ; +if (rc) +return rc; + to_alloc -= alloc; +if (to_alloc) + goto retry; +return 0 ; } static ssize_t size_store(struct device *dev, struct device_attribute *attr,
@@ -767,8 +881,15 @@ static ssize_t resource_show(struct device *dev, struct device_attribute *attr, char *buf) { struct dev_dax *dev_dax = to_dev_dax(dev); +struct dax_region *dax_region = dev_dax->region; +unsigned long long start; + +if (dev_dax->nr_range <1 ) + start = dax_region->res.start; +else + start = dev_dax->ranges[0 ].range.start; -return sprintf (buf,"%#llx\n" , dev_dax->range.start); +return sprintf (buf,"%#llx\n" , start); } static DEVICE_ATTR(resource, 0400, resource_show, NULL);
@@ -833,6 +954,7 @@ static void dev_dax_release(struct device *dev)put_dax (dax_dev);free_dev_dax_id (dev_dax);dax_region_put (dax_region); +kfree (dev_dax->ranges);kfree (dev_dax->pgmap);kfree (dev_dax); }
@@ -941,7 +1063,7 @@ struct dev_dax *devm_create_dev_dax(struct dev_dax_data *data) err_alloc_dax:kfree (dev_dax->pgmap); err_pgmap: -free_dev_dax_range (dev_dax); +free_dev_dax_ranges (dev_dax); err_range:free_dev_dax_id (dev_dax); err_id:
drivers/dax/dax-private.h +7 -2
@@ -49,7 +49,8 @@ struct dax_region {* @id: ida allocated id * @dev - device core * @pgmap - pgmap for memmap setup / lifetime (driver owned) -* @range: resource range for the instance +* @nr_range: size of @ranges +* @ranges: resource-span + pgoff tuples for the instance */ struct dev_dax {struct dax_region *region;
@@ -58,7 +59,11 @@ struct dev_dax {int id;struct device dev;struct dev_pagemap *pgmap; -struct range range; +int nr_range; +struct dev_dax_range { +unsigned long pgoff; +struct range range; + } *ranges; };static inline struct dev_dax *to_dev_dax (struct device *dev)
drivers/dax/device.c +36 -19
81 lines not on this page · raw message
drivers/dax/kmem.c +86 -46
170 lines not on this page · raw message
tools/testing/nvdimm/dax-dev.c +14 -6
@@ -9,11 +9,18 @@phys_addr_t dax_pgoff_to_phys (struct dev_dax *dev_dax,pgoff_t pgoff,unsigned long size) { -struct range *range = &dev_dax->range; -phys_addr_t addr; +int i; - addr = pgoff *PAGE_SIZE + range->start; -if (addr >= range->start && addr <= range->end) { +for (i =0 ; i < dev_dax->nr_range; i++) { +struct dev_dax_range *dax_range = &dev_dax->ranges[i]; +struct range *range = &dax_range->range; +unsigned long long pgoff_end; +phys_addr_t addr; + + pgoff_end = dax_range->pgoff +PHYS_PFN (range_len (range)) -1 ; +if (pgoff < dax_range->pgoff || pgoff > pgoff_end) +continue ; + addr =PFN_PHYS (pgoff - dax_range->pgoff) + range->start;if (addr + size -1 <= range->end) {if (get_nfit_res (addr)) {struct page *page;
@@ -23,9 +30,10 @@ phys_addr_t dax_pgoff_to_phys(struct dev_dax *dev_dax, pgoff_t pgoff, page =vmalloc_to_page ((void *)addr);return PFN_PHYS (page_to_pfn (page)); - }else -return addr; + } +return addr; } +break ; }return -1 ; }
_______________________________________________
Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH v2 22/22 device-dax: Introduce 'mapping' devices
In reply to Dan WilliamsIn support of interrogating the physical address layout of a device with dis-contiguous ranges, introduce a sysfs directory with 'start', 'end', and 'page_offset' attributes. The alternative is trying to parse /proc/iomem, and that file will not reflect the extent layout until the device is enabled.
--- drivers/dax/bus.c | 191 +++++++++++++++++++++++++++++++++++++++++++++ drivers/dax/dax-private.h | 14 +++ 2 files changed, 203 insertions(+), 2 deletions(-)
drivers/dax/bus.c +189 -2
@@ -579,6 +579,167 @@ struct dax_region *alloc_dax_region(struct device *parent, int region_id, }EXPORT_SYMBOL_GPL (alloc_dax_region); +static void dax_mapping_release (struct device *dev) +{ +struct dax_mapping *mapping =to_dax_mapping (dev); +struct dev_dax *dev_dax =to_dev_dax (dev->parent); + +ida_free (&dev_dax->ida, mapping->id); +kfree (mapping); +} + +static void unregister_dax_mapping (void *data) +{ +struct device *dev = data; +struct dax_mapping *mapping =to_dax_mapping (dev); +struct dev_dax *dev_dax =to_dev_dax (dev->parent); +struct dax_region *dax_region = dev_dax->region; + +dev_dbg (dev,"%s\n" , __func__); + +device_lock_assert (dax_region->dev); + + dev_dax->ranges[mapping->range_id].mapping =NULL ; + mapping->range_id =-1 ; + +device_del (dev); +put_device (dev); +} + +static struct dev_dax_range *get_dax_range (struct device *dev) +{ +struct dax_mapping *mapping =to_dax_mapping (dev); +struct dev_dax *dev_dax =to_dev_dax (dev->parent); +struct dax_region *dax_region = dev_dax->region; + +device_lock (dax_region->dev); +if (mapping->range_id <1 ) { +device_unlock (dax_region->dev); +return NULL ; + } + +return &dev_dax->ranges[mapping->range_id]; +} + +static void put_dax_range (struct dev_dax_range *dax_range) +{ +struct dax_mapping *mapping = dax_range->mapping; +struct dev_dax *dev_dax =to_dev_dax (mapping->dev.parent); +struct dax_region *dax_region = dev_dax->region; + +device_unlock (dax_region->dev); +} + +static ssize_t start_show (struct device *dev, +struct device_attribute *attr,char *buf) +{ +struct dev_dax_range *dax_range; +ssize_t rc; + + dax_range =get_dax_range (dev); +if (!dax_range) +return -ENXIO ; + rc =sprintf (buf,"%#llx\n" , dax_range->range.start); +put_dax_range (dax_range); + +return rc; +} +static DEVICE_ATTR(start, 0400, start_show, NULL); + +static ssize_t end_show (struct device *dev, +struct device_attribute *attr,char *buf) +{ +struct dev_dax_range *dax_range; +ssize_t rc; + + dax_range =get_dax_range (dev); +if (!dax_range) +return -ENXIO ; + rc =sprintf (buf,"%#llx\n" , dax_range->range.end); +put_dax_range (dax_range); + +return rc; +} +static DEVICE_ATTR(end, 0400, end_show, NULL); + +static ssize_t pgoff_show (struct device *dev, +struct device_attribute *attr,char *buf) +{ +struct dev_dax_range *dax_range; +ssize_t rc; + + dax_range =get_dax_range (dev); +if (!dax_range) +return -ENXIO ; + rc =sprintf (buf,"%#lx\n" , dax_range->pgoff); +put_dax_range (dax_range); + +return rc; +} +static DEVICE_ATTR(page_offset, 0400, pgoff_show, NULL); + +static struct attribute *dax_mapping_attributes[] = { + &dev_attr_start.attr, + &dev_attr_end.attr, + &dev_attr_page_offset.attr, +NULL , +}; + +static const struct attribute_group dax_mapping_attribute_group = { + .attrs = dax_mapping_attributes, +}; + +static const struct attribute_group *dax_mapping_attribute_groups[] = { + &dax_mapping_attribute_group, +NULL , +}; + +static struct device_type dax_mapping_type = { + .release = dax_mapping_release, + .groups = dax_mapping_attribute_groups, +}; + +static int devm_register_dax_mapping (struct dev_dax *dev_dax,int range_id) +{ +struct dax_region *dax_region = dev_dax->region; +struct dax_mapping *mapping; +struct device *dev; +int rc; + +device_lock_assert (dax_region->dev); + +if (dev_WARN_ONCE (&dev_dax->dev, !dax_region->dev->driver, +"region disabled\n" )) +return -ENXIO ; + + mapping =kzalloc (sizeof (*mapping),GFP_KERNEL ); +if (!mapping) +return -ENOMEM ; + mapping->range_id = range_id; + mapping->id =ida_alloc (&dev_dax->ida,GFP_KERNEL ); +if (mapping->id <0 ) { +kfree (mapping); +return -ENOMEM ; + } + dev_dax->ranges[range_id].mapping = mapping; + dev = &mapping->dev; +device_initialize (dev); + dev->parent = &dev_dax->dev; + dev->type = &dax_mapping_type; +dev_set_name (dev,"mapping%d" , mapping->id); + rc =device_add (dev); +if (rc) { +put_device (dev); +return rc; + } + + rc =devm_add_action_or_reset (dax_region->dev, unregister_dax_mapping, + dev); +if (rc) +return rc; +return 0 ; +} +static int alloc_dev_dax_range (struct dev_dax *dev_dax,u64 start,resource_size_t size) {
@@ -588,7 +749,7 @@ static int alloc_dev_dax_range(struct dev_dax *dev_dax, u64 start,struct dev_dax_range *ranges;unsigned long pgoff =0 ;struct resource *alloc; -int i; +int i, rc;device_lock_assert (dax_region->dev);
@@ -630,6 +791,22 @@ static int alloc_dev_dax_range(struct dev_dax *dev_dax, u64 start,dev_dbg (dev,"alloc range[%d]: %pa:%pa\n" , dev_dax->nr_range -1 , &alloc->start, &alloc->end); +/* +* A dev_dax instance must be registered before mapping device +* children can be added. Defer to devm_create_dev_dax() to add +* the initial mapping device. +*/ +if (!device_is_registered (&dev_dax->dev)) +return 0 ; + + rc =devm_register_dax_mapping (dev_dax, dev_dax->nr_range -1 ); +if (rc) { +dev_dbg (dev,"delete range[%d]: %pa:%pa\n" , dev_dax->nr_range -1 , + &alloc->start, &alloc->end); + dev_dax->nr_range--; +__release_region (res, alloc->start,resource_size (alloc)); +return rc; + }return 0 ; }
@@ -698,11 +875,14 @@ static int dev_dax_shrink(struct dev_dax *dev_dax, resource_size_t size)for (i = dev_dax->nr_range -1 ; i >=0 ; i--) {struct range *range = &dev_dax->ranges[i].range; +struct dax_mapping *mapping = dev_dax->ranges[i].mapping;struct resource *adjust =NULL , *res;resource_size_t shrink; shrink =min (to_shrink,range_len (range));if (shrink >=range_len (range)) { +devm_release_action (dax_region->dev, + unregister_dax_mapping, &mapping->dev);__release_region (&dax_region->res, range->start,range_len (range)); dev_dax->nr_range--;
@@ -1033,9 +1213,9 @@ struct dev_dax *devm_create_dev_dax(struct dev_dax_data *data)/* a device_dax instance is dead while the driver is not attached */ kill_dax (dax_dev); -/* from here on we're committed to teardown via dev_dax_release() */ dev_dax->dax_dev = dax_dev; dev_dax->target_node = dax_region->target_node; +ida_init (&dev_dax->ida);kref_get (&dax_region->kref); inode =dax_inode (dax_dev);
@@ -1058,6 +1238,13 @@ struct dev_dax *devm_create_dev_dax(struct dev_dax_data *data)if (rc)return ERR_PTR (rc); +/* register mapping device for the initial allocation range */ +if (dev_dax->nr_range &&range_len (&dev_dax->ranges[0 ].range)) { + rc =devm_register_dax_mapping (dev_dax,0 ); +if (rc) +return ERR_PTR (rc); + } +return dev_dax; err_alloc_dax:
drivers/dax/dax-private.h +14 -0
@@ -40,6 +40,12 @@ struct dax_region {struct device *youngest; }; +struct dax_mapping { +struct device dev; +int range_id; +int id; +}; +/** * struct dev_dax - instance data for a subdivision of a dax region, and * data while the device is activated in the driver.
@@ -47,6 +53,7 @@ struct dax_region {* @dax_dev - core dax functionality * @target_node: effective numa node if dev_dax memory range is onlined * @id: ida allocated id +* @ida: mapping id allocator * @dev - device core * @pgmap - pgmap for memmap setup / lifetime (driver owned) * @nr_range: size of @ranges
@@ -57,12 +64,14 @@ struct dev_dax {struct dax_device *dax_dev;int target_node;int id; +struct ida ida;struct device dev;struct dev_pagemap *pgmap;int nr_range;struct dev_dax_range {unsigned long pgoff;struct range range; +struct dax_mapping *mapping; } *ranges; };
@@ -70,4 +79,9 @@ static inline struct dev_dax *to_dev_dax(struct device *dev) { return container_of(dev, struct dev_dax, dev); } + +static inline struct dax_mapping *to_dax_mapping (struct device *dev) +{ + return container_of(dev, struct dax_mapping, dev); +}#endif
_______________________________________________
Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
Re: [PATCH v2 22/22] device-dax: Introduce 'mapping' devices
Quoted 46 lines · Dan Williams
In support of interrogating the physical address layout of a device with dis-contiguous ranges, introduce a sysfs directory with 'start', 'end', and '
page_offset' attributes. The alternative is trying to parse/proc/iomem, and that file will not reflect the extent layout until the device is enabled.Cc Vishal Verma <[email protected]>Signed-off-by Dan Williams <[email protected]>--- drivers/dax/bus.c | 191 +++++++++++++++++++++++++++++++++++++++++++++ drivers/dax/dax-private.h | 14 +++ 2 files changed, 203 insertions(+), 2 deletions(-)drivers/dax/bus.c +25
-0@@ -579,6 +579,167 @@ struct dax_region *alloc_dax_region(struct device *parent, int region_id, }EXPORT_SYMBOL_GPL (alloc_dax_region); +static void dax_mapping_release (struct device *dev) +{ +struct dax_mapping *mapping =to_dax_mapping (dev); +struct dev_dax *dev_dax =to_dev_dax (dev->parent); + +ida_free (&dev_dax->ida, mapping->id); +kfree (mapping); +} + +static void unregister_dax_mapping (void *data) +{ +struct device *dev = data; +struct dax_mapping *mapping =to_dax_mapping (dev); +struct dev_dax *dev_dax =to_dev_dax (dev->parent); +struct dax_region *dax_region = dev_dax->region; + +dev_dbg (dev,"%s\n" , __func__); + +device_lock_assert (dax_region->dev); + + dev_dax->ranges[mapping->range_id].mapping =NULL ; + mapping->range_id =-1 ; + +device_del (dev); +put_device (dev);
drivers/dax/bus.c struct dax_region *alloc_dax_region(struct device *parent, int region_id, · line 616
Quoted 10 lines
drivers/dax/bus.c +10
-0+} + +static struct dev_dax_range *get_dax_range (struct device *dev) +{ +struct dax_mapping *mapping =to_dax_mapping (dev); +struct dev_dax *dev_dax =to_dev_dax (dev->parent); +struct dax_region *dax_region = dev_dax->region; + +device_lock (dax_region->dev); +if (mapping->range_id <1 ) {
^^^^^^^^^^^^^^^^^^^^^ it's 'mapping->range_id < 0'
Otherwise 'mapping0' sysfs entries won't work.
Disabled ranges use id -1.
Joao
Re: [PATCH v2 22/22] device-dax: Introduce 'mapping' devices
Quoted 60 lines · Joao Martins
Quoted 46 lines · Dan Williams
In support of interrogating the physical address layout of a device with dis-contiguous ranges, introduce a sysfs directory with 'start', 'end', and '
page_offset' attributes. The alternative is trying to parse/proc/iomem, and that file will not reflect the extent layout until the device is enabled.Cc Vishal Verma <[email protected]>Signed-off-by Dan Williams <[email protected]>--- drivers/dax/bus.c | 191 +++++++++++++++++++++++++++++++++++++++++++++ drivers/dax/dax-private.h | 14 +++ 2 files changed, 203 insertions(+), 2 deletions(-)drivers/dax/bus.c +25
-0@@ -579,6 +579,167 @@ struct dax_region *alloc_dax_region(struct device *parent, int region_id, }EXPORT_SYMBOL_GPL (alloc_dax_region); +static void dax_mapping_release (struct device *dev) +{ +struct dax_mapping *mapping =to_dax_mapping (dev); +struct dev_dax *dev_dax =to_dev_dax (dev->parent); + +ida_free (&dev_dax->ida, mapping->id); +kfree (mapping); +} + +static void unregister_dax_mapping (void *data) +{ +struct device *dev = data; +struct dax_mapping *mapping =to_dax_mapping (dev); +struct dev_dax *dev_dax =to_dev_dax (dev->parent); +struct dax_region *dax_region = dev_dax->region; + +dev_dbg (dev,"%s\n" , __func__); + +device_lock_assert (dax_region->dev); + + dev_dax->ranges[mapping->range_id].mapping =NULL ; + mapping->range_id =-1 ; + +device_del (dev); +put_device (dev);drivers/dax/bus.c struct dax_region *alloc_dax_region(struct device *parent, int region_id, · line 616
Quoted 10 lines
drivers/dax/bus.c +10
-0+} + +static struct dev_dax_range *get_dax_range (struct device *dev) +{ +struct dax_mapping *mapping =to_dax_mapping (dev); +struct dev_dax *dev_dax =to_dev_dax (dev->parent); +struct dax_region *dax_region = dev_dax->region; + +device_lock (dax_region->dev); +if (mapping->range_id <1 ) {^^^^^^^^^^^^^^^^^^^^^ it's 'mapping->range_id < 0'
Quoted 2 lines
Otherwise 'mapping0' sysfs entries won't work.
Disabled ranges use id -1.
Whoops, yes. Needs a unit test.
Re: [PATCH v2 22/22] device-dax: Introduce 'mapping' devices
Quoted 60 lines · Dan Williams
Quoted 59 lines · Joao Martins
Quoted 46 lines · Dan Williams
In support of interrogating the physical address layout of a device with dis-contiguous ranges, introduce a sysfs directory with 'start', 'end', and '
page_offset' attributes. The alternative is trying to parse/proc/iomem, and that file will not reflect the extent layout until the device is enabled.Cc Vishal Verma <[email protected]>Signed-off-by Dan Williams <[email protected]>--- drivers/dax/bus.c | 191 +++++++++++++++++++++++++++++++++++++++++++++ drivers/dax/dax-private.h | 14 +++ 2 files changed, 203 insertions(+), 2 deletions(-)drivers/dax/bus.c +25
-0@@ -579,6 +579,167 @@ struct dax_region *alloc_dax_region(struct device *parent, int region_id, }EXPORT_SYMBOL_GPL (alloc_dax_region); +static void dax_mapping_release (struct device *dev) +{ +struct dax_mapping *mapping =to_dax_mapping (dev); +struct dev_dax *dev_dax =to_dev_dax (dev->parent); + +ida_free (&dev_dax->ida, mapping->id); +kfree (mapping); +} + +static void unregister_dax_mapping (void *data) +{ +struct device *dev = data; +struct dax_mapping *mapping =to_dax_mapping (dev); +struct dev_dax *dev_dax =to_dev_dax (dev->parent); +struct dax_region *dax_region = dev_dax->region; + +dev_dbg (dev,"%s\n" , __func__); + +device_lock_assert (dax_region->dev); + + dev_dax->ranges[mapping->range_id].mapping =NULL ; + mapping->range_id =-1 ; + +device_del (dev); +put_device (dev);drivers/dax/bus.c struct dax_region *alloc_dax_region(struct device *parent, int region_id, · line 616
Quoted 10 lines
drivers/dax/bus.c +10
-0+} + +static struct dev_dax_range *get_dax_range (struct device *dev) +{ +struct dax_mapping *mapping =to_dax_mapping (dev); +struct dev_dax *dev_dax =to_dev_dax (dev->parent); +struct dax_region *dax_region = dev_dax->region; + +device_lock (dax_region->dev); +if (mapping->range_id <1 ) {^^^^^^^^^^^^^^^^^^^^^ it's 'mapping->range_id < 0'
Quoted 5 lines
Quoted 2 lines
Otherwise 'mapping0' sysfs entries won't work.
Disabled ranges use id -1.Whoops, yes. Needs a unit test.
If it helps, this particular patch for daxctl:
https://lore.kernel.org/linux-nvdimm/[email protected]/
May help in the immediate term: if it's broken no mappings are listed.
But yeah, a unit test in 'test/daxctl-create.sh' should be added.
Joao
cover device-dax: Further improvements to subdivision
In reply to Dan WilliamsHey,
Here's a small set of improvements that I was hoping you would consider as part of your Soft-Reserved series[0]; should you think they make sense. It does the following:
Patch 1-2: Add an align sysfs attribute, as opposed to being limited to 2M. This brings parity to static dax regions, which support 1G.
Patch 3. Add a module parameter to hmem, to initialize the region as idle with full available_size for child devices. When the region is gonna be partiotined by default and assigned to guests, doesn't help to initialize the region. Also if the majority of the region starts non-idle and it's a region which memmap is bigger than System-Ram, then there not be enough space for the device to be probed successfully.
Patch 4: Add an sysfs attribute for range allocation. It is a single entry where you pass a range <start>-<end> and where the ordering plus range length designate the page_offset. It is meant for recreate the same mappings after kexec (retaining the GPA->HPA association), but could also allow application to implement their own allocation strategy.
I will submit a separate daxctl counterpart shortly, to help visualize its use.
Joao
Joao Martins (4):
device-dax: Make align a per-device property
device-dax: Add an 'align' attribute dax/hmem: Introduce dax_hmem.region_idle parameter
device-dax: Add a range mapping allocation attribute
drivers/dax/bus.c | 166 +++++++++++++++++++++++++++++++++++--- drivers/dax/dax-private.h | 1 + drivers/dax/device.c | 35 ++++---- drivers/dax/hmem/hmem.c | 5 +- 4 files changed, 177 insertions(+), 30 deletions(-)
Signature · 1 line
2.17.1
PATCH 1/4 device-dax: Make align a per-device property
Introduce @align to struct dev_dax.
When creating a new device, we still initialize to the default dax_region @align. Child devices belonging to a region may wish to keep a different alignment property instead of a global region-defined one.
--- drivers/dax/bus.c | 1 + drivers/dax/dax-private.h | 1 + drivers/dax/device.c | 35 +++++++++++++++-------------------- 3 files changed, 17 insertions(+), 20 deletions(-)
drivers/dax/bus.c +1 -0
@@ -1215,6 +1215,7 @@ struct dev_dax *devm_create_dev_dax(struct dev_dax_data *data) dev_dax->dax_dev = dax_dev; dev_dax->target_node = dax_region->target_node; + dev_dax->align = dax_region->align;ida_init (&dev_dax->ida);kref_get (&dax_region->kref);
drivers/dax/dax-private.h +1 -0
@@ -62,6 +62,7 @@ struct dax_mapping {struct dev_dax {struct dax_region *region;struct dax_device *dax_dev; +unsigned int align;int target_node;int id;struct ida ida;
drivers/dax/device.c +15 -20
@@ -17,7 +17,6 @@static int check_vma (struct dev_dax *dev_dax,struct vm_area_struct *vma,const char *func) { -struct dax_region *dax_region = dev_dax->region;struct device *dev = &dev_dax->dev;unsigned long mask;
@@ -32,7 +31,7 @@ static int check_vma(struct dev_dax *dev_dax, struct vm_area_struct *vma,return -EINVAL ; } - mask = dax_region->align -1 ; + mask = dev_dax->align -1 ;if (vma->vm_start & mask || vma->vm_end & mask) { dev_info_ratelimited(dev, "%s: %s: fail, unaligned vma (%#lx - %#lx, %#lx)\n",
@@ -86,13 +85,13 @@ static vm_fault_t __dev_dax_pte_fault(struct dev_dax *dev_dax,return VM_FAULT_SIGBUS ; dax_region = dev_dax->region; -if (dax_region->align >PAGE_SIZE ) { +if (dev_dax->align >PAGE_SIZE ) {dev_dbg (dev,"alignment (%#x) > fault size (%#x)\n" , - dax_region->align, fault_size); + dev_dax->align, fault_size);return VM_FAULT_SIGBUS ; } -if (fault_size != dax_region->align) +if (fault_size != dev_dax->align)return VM_FAULT_SIGBUS ; phys =dax_pgoff_to_phys (dev_dax, vmf->pgoff,PAGE_SIZE );
@@ -120,15 +119,15 @@ static vm_fault_t __dev_dax_pmd_fault(struct dev_dax *dev_dax,return VM_FAULT_SIGBUS ; dax_region = dev_dax->region; -if (dax_region->align >PMD_SIZE ) { +if (dev_dax->align >PMD_SIZE ) {dev_dbg (dev,"alignment (%#x) > fault size (%#x)\n" , - dax_region->align, fault_size); + dev_dax->align, fault_size);return VM_FAULT_SIGBUS ; } -if (fault_size < dax_region->align) +if (fault_size < dev_dax->align)return VM_FAULT_SIGBUS ; -else if (fault_size > dax_region->align) +else if (fault_size > dev_dax->align)return VM_FAULT_FALLBACK ;/* if we are outside of the VMA */
@@ -164,15 +163,15 @@ static vm_fault_t __dev_dax_pud_fault(struct dev_dax *dev_dax,return VM_FAULT_SIGBUS ; dax_region = dev_dax->region; -if (dax_region->align >PUD_SIZE ) { +if (dev_dax->align >PUD_SIZE ) {dev_dbg (dev,"alignment (%#x) > fault size (%#x)\n" , - dax_region->align, fault_size); + dev_dax->align, fault_size);return VM_FAULT_SIGBUS ; } -if (fault_size < dax_region->align) +if (fault_size < dev_dax->align)return VM_FAULT_SIGBUS ; -else if (fault_size > dax_region->align) +else if (fault_size > dev_dax->align)return VM_FAULT_FALLBACK ;/* if we are outside of the VMA */
@@ -267,9 +266,8 @@ static int dev_dax_split(struct vm_area_struct *vma, unsigned long addr) {struct file *filp = vma->vm_file;struct dev_dax *dev_dax = filp->private_data; -struct dax_region *dax_region = dev_dax->region; -if (!IS_ALIGNED (addr, dax_region->align)) +if (!IS_ALIGNED (addr, dev_dax->align))return -EINVAL ;return 0 ; }
@@ -278,9 +276,8 @@ static unsigned long dev_dax_pagesize(struct vm_area_struct *vma) {struct file *filp = vma->vm_file;struct dev_dax *dev_dax = filp->private_data; -struct dax_region *dax_region = dev_dax->region; -return dax_region->align; +return dev_dax->align; }static const struct vm_operations_struct dax_vm_ops = {
@@ -319,13 +316,11 @@ static unsigned long dax_get_unmapped_area(struct file *filp, {unsigned long off, off_end, off_align, len_align, addr_align, align;struct dev_dax *dev_dax = filp ? filp->private_data :NULL ; -struct dax_region *dax_region;if (!dev_dax || addr) goto out; - dax_region = dev_dax->region; - align = dax_region->align; + align = dev_dax->align; off = pgoff <<PAGE_SHIFT ; off_end = off + len; off_align =round_up (off, align);
Signature · 1 line
2.17.1
PATCH 2/4 device-dax: Add an 'align' attribute
In reply to Joao MartinsIntroduce a device align attribute. While doing so, rename the region align attribute to be more explicitly named as so, but keep it named as @align to retain the API for tools like daxctl.
Changes on align may not always be valid, when say certain mappings were created with 2M and then we switch to 1G. So, we validate all ranges against the new value being attempted, post resizing.
--- drivers/dax/bus.c | 101 +++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 92 insertions(+), 9 deletions(-)
drivers/dax/bus.c +92 -9
@@ -230,14 +230,15 @@ static ssize_t region_size_show(struct device *dev,static struct device_attribute dev_attr_region_size =__ATTR (size,0444 , region_size_show,NULL ); -static ssize_t align_show (struct device *dev, +static ssize_t region_align_show (struct device *dev,struct device_attribute *attr,char *buf) {struct dax_region *dax_region =dev_get_drvdata (dev);return sprintf (buf,"%u\n" , dax_region->align); } -static DEVICE_ATTR_RO (align); +static struct device_attribute dev_attr_region_align = +__ATTR (align,0400 , region_align_show,NULL );#define for_each_dax_region_resource (dax_region, res) \ for (res = (dax_region)->res.child; res; res = res->sibling)
@@ -488,7 +489,7 @@ static umode_t dax_region_visible(struct kobject *kobj, struct attribute *a,static struct attribute *dax_region_attributes[] = { &dev_attr_available_size.attr, &dev_attr_region_size.attr, - &dev_attr_align.attr, + &dev_attr_region_align.attr, &dev_attr_create.attr, &dev_attr_seed.attr, &dev_attr_delete.attr,
@@ -855,14 +856,13 @@ static ssize_t size_show(struct device *dev,return sprintf (buf,"%llu\n" , size); } -static bool alloc_is_aligned (struct dax_region *dax_region, -resource_size_t size) +static bool alloc_is_aligned (resource_size_t size,unsigned long align) {/* * The minimum mapping granularity for a device instance is a * single subsection, unless the arch says otherwise. */ - return IS_ALIGNED(size, max_t(unsigned long, dax_region->align, + return IS_ALIGNED(size, max_t(unsigned long, align,memremap_compat_align ())); }
@@ -958,7 +958,7 @@ static ssize_t dev_dax_resize(struct dax_region *dax_region,return dev_dax_shrink (dev_dax, size); to_alloc = size - dev_size; -if (dev_WARN_ONCE (dev, !alloc_is_aligned (dax_region, to_alloc), +if (dev_WARN_ONCE (dev, !alloc_is_aligned (to_alloc, dev_dax->align),"resize of %pa misaligned\n" , &to_alloc))return -ENXIO ;
@@ -1022,7 +1022,7 @@ static ssize_t size_store(struct device *dev, struct device_attribute *attr,if (rc)return rc; -if (!alloc_is_aligned (dax_region, val)) { +if (!alloc_is_aligned (val, dev_dax->align)) {dev_dbg (dev,"%s: size: %lld misaligned\n" , __func__, val);return -EINVAL ; }
@@ -1041,6 +1041,87 @@ static ssize_t size_store(struct device *dev, struct device_attribute *attr, }static DEVICE_ATTR_RW (size); +static ssize_t align_show (struct device *dev, +struct device_attribute *attr,char *buf) +{ +struct dev_dax *dev_dax =to_dev_dax (dev); + +return sprintf (buf,"%d\n" , dev_dax->align); +} + +static ssize_t dev_dax_set_align (struct dev_dax *dev_dax, +unsigned long long align) +{ +resource_size_t dev_size =dev_dax_size (dev_dax); +struct device *dev = &dev_dax->dev; +ssize_t rc, i; + +if (dev->driver) +return -EBUSY ; + + rc = -EINVAL ; +if (dev_size >0 && !alloc_is_aligned (dev_size, align)) { +dev_dbg (dev,"%s: align %llx invalid for size %llu\n" , + __func__, align, dev_size); +return rc; + } + +for (i =0 ; i < dev_dax->nr_range; i++) { +size_t len =range_len (&dev_dax->ranges[i].range); + +if (!alloc_is_aligned (len, align)) { +dev_dbg (dev,"%s: align %llx invalid for range %ld\n" , + __func__, align, i); +return rc; + } + } + +switch (align) { +case PUD_SIZE : +if (!IS_ENABLED (CONFIG_HAVE_ARCH_TRANSPARENT_HUGEPAGE_PUD )) +break ; + fallthrough; +case PMD_SIZE : +if (!has_transparent_hugepage ()) +break ; + fallthrough; +case PAGE_SIZE : + rc =0 ; +break ; + } + +if (!rc) + dev_dax->align = align; + +return rc; +} + +static ssize_t align_store (struct device *dev, +struct device_attribute *attr,const char *buf,size_t len) +{ +struct dev_dax *dev_dax =to_dev_dax (dev); +struct dax_region *dax_region = dev_dax->region; +unsigned long long val; +ssize_t rc; + + rc =kstrtoull (buf,0 , &val); +if (rc) +return -ENXIO ; + +device_lock (dax_region->dev); +if (!dax_region->dev->driver) { +device_unlock (dax_region->dev); +return -ENXIO ; + } + +device_lock (dev); + rc =dev_dax_set_align (dev_dax, val); +device_unlock (dev); +device_unlock (dax_region->dev); +return rc ==0 ? len : rc; +} +static DEVICE_ATTR_RW (align); +static int dev_dax_target_node (struct dev_dax *dev_dax) {struct dax_region *dax_region = dev_dax->region;
@@ -1101,7 +1182,8 @@ static umode_t dev_dax_visible(struct kobject *kobj, struct attribute *a, int n)return 0 ;if (a == &dev_attr_numa_node.attr && !IS_ENABLED (CONFIG_NUMA ))return 0 ; -if (a == &dev_attr_size.attr &&is_static (dax_region)) +if ((a == &dev_attr_align.attr || + a == &dev_attr_size.attr) &&is_static (dax_region))return 0444 ;return a->mode; }
@@ -1110,6 +1192,7 @@ static struct attribute *dev_dax_attributes[] = { &dev_attr_modalias.attr, &dev_attr_size.attr, &dev_attr_target_node.attr, + &dev_attr_align.attr, &dev_attr_resource.attr, &dev_attr_numa_node.attr, NULL,
Signature · 4 lines
2.17.1 _______________________________________________ Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
Re: [PATCH v1 2/4] device-dax: Add an 'align' attribute
Quoted 48 lines · Joao Martins
Introduce a device align attribute. While doing so, rename the region align attribute to be more explicitly named as so, but keep it named as @align to retain the API for tools like daxctl.
Changes on align may not always be valid, when say certain mappings were created with 2M and then we switch to 1G. So, we validate all ranges against the new value being attempted, post resizing.
Signed-off-by Joao Martins <[email protected]>--- drivers/dax/bus.c | 101 +++++++++++++++++++++++++++++++++++++++++----- 1 file changed, 92 insertions(+), 9 deletions(-)drivers/dax/bus.c +4
-3@@ -230,14 +230,15 @@ static ssize_t region_size_show(struct device *dev,static struct device_attribute dev_attr_region_size =__ATTR (size,0444 , region_size_show,NULL ); -static ssize_t align_show (struct device *dev, +static ssize_t region_align_show (struct device *dev,struct device_attribute *attr,char *buf) {struct dax_region *dax_region =dev_get_drvdata (dev);return sprintf (buf,"%u\n" , dax_region->align); } -static DEVICE_ATTR_RO (align); +static struct device_attribute dev_attr_region_align = +__ATTR (align,0400 , region_align_show,NULL );#define for_each_dax_region_resource (dax_region, res) \ for (res = (dax_region)->res.child; res; res = res->sibling)@@ -488,7 +489,7 @@ static umode_t dax_region_visible(struct kobject *kobj, struct attribute *a,static struct attribute *dax_region_attributes[] = { &dev_attr_available_size.attr, &dev_attr_region_size.attr, - &dev_attr_align.attr, + &dev_attr_region_align.attr, &dev_attr_create.attr, &dev_attr_seed.attr, &dev_attr_delete.attr,
drivers/dax/bus.c static ssize_t size_show(struct device *dev, · line 859
Quoted 6 lines
drivers/dax/bus.c +1
-2@@ -855,14 +856,13 @@ static ssize_t size_show(struct device *dev,return sprintf (buf,"%llu\n" , size); } -static bool alloc_is_aligned (struct dax_region *dax_region, -resource_size_t size) +static bool alloc_is_aligned (resource_size_t size,unsigned long align)
For type safety, let's make this take @dev_dax as a parameter. For the dev_dax_set_align() case I think it is ok to provisionally adjust dev_dax->align under the lock before entry and revert to the old alignment on failure.
I can fix that up locally on applying.
PATCH 3/4 dax/hmem: Introduce dax_hmem.region_idle parameter
In reply to Joao MartinsIntroduce a new module parameter for dax_hmem which initializes all region devices as free, rather than allocating a pagemap for the region by default.
All hmem devices created with dax_hmem.region_idle=1 will have full available size for creating dynamic dax devices.
--- drivers/dax/hmem/hmem.c | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
drivers/dax/hmem/hmem.c +4 -1
@@ -5,6 +5,9 @@#include <linux/pfn_t.h> #include "../bus.h" +static bool region_idle; +module_param_named (region_idle, region_idle, bool,0644 ); +static int dax_hmem_probe (struct platform_device *pdev) {struct device *dev = &pdev->dev;
@@ -30,7 +33,7 @@ static int dax_hmem_probe(struct platform_device *pdev) data = (struct dev_dax_data ) { .dax_region = dax_region, .id =-1 , - .size =resource_size (res), + .size = region_idle ?0 :resource_size (res), }; dev_dax =devm_create_dev_dax (&data);if (IS_ERR (dev_dax))
Signature · 4 lines
2.17.1 _______________________________________________ Linux-nvdimm mailing list -- [email protected] To unsubscribe send an email to [email protected]
PATCH 4/4 device-dax: Add a range mapping allocation attribute
In reply to Joao MartinsAdd a sysfs attribute which denotes a range from the dax region to be allocated. It's an write only @mapping sysfs attribute in the format of '<start>-<end>' to allocate a range. @start and @end use hexadecimal values and the @pgoff is implicitly ordered wrt to previous writes to @mapping sysfs e.g. a write of a range of length 1G the pgoff is 0..1G(-4K), a second write will use @pgoff for 1G+4K..<size>.
This range mapping interface is useful for:
1) Application which want to implement its own allocation logic, and thus pick the desired ranges from dax_region.
2) For use cases like VMM fast restart[0] where after kexec we want to the same gpa<->phys mappings (as originally created before kexec).
[0] https://static.sched.com/hosted_files/kvmforum2019/66/VMM-fast-restart_kvmforum2019.pdf
--- drivers/dax/bus.c | 64 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 64 insertions(+)
drivers/dax/bus.c +64 -0
@@ -1041,6 +1041,67 @@ static ssize_t size_store(struct device *dev, struct device_attribute *attr, }static DEVICE_ATTR_RW (size); +static ssize_t range_parse (const char *opt,size_t len,struct range *range) +{ +unsigned long long addr =0 ; +char *start, *end, *str; +ssize_t rc =EINVAL ; + + str =kstrdup (opt,GFP_KERNEL ); +if (!str) +return rc; + + end = str; + start =strsep (&end,"-" ); +if (!start || !end) + goto err; + + rc =kstrtoull (start,16 , &addr); +if (rc) + goto err; + range->start = addr; + + rc =kstrtoull (end,16 , &addr); +if (rc) + goto err; + range->end = addr; + +err: +kfree (str); +return rc; +} + +static ssize_t mapping_store (struct device *dev,struct device_attribute *attr, +const char *buf,size_t len) +{ +struct dev_dax *dev_dax =to_dev_dax (dev); +struct dax_region *dax_region = dev_dax->region; +size_t to_alloc; +struct range r; +ssize_t rc; + + rc =range_parse (buf, len, &r); +if (rc) +return rc; + + rc = -ENXIO ; +device_lock (dax_region->dev); +if (!dax_region->dev->driver) { +device_unlock (dax_region->dev); +return rc; + } +device_lock (dev); + + to_alloc =range_len (&r); +if (alloc_is_aligned (to_alloc, dev_dax->align)) + rc =alloc_dev_dax_range (dev_dax, r.start, to_alloc); +device_unlock (dev); +device_unlock (dax_region->dev); + +return rc ==0 ? len : rc; +} +static DEVICE_ATTR_WO (mapping); +static ssize_t align_show (struct device *dev,struct device_attribute *attr,char *buf) {
@@ -1182,6 +1243,8 @@ static umode_t dev_dax_visible(struct kobject *kobj, struct attribute *a, int n)return 0 ;if (a == &dev_attr_numa_node.attr && !IS_ENABLED (CONFIG_NUMA ))return 0 ; +if (a == &dev_attr_mapping.attr &&is_static (dax_region)) +return 0 ;if ((a == &dev_attr_align.attr || a == &dev_attr_size.attr) &&is_static (dax_region))return 0444 ;
@@ -1191,6 +1254,7 @@ static umode_t dev_dax_visible(struct kobject *kobj, struct attribute *a, int n)static struct attribute *dev_dax_attributes[] = { &dev_attr_modalias.attr, &dev_attr_size.attr, + &dev_attr_mapping.attr, &dev_attr_target_node.attr, &dev_attr_align.attr, &dev_attr_resource.attr,
Signature · 1 line
2.17.1