riscv: Memory Hot(Un)Plug support
Subsystems (4)
v3 cover riscv: Memory Hot(Un)Plug support
From: Björn Töpel <[email protected]>
================================================================
Memory Hot(Un)Plug support (and ZONE_DEVICE) for the RISC-V port
================================================================
Introduction
============
To quote "Documentation/admin-guide/mm/memory-hotplug.rst": "Memory hot(un)plug allows for increasing and decreasing the size of physical memory available to a machine at runtime."
This series adds memory hot(un)plugging, and ZONE_DEVICE support for the RISC-V Linux port.
MM configuration
================
RISC-V MM has the following configuration:
* Memory blocks are 128M, analogous to x86-64. It uses PMD ("hugepage") vmemmaps. From that follows that 2M (PMD) worth of vmemmap spans 32768 pages á 4K which gets us 128M.
* The pageblock size is the minimum minimum virtio_mem size, and on RISC-V it's 2M (2^9 * 4K).
Implementation
==============
The PGD table on RISC-V is shared/copied between for all processes. To avoid doing page table synchronization, the first patch (patch 1) pre-allocated the PGD entries for vmemmap/direct map. By doing that the init_mm PGD will be fixed at kernel init, and synchronization can be avoided all together.
The following two patches (patch 2-3) does some preparations, followed by the actual MHP implementation (patch 4-5). Then, MHP and virtio-mem are enabled (patch 6-7), and finally ZONE_DEVICE support is added (patch 8).
MHP and locking
===============
TL;DR: The MHP does not step on any toes, except for ptdump. Additional locking is required for ptdump.
Long version: For v2 I spent some time digging into init_mm synchronization/update. Here are my findings, and I'd love them to be corrected if incorrect.
It's been a gnarly path...
The init_mm structure is a special mm (perhaps not a "real" one). It's a "lazy context" that tracks kernel page table resources, e.g., the kernel page table (swapper_pg_dir), a kernel page_table_lock (more about the usage below), mmap_lock, and such.
init_mm does not track/contain any VMAs. Having the init_mm is convenient, so that the regular kernel page table walk/modify functions can be used.
Now, init_mm being special means that the locking for kernel page tables are special as well.
On RISC-V the PGD (top-level page table structure), similar to x86, is shared (copied) with user processes. If the kernel PGD is modified, it has to be synched to user-mode processes PGDs. This is avoided by pre-populating the PGD, so it'll be fixed from boot.
The in-kernel pgd regions are documented inDocumentation/arch/riscv/vm-layout.rst.
The distinct regions are:
* vmemmap
* vmalloc/ioremap space
* direct mapping of all physical memory
* kasan
* modules, BPF
* kernel
Memory hotplug is the process of adding/removing memory to/from the kernel.
Adding is done in two phases:
1. Add the memory to the kernel
2. Online memory, making it available to the page allocator.
Step 1 is partially architecture dependent, and updates the init_mm page table:
* Update the direct map page tables. The direct map is a linear map, representing all physical memory: virt = phys + PAGE_OFFSET
* Add a struct page for each added page of memory. Update the vmemmap (virtual mapping to the struct page, so we can easily transform a kernel virtual address to a struct page * address.
From an MHP perspective, there are two regions of the PGD that are updated:
* vmemmap
* direct mapping of all physical memory
The struct mm_struct has a couple of locks in play:
* spinlock_t page_table_lock protects the page table, and some counters
* struct rw_semaphore mmap_lock protect an mm's VMAs
Note again that init_mm does not contain any VMAs, but still uses the mmap_lock in some places.
The page_table_lock was originally used to to protect all pages tables, but more recently a split page table lock has been introduced. The split lock has a per-table lock for the PTE and PMD tables. If split lock is disabled, all tables are guarded by mm->page_table_lock (for user processes). Split page table locks are not used for init_mm.
MHP operations is typically synchronized usingDEFINE_STATIC_PERCPU_RWSEM(mem_hotplug_lock).
Actors
------
The following non-MHP actors in the kernel traverses (read), and/or modifies the kernel PGD.
* ptdump
Walks the entire init_mm, via ptdump_walk_pgd() with the mmap_write_lock(init_mm) taken.
Observation: ptdump can race with MHP, and needs additional locking to avoid crashes/races.
* set_direct_* / arch/riscv/mm/pageattr.c
The set_direct_* functionality is used to "synchronize" the direct map to other kernel mappings, e.g. modules/kernel text. The direct map is using "as large huge table mappings as possible", which means that the set_direct_* might need to split the direct map.
The set_direct_* functions operates with the
mmap_write_lock(init_mm) taken.
Observation: set_direct_* uses the direct map, but will never modify the same entry as MHP. If there is a mapping, that entry will never race with MHP. Further, MHP acts when memory is offline.
* HVO / mm/hugetlb_vmemmap
HVO optimizes the backing struct page for hugetlb pages, which means changing the "vmemmap" region. HVO can split (merge?) a vmemmap pmd. However, it will never race with MHP, since HVO only operates at online memory. HVO cannot touch memory being MHP added or removed.
* apply_to_page_range
Walks a range, creates pages and applies a callback (setting permissions) for the page.
When creating a table, it might use int __pte_alloc_kernel(pmd_t *pmd) which takes the init_mm.page_table_lock to synchronize pmd populate.
Used by: mm/vmalloc.c and mm/kasan/shadow.c. The KASAN callback takes the init_mm.page_table_lock to synchronize pte creation.
Observations: apply_to_page_range applies to the "vmalloc/ioremap space" region, and "kasan" region. *Not* affected by MHP.
* apply_to_existing_page_range
Walks a range, applies a callback (setting permissions) for the page (no page creation).
Used by: kernel/bpf/arena.c and mm/kasan/shadow.c. The KASAN callback takes the init_mm.page_table_lock to synchronize pte creation. *Not* affected by MHP regions.
* apply_to_existing_page_range applies to the "vmalloc/ioremap space" region, and "kasan" region. *Not* affected by MHP regions.
* ioremap_page_range and vmap_page_range
Uses the same internal function, and might create table entries at the "vmalloc/ioremap space" region. Can call __pte_alloc_kernel() which takes the init_mm.page_table_lock synchronizing pmd populate in the region. *Not* affected by MHP regions.
Summary:
* MHP add will never modify the same page table entries, as any of the other actors.
* MHP remove is done when memory is offlined, and will not clash with any of the actors.
* Functions that walk the entire kernel page table need synchronization
* It's sufficient to add the MHP lock ptdump.
Testing
=======
This series adds basic DT supported hotplugging. There is a QEMU series enabling MHP for the RISC-V "virt" machine here: [1]
ACPI/MSI support is still in the making for RISC-V, and prior proper (ACPI) PCI MSI support lands [2] and NUMA SRAT support [3], it hard to try it out.
I've prepared a QEMU branch with proper ACPI GED/PC-DIMM support [4], and a this series with the required prerequisites [5] (AIA, ACPI AIA MADT, ACPI NUMA SRAT).
To test with virtio-mem, e.g.:
| qemu-system-riscv64 \ | -machine virt,aia=aplic-imsic \ | -cpu rv64,v=true,vlen=256,elen=64,h=true,zbkb=on,zbkc=on,zbkx=on,zkr=on,zkt=on,svinval=on,svnapot=on,svpbmt=on \ | -nodefaults \ | -nographic -smp 8 -kernel rv64-u-boot.bin \ | -drive file=rootfs.img,format=raw,if=virtio \ | -device virtio-rng-pci \ | -m 16G,slots=3,maxmem=32G \ | -object memory-backend-ram,id=mem0,size=16G \ | -numa node,nodeid=0,memdev=mem0 \ | -serial chardev:char0 \ | -mon chardev=char0,mode=readline \ | -chardev stdio,mux=on,id=char0 \ | -device pci-serial,id=serial0,chardev=char0 \ | -object memory-backend-ram,id=vmem0,size=2G \ | -device virtio-mem-pci,id=vm0,memdev=vmem0,node=0
where "rv64-u-boot.bin" is U-boot with EFI/ACPI-support (use [6] if you're lazy).
In the QEMU monitor:
| (qemu) info memory-devices
| (qemu) qom-set vm0 requested-size 1G
...to test DAX/KMEM, use the follow QEMU parameters:
| -object memory-backend-file,id=mem1,share=on,mem-path=virtio_pmem.img,size=4G \ | -device virtio-pmem-pci,memdev=mem1,id=nv1
and the regular ndctl/daxctl dance.
If you're brave to try the ACPI branch, add "acpi=on" to "-machine virt", and test PC-DIMM MHP (in addition to virtio-{p},mem):
In the QEMU monitor:
| (qemu) object_add memory-backend-ram,id=mem1,size=1G | (qemu) device_add pc-dimm,id=dimm1,memdev=mem1
You can also try hot-remove with some QEMU options, say:
| -object memory-backend-file,id=mem-1,size=256M,mem-path=/pagesize-2MB | -device pc-dimm,id=mem1,memdev=mem-1 | -object memory-backend-file,id=mem-2,size=1G,mem-path=/pagesize-1GB | -device pc-dimm,id=mem2,memdev=mem-2 | -object memory-backend-file,id=mem-3,size=256M,mem-path=/pagesize-2MB | -device pc-dimm,id=mem3,memdev=mem-3
Remove "acpi=on" to run with DT.
Thanks to Alex, Andrew, David, and Oscar for all
comments/tests/fixups.
Changelog
=========
v2->v3:
Collect tags 0001-riscv-mm-Properly-forward-vmemmap_populate-altmap
* New patch, split from attribute change (Alex, Oscar)
0005-riscv-mm-Add-memory-hotplugging-support
* Fix page table free to take PG_reserved into consideration (David, Oscar)
* Depend on SPARSE_VMEMMAP (Alex, David, Oscar)
* Proper TLB flushing (Alex)
0009-riscv-mm-Add-support-for-ZONE_DEVICE
* Fixed 32b build
v1->v2:
Reviewed a lot of MHP locking scenarios
Various config build issues (e.g. build !CONFIG_MEMORY_HOTPLUG) (Andrew) Added arch_get_mappable_range() implementation
Acquire MHP lock for ptdump, analogous to arm64
ACPI MHP tests
Add ZONE_DEVICE patch
References
==========
[1] https://lore.kernel.org/qemu-devel/[email protected]/
[2] https://lore.kernel.org/linux-riscv/[email protected]/
[3] https://lore.kernel.org/linux-riscv/[email protected]/
[4] https://github.com/bjoto/qemu/commits/virtio-mem-pc-dimm-mhp-acpi-v2/
[5] https://github.com/bjoto/linux/commits/mhp-v3-next-acpi
[6] https://github.com/bjoto/riscv-rootfs-utils/tree/acpi
Thanks,
Björn
Björn Töpel (9):
riscv: mm: Properly forward vmemmap_populate() altmap parameter
riscv: mm: Pre-allocate vmemmap/direct map PGD entries
riscv: mm: Change attribute from __init to __meminit for page
functions
riscv: mm: Refactor create_linear_mapping_range() for memory hot add
riscv: mm: Add memory hotplugging support
riscv: mm: Take memory hotplug read-lock during kernel page table dump
riscv: Enable memory hotplugging for RISC-V
virtio-mem: Enable virtio-mem for RISC-V
riscv: mm: Add support for ZONE_DEVICE
arch/riscv/Kconfig | 3 + arch/riscv/include/asm/kasan.h | 4 +- arch/riscv/include/asm/mmu.h | 4 +- arch/riscv/include/asm/pgtable-64.h | 20 ++ arch/riscv/include/asm/pgtable-bits.h | 1 + arch/riscv/include/asm/pgtable.h | 19 +- arch/riscv/mm/init.c | 339 +++++++++++++++++++++++--- arch/riscv/mm/ptdump.c | 3 + drivers/virtio/Kconfig | 2 +- 9 files changed, 349 insertions(+), 46 deletions(-)
base-commit: 92cce91949a497a8a4615f9ba5813b03f7a1f1d5
Signature · 1 line
2.40.1
PATCH v3 1/9 riscv: mm: Properly forward vmemmap_populate() altmap parameter
From: Björn Töpel <[email protected]>
Make sure that the altmap parameter is properly passed on to vmemmap_populate_hugepages().
--- arch/riscv/mm/init.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/riscv/mm/init.c +1 -1
@@ -1434,7 +1434,7 @@ int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node,* memory hotplug, we are not able to update all the page tables with * the new PMDs. */ - return vmemmap_populate_hugepages(start, end, node, NULL); + return vmemmap_populate_hugepages(start, end, node, altmap); }#endif
Signature · 1 line
2.40.1
PATCH v3 2/9 riscv: mm: Pre-allocate vmemmap/direct map PGD entries
In reply to Björn TöpelFrom: Björn Töpel <[email protected]>
The RISC-V port copies the PGD table from init_mm/swapper_pg_dir to all userland page tables, which means that if the PGD level table is changed, other page tables has to be updated as well.
Instead of having the PGD changes ripple out to all tables, the synchronization can be avoided by pre-allocating the PGD entries/pages at boot, avoiding the synchronization all together.
This is currently done for the bpf/modules, and vmalloc PGD regions. Extend this scheme for the PGD regions touched by memory hotplugging.
Prepare the RISC-V port for memory hotplug by pre-allocate vmemmap/direct map entries at the PGD level. This will roughly waste ~128 worth of 4K pages when memory hotplugging is enabled in the kernel configuration.
--- arch/riscv/include/asm/kasan.h | 4 ++-- arch/riscv/mm/init.c | 7 +++++++ 2 files changed, 9 insertions(+), 2 deletions(-)
arch/riscv/include/asm/kasan.h +2 -2
@@ -6,8 +6,6 @@#ifndef __ASSEMBLY__ -#ifdef CONFIG_KASAN -/* * The following comment was copied from arm64: * KASAN_SHADOW_START: beginning of the kernel virtual addresses.
@@ -34,6 +32,8 @@*/ #define KASAN_SHADOW_START ((KASAN_SHADOW_END - KASAN_SHADOW_SIZE) & PGDIR_MASK)#define KASAN_SHADOW_END MODULES_LOWEST_VADDR + +#ifdef CONFIG_KASAN #define KASAN_SHADOW_OFFSET _AC(CONFIG_KASAN_SHADOW_OFFSET, UL)void kasan_init (void );
arch/riscv/mm/init.c +7 -0
@@ -27,6 +27,7 @@#include <asm/fixmap.h> #include <asm/io.h> +#include <asm/kasan.h> #include <asm/numa.h> #include <asm/pgtable.h> #include <asm/sections.h>
@@ -1488,10 +1489,16 @@ static void __init preallocate_pgd_pages_range(unsigned long start, unsigned lon panic("Failed to pre-allocate %s pages for %s area\n", lvl, area); } +#define PAGE_END KASAN_SHADOW_START +void __init pgtable_cache_init (void ) {preallocate_pgd_pages_range (VMALLOC_START ,VMALLOC_END ,"vmalloc" );if (IS_ENABLED (CONFIG_MODULES ))preallocate_pgd_pages_range (MODULES_VADDR ,MODULES_END ,"bpf/modules" ); +if (IS_ENABLED (CONFIG_MEMORY_HOTPLUG )) { +preallocate_pgd_pages_range (VMEMMAP_START ,VMEMMAP_END ,"vmemmap" ); +preallocate_pgd_pages_range (PAGE_OFFSET ,PAGE_END ,"direct map" ); + } }#endif
Signature · 1 line
2.40.1
PATCH v3 3/9 riscv: mm: Change attribute from __init to __meminit for page functions
In reply to Björn TöpelFrom: Björn Töpel <[email protected]>
Prepare for memory hotplugging support by changing from __init to __meminit for the page table functions that are used by the upcoming architecture specific callbacks.
Changing the __init attribute to __meminit, avoids that the functions are removed after init. The __meminit attribute makes sure the functions are kept in the kernel text post init, but only if memory hotplugging is enabled for the build.
--- arch/riscv/include/asm/mmu.h | 4 +-- arch/riscv/include/asm/pgtable.h | 2 +- arch/riscv/mm/init.c | 56 ++++++++++++++------------------ 3 files changed, 28 insertions(+), 34 deletions(-)
arch/riscv/include/asm/mmu.h +2 -2
@@ -31,8 +31,8 @@ typedef struct {#define cntx2asid (cntx) ((cntx) & SATP_ASID_MASK)#define cntx2version (cntx) ((cntx) & ~SATP_ASID_MASK) -void __init create_pgd_mapping (pgd_t *pgdp,uintptr_t va,phys_addr_t pa, -phys_addr_t sz,pgprot_t prot); +void __meminit create_pgd_mapping (pgd_t *pgdp,uintptr_t va,phys_addr_t pa,phys_addr_t sz, +pgprot_t prot);#endif /* __ASSEMBLY__ */ #endif /* _ASM_RISCV_MMU_H */
arch/riscv/include/asm/pgtable.h +1 -1
@@ -162,7 +162,7 @@ struct pt_alloc_ops {#endif }; -extern struct pt_alloc_ops pt_ops__initdata ; +extern struct pt_alloc_ops pt_ops__meminitdata ;#ifdef CONFIG_MMU /* Number of PGD entries that a user-mode program can use */
arch/riscv/mm/init.c +25 -31
164 lines not on this page · raw message
Signature · 1 line
2.40.1
PATCH v3 4/9 riscv: mm: Refactor create_linear_mapping_range() for memory hot add
In reply to Björn TöpelFrom: Björn Töpel <[email protected]>
Add a parameter to the direct map setup function, so it can be used in arch_add_memory() later.
--- arch/riscv/mm/init.c | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-)
arch/riscv/mm/init.c +6 -9
@@ -1227,7 +1227,7 @@ asmlinkage void __init setup_vm(uintptr_t dtb_pa) }static void __meminit create_linear_mapping_range (phys_addr_t start,phys_addr_t end, -uintptr_t fixed_map_size) +uintptr_t fixed_map_size,const pgprot_t *pgprot) {phys_addr_t pa;uintptr_t va, map_size;
@@ -1238,7 +1238,7 @@ static void __meminit create_linear_mapping_range(phys_addr_t start, phys_addr_tbest_map_size (pa, va, end - pa);create_pgd_mapping (swapper_pg_dir, va, pa, map_size, -pgprot_from_va (va)); + pgprot ? *pgprot :pgprot_from_va (va)); } }
@@ -1282,22 +1282,19 @@ static void __init create_linear_mapping_page_table(void)if (end >=__pa (PAGE_OFFSET ) + memory_limit) end =__pa (PAGE_OFFSET ) + memory_limit; -create_linear_mapping_range (start, end,0 ); +create_linear_mapping_range (start, end,0 ,NULL ); }#ifdef CONFIG_STRICT_KERNEL_RWX -create_linear_mapping_range (ktext_start, ktext_start + ktext_size,0 ); -create_linear_mapping_range (krodata_start, - krodata_start + krodata_size,0 ); +create_linear_mapping_range (ktext_start, ktext_start + ktext_size,0 ,NULL ); +create_linear_mapping_range (krodata_start, krodata_start + krodata_size,0 ,NULL );memblock_clear_nomap (ktext_start, ktext_size);memblock_clear_nomap (krodata_start, krodata_size);#endif #ifdef CONFIG_KFENCE -create_linear_mapping_range (kfence_pool, - kfence_pool +KFENCE_POOL_SIZE , -PAGE_SIZE ); +create_linear_mapping_range (kfence_pool, kfence_pool +KFENCE_POOL_SIZE ,PAGE_SIZE ,NULL );memblock_clear_nomap (kfence_pool,KFENCE_POOL_SIZE );#endif
Signature · 1 line
2.40.1
PATCH v3 5/9 riscv: mm: Add memory hotplugging support
In reply to Björn TöpelFrom: Björn Töpel <[email protected]>
For an architecture to support memory hotplugging, a couple of callbacks needs to be implemented:
arch_add_memory()
This callback is responsible for adding the physical memory into the direct map, and call into the memory hotplugging generic code via __add_pages() that adds the corresponding struct page entries, and updates the vmemmap mapping.
arch_remove_memory()
This is the inverse of the callback above.
vmemmap_free()
This function tears down the vmemmap mappings (if CONFIG_SPARSEMEM_VMEMMAP is enabled), and also deallocates the backing vmemmap pages. Note that for persistent memory, an alternative allocator for the backing pages can be used; The vmem_altmap. This means that when the backing pages are cleared, extra care is needed so that the correct deallocation method is used.
arch_get_mappable_range()
This functions returns the PA range that the direct map can map. Used by the MHP internals for sanity checks.
The page table unmap/teardown functions are heavily based on code from the x86 tree. The same remove_pgd_mapping() function is used in both vmemmap_free() and arch_remove_memory(), but in the latter function the backing pages are not removed.
--- arch/riscv/mm/init.c | 261 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 261 insertions(+)
arch/riscv/mm/init.c +261 -0
@@ -1493,3 +1493,264 @@ void __init pgtable_cache_init(void) } }#endif + +#ifdef CONFIG_MEMORY_HOTPLUG +static void __meminit free_pagetable (struct page *page,int order) +{ +unsigned int nr_pages =1 << order; + +/* +* vmemmap/direct page tables can be reserved, if added at +* boot. +*/ +if (PageReserved (page)) { +__ClearPageReserved (page); +while (nr_pages--) +free_reserved_page (page++); +return ; + } + +free_pages ((unsigned long )page_address (page), order); +} + +static void __meminit free_pte_table (pte_t *pte_start,pmd_t *pmd) +{ +pte_t *pte; +int i; + +for (i =0 ; i <PTRS_PER_PTE ; i++) { + pte = pte_start + i; +if (!pte_none (*pte)) +return ; + } + +free_pagetable (pmd_page (*pmd),0 ); +pmd_clear (pmd); +} + +static void __meminit free_pmd_table (pmd_t *pmd_start,pud_t *pud) +{ +pmd_t *pmd; +int i; + +for (i =0 ; i <PTRS_PER_PMD ; i++) { + pmd = pmd_start + i; +if (!pmd_none (*pmd)) +return ; + } + +free_pagetable (pud_page (*pud),0 ); +pud_clear (pud); +} + +static void __meminit free_pud_table (pud_t *pud_start,p4d_t *p4d) +{ +pud_t *pud; +int i; + +for (i =0 ; i <PTRS_PER_PUD ; i++) { + pud = pud_start + i; +if (!pud_none (*pud)) +return ; + } + +free_pagetable (p4d_page (*p4d),0 ); +p4d_clear (p4d); +} + +static void __meminit free_vmemmap_storage (struct page *page,size_t size, +struct vmem_altmap *altmap) +{ +if (altmap) +vmem_altmap_free (altmap, size >>PAGE_SHIFT ); +else +free_pagetable (page,get_order (size)); +} + +static void __meminit remove_pte_mapping (pte_t *pte_base,unsigned long addr,unsigned long end, +bool is_vmemmap,struct vmem_altmap *altmap) +{ +unsigned long next; +pte_t *ptep, pte; + +for (; addr < end; addr = next) { + next = (addr +PAGE_SIZE ) &PAGE_MASK ; +if (next > end) + next = end; + + ptep = pte_base +pte_index (addr); + pte =READ_ONCE (*ptep); + +if (!pte_present (*ptep)) +continue ; + +pte_clear (&init_mm, addr, ptep); +if (is_vmemmap) +free_vmemmap_storage (pte_page (pte),PAGE_SIZE , altmap); + } +} + +static void __meminit remove_pmd_mapping (pmd_t *pmd_base,unsigned long addr,unsigned long end, +bool is_vmemmap,struct vmem_altmap *altmap) +{ +unsigned long next; +pte_t *pte_base; +pmd_t *pmdp, pmd; + +for (; addr < end; addr = next) { + next =pmd_addr_end (addr, end); + pmdp = pmd_base +pmd_index (addr); + pmd =READ_ONCE (*pmdp); + +if (!pmd_present (pmd)) +continue ; + +if (pmd_leaf (pmd)) { +pmd_clear (pmdp); +if (is_vmemmap) +free_vmemmap_storage (pmd_page (pmd),PMD_SIZE , altmap); +continue ; + } + + pte_base = (pte_t *)pmd_page_vaddr (*pmdp); +remove_pte_mapping (pte_base, addr, next, is_vmemmap, altmap); +free_pte_table (pte_base, pmdp); + } +} + +static void __meminit remove_pud_mapping (pud_t *pud_base,unsigned long addr,unsigned long end, +bool is_vmemmap,struct vmem_altmap *altmap) +{ +unsigned long next; +pud_t *pudp, pud; +pmd_t *pmd_base; + +for (; addr < end; addr = next) { + next =pud_addr_end (addr, end); + pudp = pud_base +pud_index (addr); + pud =READ_ONCE (*pudp); + +if (!pud_present (pud)) +continue ; + +if (pud_leaf (pud)) { +if (pgtable_l4_enabled) { +pud_clear (pudp); +if (is_vmemmap) +free_vmemmap_storage (pud_page (pud),PUD_SIZE , altmap); + } +continue ; + } + + pmd_base =pmd_offset (pudp,0 ); +remove_pmd_mapping (pmd_base, addr, next, is_vmemmap, altmap); + +if (pgtable_l4_enabled) +free_pmd_table (pmd_base, pudp); + } +} + +static void __meminit remove_p4d_mapping (p4d_t *p4d_base,unsigned long addr,unsigned long end, +bool is_vmemmap,struct vmem_altmap *altmap) +{ +unsigned long next; +p4d_t *p4dp, p4d; +pud_t *pud_base; + +for (; addr < end; addr = next) { + next =p4d_addr_end (addr, end); + p4dp = p4d_base +p4d_index (addr); + p4d =READ_ONCE (*p4dp); + +if (!p4d_present (p4d)) +continue ; + +if (p4d_leaf (p4d)) { +if (pgtable_l5_enabled) { +p4d_clear (p4dp); +if (is_vmemmap) +free_vmemmap_storage (p4d_page (p4d),P4D_SIZE , altmap); + } +continue ; + } + + pud_base =pud_offset (p4dp,0 ); +remove_pud_mapping (pud_base, addr, next, is_vmemmap, altmap); + +if (pgtable_l5_enabled) +free_pud_table (pud_base, p4dp); + } +} + +static void __meminit remove_pgd_mapping (unsigned long va,unsigned long end,bool is_vmemmap, +struct vmem_altmap *altmap) +{ +unsigned long addr, next; +p4d_t *p4d_base; +pgd_t *pgd; + +for (addr = va; addr < end; addr = next) { + next =pgd_addr_end (addr, end); + pgd =pgd_offset_k (addr); + +if (!pgd_present (*pgd)) +continue ; + +if (pgd_leaf (*pgd)) +continue ; + + p4d_base =p4d_offset (pgd,0 ); +remove_p4d_mapping (p4d_base, addr, next, is_vmemmap, altmap); + } + +flush_tlb_all (); +} + +static void __meminit remove_linear_mapping (phys_addr_t start,u64 size) +{ +unsigned long va = (unsigned long )__va (start); +unsigned long end = (unsigned long )__va (start + size); + +remove_pgd_mapping (va, end, false,NULL ); +} + +struct range arch_get_mappable_range (void ) +{ +struct range mhp_range; + + mhp_range.start =__pa (PAGE_OFFSET ); + mhp_range.end =__pa (PAGE_END -1 ); +return mhp_range; +} + +int __ref arch_add_memory (int nid,u64 start,u64 size,struct mhp_params *params) +{ +int ret =0 ; + +create_linear_mapping_range (start, start + size,0 , ¶ms->pgprot); + ret =__add_pages (nid, start >>PAGE_SHIFT , size >>PAGE_SHIFT , params); +if (ret) { +remove_linear_mapping (start, size); + goto out; + } + + max_pfn =PFN_UP (start + size); + max_low_pfn = max_pfn; + + out: +flush_tlb_all (); +return ret; +} + +void __ref arch_remove_memory (u64 start,u64 size,struct vmem_altmap *altmap) +{ +__remove_pages (start >>PAGE_SHIFT , size >>PAGE_SHIFT , altmap); +remove_linear_mapping (start, size); +flush_tlb_all (); +} + +void __ref vmemmap_free (unsigned long start,unsigned long end,struct vmem_altmap *altmap) +{ +remove_pgd_mapping (start, end, true, altmap); +} +#endif /* CONFIG_MEMORY_HOTPLUG */
Signature · 1 line
2.40.1
PATCH v3 6/9 riscv: mm: Take memory hotplug read-lock during kernel page table dump
In reply to Björn TöpelFrom: Björn Töpel <[email protected]>
During memory hot remove, the ptdump functionality can end up touching stale data. Avoid any potential crashes (or worse), by holding the memory hotplug read-lock while traversing the page table.
This change is analogous to arm64's commit bf2b59f60ee1 ("arm64/mm:
Hold memory hotplug lock while walking for kernel page table dump").
--- arch/riscv/mm/ptdump.c | 3 +++ 1 file changed, 3 insertions(+)
arch/riscv/mm/ptdump.c +3 -0
@@ -6,6 +6,7 @@#include <linux/efi.h> #include <linux/init.h> #include <linux/debugfs.h> +#include <linux/memory_hotplug.h> #include <linux/seq_file.h> #include <linux/ptdump.h>
@@ -370,7 +371,9 @@ bool ptdump_check_wx(void)static int ptdump_show (struct seq_file *m,void *v) { +get_online_mems ();ptdump_walk (m, m->private); +put_online_mems ();return 0 ; }
Signature · 1 line
2.40.1
PATCH v3 7/9 riscv: Enable memory hotplugging for RISC-V
In reply to Björn TöpelFrom: Björn Töpel <[email protected]>
Enable ARCH_ENABLE_MEMORY_HOTPLUG and ARCH_ENABLE_MEMORY_HOTREMOVE for RISC-V.
--- arch/riscv/Kconfig | 2 ++ 1 file changed, 2 insertions(+)
arch/riscv/Kconfig +2 -0
@@ -16,6 +16,8 @@ config RISCV select ACPI_REDUCED_HARDWARE_ONLY if ACPI select ARCH_DMA_DEFAULT_COHERENT select ARCH_ENABLE_HUGEPAGE_MIGRATION if HUGETLB_PAGE && MIGRATION + select ARCH_ENABLE_MEMORY_HOTPLUG if SPARSEMEM_VMEMMAP && 64BIT && MMU + select ARCH_ENABLE_MEMORY_HOTREMOVE if MEMORY_HOTPLUG select ARCH_ENABLE_SPLIT_PMD_PTLOCK if PGTABLE_LEVELS > 2 select ARCH_ENABLE_THP_MIGRATION if TRANSPARENT_HUGEPAGE select ARCH_HAS_BINFMT_FLAT
Signature · 1 line
2.40.1
PATCH v3 8/9 virtio-mem: Enable virtio-mem for RISC-V
In reply to Björn TöpelFrom: Björn Töpel <[email protected]>
Now that RISC-V has memory hotplugging support, virtio-mem can be used on the platform.
--- drivers/virtio/Kconfig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
drivers/virtio/Kconfig +1 -1
@@ -122,7 +122,7 @@ config VIRTIO_BALLOON config VIRTIO_MEM tristate "Virtio mem driver" - depends on X86_64 || ARM64 + depends on X86_64 || ARM64 || RISCV depends on VIRTIO depends on MEMORY_HOTPLUG depends on MEMORY_HOTREMOVE
Signature · 1 line
2.40.1
PATCH v3 9/9 riscv: mm: Add support for ZONE_DEVICE
In reply to Björn TöpelFrom: Björn Töpel <[email protected]>
ZONE_DEVICE pages need DEVMAP PTEs support to function (ARCH_HAS_PTE_DEVMAP). Claim another RSW (reserved for software) bit in the PTE for DEVMAP mark, add the corresponding helpers, and enable ARCH_HAS_PTE_DEVMAP for riscv64.
--- arch/riscv/Kconfig | 1 + arch/riscv/include/asm/pgtable-64.h | 20 ++++++++++++++++++++ arch/riscv/include/asm/pgtable-bits.h | 1 + arch/riscv/include/asm/pgtable.h | 17 +++++++++++++++++ 4 files changed, 39 insertions(+)
arch/riscv/Kconfig +1 -0
@@ -36,6 +36,7 @@ config RISCV select ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE select ARCH_HAS_PMEM_API select ARCH_HAS_PREPARE_SYNC_CORE_CMD + select ARCH_HAS_PTE_DEVMAP if 64BIT && MMU select ARCH_HAS_PTE_SPECIAL select ARCH_HAS_SET_DIRECT_MAP if MMU select ARCH_HAS_SET_MEMORY if MMU
arch/riscv/include/asm/pgtable-64.h +20 -0
@@ -400,4 +400,24 @@ static inline struct page *pgd_page(pgd_t pgd)#define p4d_offset p4d_offsetp4d_t *p4d_offset (pgd_t *pgd,unsigned long address); +#ifdef CONFIG_TRANSPARENT_HUGEPAGE +static inline int pte_devmap (pte_t pte); +static inline pte_t pmd_pte (pmd_t pmd); + +static inline int pmd_devmap (pmd_t pmd) +{ +return pte_devmap (pmd_pte (pmd)); +} + +static inline int pud_devmap (pud_t pud) +{ +return 0 ; +} + +static inline int pgd_devmap (pgd_t pgd) +{ +return 0 ; +} +#endif +#endif /* _ASM_RISCV_PGTABLE_64_H */
arch/riscv/include/asm/pgtable-bits.h +1 -0
@@ -19,6 +19,7 @@#define _PAGE_SOFT (3 << 8)/* Reserved for software */ #define _PAGE_SPECIAL (1 << 8)/* RSW: 0x1 */ +#define _PAGE_DEVMAP (1 << 9)/* RSW, devmap */ #define _PAGE_TABLE _PAGE_PRESENT/*
arch/riscv/include/asm/pgtable.h +17 -0
@@ -387,6 +387,13 @@ static inline int pte_special(pte_t pte)return pte_val (pte) & _PAGE_SPECIAL; } +#ifdef CONFIG_ARCH_HAS_PTE_DEVMAP +static inline int pte_devmap (pte_t pte) +{ +return pte_val (pte) & _PAGE_DEVMAP; +} +#endif +/* static inline pte_t pte_rdprotect(pte_t pte) */ static inline pte_t pte_wrprotect (pte_t pte)
@@ -428,6 +435,11 @@ static inline pte_t pte_mkspecial(pte_t pte)return __pte (pte_val (pte) | _PAGE_SPECIAL); } +static inline pte_t pte_mkdevmap (pte_t pte) +{ +return __pte (pte_val (pte) | _PAGE_DEVMAP); +} +static inline pte_t pte_mkhuge (pte_t pte) {return pte;
@@ -711,6 +723,11 @@ static inline pmd_t pmd_mkdirty(pmd_t pmd)return pte_pmd (pte_mkdirty (pmd_pte (pmd))); } +static inline pmd_t pmd_mkdevmap (pmd_t pmd) +{ +return pte_pmd (pte_mkdevmap (pmd_pte (pmd))); +} +static inline void set_pmd_at (struct mm_struct *mm,unsigned long addr,pmd_t *pmdp,pmd_t pmd) {
Signature · 1 line
2.40.1
Re: [PATCH v3 1/9] riscv: mm: Properly forward vmemmap_populate() altmap parameter
In reply to Björn TöpelHi Björn,
Quoted 25 lines · Björn Töpel
From: Björn Töpel <[email protected]>
Make sure that the altmap parameter is properly passed on to
vmemmap_populate_hugepages().Signed-off-by Björn Töpel <[email protected]>--- arch/riscv/mm/init.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)arch/riscv/mm/init.c +1
-2@@ -1434,7 +1434,7 @@ int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node,* memory hotplug, we are not able to update all the page tables with * the new PMDs. */ -return vmemmap_populate_hugepages (start, end, node,NULL ); + return vmemmap_populate_hugepages(start, end, node, altmap); }#endif --
Quoted 2 lines
2.40.1
You can add:
Thanks,
Alex
Re: [PATCH v3 3/9] riscv: mm: Change attribute from __init to __meminit for page functions
In reply to Björn TöpelQuoted 236 lines · Björn Töpel
From: Björn Töpel <[email protected]>
Prepare for memory hotplugging support by changing from
__initto__meminitfor the page table functions that are used by the upcoming architecture specific callbacks.Changing the
__initattribute to__meminit, avoids that the functions are removed after init. The__meminitattribute makes sure the functions are kept in the kernel text post init, but only if memory hotplugging is enabled for the build.Reviewed-by David Hildenbrand <[email protected]>Reviewed-by Oscar Salvador <[email protected]>Signed-off-by Björn Töpel <[email protected]>--- arch/riscv/include/asm/mmu.h | 4 +-- arch/riscv/include/asm/pgtable.h | 2 +- arch/riscv/mm/init.c | 56 ++++++++++++++------------------ 3 files changed, 28 insertions(+), 34 deletions(-)arch/riscv/include/asm/mmu.h +2
-2@@ -31,8 +31,8 @@ typedef struct {#define cntx2asid (cntx) ((cntx) & SATP_ASID_MASK)#define cntx2version (cntx) ((cntx) & ~SATP_ASID_MASK) -void __init create_pgd_mapping (pgd_t *pgdp,uintptr_t va,phys_addr_t pa, -phys_addr_t sz,pgprot_t prot); +void __meminit create_pgd_mapping (pgd_t *pgdp,uintptr_t va,phys_addr_t pa,phys_addr_t sz, +pgprot_t prot);#endif /* __ASSEMBLY__ */ #endif /* _ASM_RISCV_MMU_H */ arch/riscv/include/asm/pgtable.h +1
-1@@ -162,7 +162,7 @@ struct pt_alloc_ops {#endif }; -extern struct pt_alloc_ops pt_ops__initdata ; +extern struct pt_alloc_ops pt_ops__meminitdata ;#ifdef CONFIG_MMU /* Number of PGD entries that a user-mode program can use */ arch/riscv/mm/init.c +25
-32@@ -295,7 +295,7 @@ static void __init setup_bootmem(void) }#ifdef CONFIG_MMU -struct pt_alloc_ops pt_ops__initdata ; +struct pt_alloc_ops pt_ops__meminitdata ; pgd_t swapper_pg_dir[PTRS_PER_PGD] __page_aligned_bss; pgd_t trampoline_pg_dir[PTRS_PER_PGD] __page_aligned_bss;@@ -357,7 +357,7 @@ static inline pte_t *__init get_pte_virt_fixmap(phys_addr_t pa)return (pte_t *)set_fixmap_offset (FIX_PTE , pa); } -static inline pte_t *__init get_pte_virt_late (phys_addr_t pa) +static inline pte_t *__meminit get_pte_virt_late (phys_addr_t pa) {return (pte_t *)__va (pa); }@@ -376,7 +376,7 @@ static inline phys_addr_t __init alloc_pte_fixmap(uintptr_t va)return memblock_phys_alloc (PAGE_SIZE ,PAGE_SIZE ); } -static phys_addr_t __init alloc_pte_late (uintptr_t va) +static phys_addr_t __meminit alloc_pte_late (uintptr_t va) {struct ptdesc *ptdesc =pagetable_alloc (GFP_KERNEL & ~__GFP_HIGHMEM,0 );@@ -384,9 +384,8 @@ static phys_addr_t __init alloc_pte_late(uintptr_t va)return __pa ((pte_t *)ptdesc_address (ptdesc)); } -static void __init create_pte_mapping (pte_t *ptep, -uintptr_t va,phys_addr_t pa, -phys_addr_t sz,pgprot_t prot) +static void __meminit create_pte_mapping (pte_t *ptep,uintptr_t va,phys_addr_t pa,phys_addr_t sz, +pgprot_t prot) {uintptr_t pte_idx =pte_index (va);@@ -440,7 +439,7 @@ static pmd_t *__init get_pmd_virt_fixmap(phys_addr_t pa)return (pmd_t *)set_fixmap_offset (FIX_PMD , pa); } -static pmd_t *__init get_pmd_virt_late (phys_addr_t pa) +static pmd_t *__meminit get_pmd_virt_late (phys_addr_t pa) {return (pmd_t *)__va (pa); }@@ -457,7 +456,7 @@ static phys_addr_t __init alloc_pmd_fixmap(uintptr_t va)return memblock_phys_alloc (PAGE_SIZE ,PAGE_SIZE ); } -static phys_addr_t __init alloc_pmd_late (uintptr_t va) +static phys_addr_t __meminit alloc_pmd_late (uintptr_t va) {struct ptdesc *ptdesc =pagetable_alloc (GFP_KERNEL & ~__GFP_HIGHMEM,0 );@@ -465,9 +464,9 @@ static phys_addr_t __init alloc_pmd_late(uintptr_t va)return __pa ((pmd_t *)ptdesc_address (ptdesc)); } -static void __init create_pmd_mapping (pmd_t *pmdp, -uintptr_t va,phys_addr_t pa, -phys_addr_t sz,pgprot_t prot) +static void __meminit create_pmd_mapping (pmd_t *pmdp, +uintptr_t va,phys_addr_t pa, +phys_addr_t sz,pgprot_t prot) {pte_t *ptep;phys_addr_t pte_phys;@@ -503,7 +502,7 @@ static pud_t *__init get_pud_virt_fixmap(phys_addr_t pa)return (pud_t *)set_fixmap_offset (FIX_PUD , pa); } -static pud_t *__init get_pud_virt_late (phys_addr_t pa) +static pud_t *__meminit get_pud_virt_late (phys_addr_t pa) {return (pud_t *)__va (pa); }@@ -521,7 +520,7 @@ static phys_addr_t __init alloc_pud_fixmap(uintptr_t va)return memblock_phys_alloc (PAGE_SIZE ,PAGE_SIZE ); } -static phys_addr_t alloc_pud_late (uintptr_t va) +static phys_addr_t __meminit alloc_pud_late (uintptr_t va) {unsigned long vaddr;@@ -541,7 +540,7 @@ static p4d_t *__init get_p4d_virt_fixmap(phys_addr_t pa)return (p4d_t *)set_fixmap_offset (FIX_P4D , pa); } -static p4d_t *__init get_p4d_virt_late (phys_addr_t pa) +static p4d_t *__meminit get_p4d_virt_late (phys_addr_t pa) {return (p4d_t *)__va (pa); }@@ -559,7 +558,7 @@ static phys_addr_t __init alloc_p4d_fixmap(uintptr_t va)return memblock_phys_alloc (PAGE_SIZE ,PAGE_SIZE ); } -static phys_addr_t alloc_p4d_late (uintptr_t va) +static phys_addr_t __meminit alloc_p4d_late (uintptr_t va) {unsigned long vaddr;@@ -568,9 +567,8 @@ static phys_addr_t alloc_p4d_late(uintptr_t va)return __pa (vaddr); } -static void __init create_pud_mapping (pud_t *pudp, -uintptr_t va,phys_addr_t pa, -phys_addr_t sz,pgprot_t prot) +static void __meminit create_pud_mapping (pud_t *pudp,uintptr_t va,phys_addr_t pa,phys_addr_t sz, +pgprot_t prot) {pmd_t *nextp;phys_addr_t next_phys;@@ -595,9 +593,8 @@ static void __init create_pud_mapping(pud_t *pudp,create_pmd_mapping (nextp, va, pa, sz, prot); } -static void __init create_p4d_mapping (p4d_t *p4dp, -uintptr_t va,phys_addr_t pa, -phys_addr_t sz,pgprot_t prot) +static void __meminit create_p4d_mapping (p4d_t *p4dp,uintptr_t va,phys_addr_t pa,phys_addr_t sz, +pgprot_t prot) {pud_t *nextp;phys_addr_t next_phys;@@ -653,9 +650,8 @@ static void __init create_p4d_mapping(p4d_t *p4dp,#define create_pmd_mapping (__pmdp, __va, __pa, __sz, __prot) do {} while(0)#endif /* __PAGETABLE_PMD_FOLDED */ -void __init create_pgd_mapping (pgd_t *pgdp, -uintptr_t va,phys_addr_t pa, -phys_addr_t sz,pgprot_t prot) +void __meminit create_pgd_mapping (pgd_t *pgdp,uintptr_t va,phys_addr_t pa,phys_addr_t sz, +pgprot_t prot) {pgd_next_t *nextp;phys_addr_t next_phys;@@ -680,8 +676,7 @@ void __init create_pgd_mapping(pgd_t *pgdp,create_pgd_next_mapping (nextp, va, pa, sz, prot); } -static uintptr_t __init best_map_size (phys_addr_t pa,uintptr_t va, -phys_addr_t size) +static uintptr_t __meminit best_map_size (phys_addr_t pa,uintptr_t va,phys_addr_t size) {if (pgtable_l5_enabled && !(pa & (P4D_SIZE -1 )) && !(va & (P4D_SIZE -1 )) && size >=P4D_SIZE )@@ -714,7 +709,7 @@ asmlinkage void __init __copy_data(void)#endif #ifdef CONFIG_STRICT_KERNEL_RWX -static __init pgprot_t pgprot_from_va (uintptr_t va) +static __meminit pgprot_t pgprot_from_va (uintptr_t va) {if (is_va_kernel_text (va))return PAGE_KERNEL_READ_EXEC ;@@ -739,7 +734,7 @@ void mark_rodata_ro(void) set_memory_ro); }#else -static __init pgprot_t pgprot_from_va (uintptr_t va) +static __meminit pgprot_t pgprot_from_va (uintptr_t va) {if (IS_ENABLED (CONFIG_64BIT ) && !is_kernel_mapping (va))return PAGE_KERNEL ;@@ -1231,9 +1226,8 @@ asmlinkage void __init setup_vm(uintptr_t dtb_pa)pt_ops_set_fixmap (); } -static void __init create_linear_mapping_range (phys_addr_t start, -phys_addr_t end, -uintptr_t fixed_map_size) +static void __meminit create_linear_mapping_range (phys_addr_t start,phys_addr_t end, +uintptr_t fixed_map_size) {phys_addr_t pa;uintptr_t va, map_size; --
Quoted 2 lines
2.40.1
You can add:
Thanks,
Alex
Re: [PATCH v3 5/9] riscv: mm: Add memory hotplugging support
In reply to Björn TöpelQuoted 48 lines · Björn Töpel
From: Björn Töpel <[email protected]>
For an architecture to support memory hotplugging, a couple of callbacks needs to be implemented:
arch_add_memory()
This callback is responsible for adding the physical memory into the direct map, and call into the memory hotplugging generic code via__add_pages()that adds the corresponding struct page entries, and updates the vmemmap mapping.
arch_remove_memory()
This is the inverse of the callback above.
vmemmap_free()
This function tears down the vmemmap mappings (ifCONFIG_SPARSEMEM_VMEMMAPis enabled), and also deallocates the backing vmemmap pages. Note that for persistent memory, an alternative allocator for the backing pages can be used; Thevmem_altmap. This means that when the backing pages are cleared, extra care is needed so that the correct deallocation method is used.
arch_get_mappable_range()
This functions returns the PA range that the direct map can map. Used by the MHP internals for sanity checks.The page table unmap/teardown functions are heavily based on code from the x86 tree. The same
remove_pgd_mapping()function is used in bothvmemmap_free()andarch_remove_memory(), but in the latter function the backing pages are not removed.Signed-off-by Björn Töpel <[email protected]>--- arch/riscv/mm/init.c | 261 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 261 insertions(+)arch/riscv/mm/init.c +2
-0@@ -1493,3 +1493,264 @@ void __init pgtable_cache_init(void) } }#endif + +#ifdef CONFIG_MEMORY_HOTPLUG
arch/riscv/mm/init.c void __init pgtable_cache_init(void) · line 1507
Quoted 10 lines
arch/riscv/mm/init.c +10
-0+static void __meminit free_pagetable (struct page *page,int order) +{ +unsigned int nr_pages =1 << order; + +/* +* vmemmap/direct page tables can be reserved, if added at +* boot. +*/ +if (PageReserved (page)) { +__ClearPageReserved (page);
What's the difference between __ClearPageReserved() and ClearPageReserved()? Because it seems like free_reserved_page() calls the latter already, so why would you need to call __ClearPageReserved() on the first page?
Quoted 60 lines
arch/riscv/mm/init.c +60
-0+while (nr_pages--) +free_reserved_page (page++); +return ; + } + +free_pages ((unsigned long )page_address (page), order); +} + +static void __meminit free_pte_table (pte_t *pte_start,pmd_t *pmd) +{ +pte_t *pte; +int i; + +for (i =0 ; i <PTRS_PER_PTE ; i++) { + pte = pte_start + i; +if (!pte_none (*pte)) +return ; + } + +free_pagetable (pmd_page (*pmd),0 ); +pmd_clear (pmd); +} + +static void __meminit free_pmd_table (pmd_t *pmd_start,pud_t *pud) +{ +pmd_t *pmd; +int i; + +for (i =0 ; i <PTRS_PER_PMD ; i++) { + pmd = pmd_start + i; +if (!pmd_none (*pmd)) +return ; + } + +free_pagetable (pud_page (*pud),0 ); +pud_clear (pud); +} + +static void __meminit free_pud_table (pud_t *pud_start,p4d_t *p4d) +{ +pud_t *pud; +int i; + +for (i =0 ; i <PTRS_PER_PUD ; i++) { + pud = pud_start + i; +if (!pud_none (*pud)) +return ; + } + +free_pagetable (p4d_page (*p4d),0 ); +p4d_clear (p4d); +} + +static void __meminit free_vmemmap_storage (struct page *page,size_t size, +struct vmem_altmap *altmap) +{ +if (altmap) +vmem_altmap_free (altmap, size >>PAGE_SHIFT ); +else +free_pagetable (page,get_order (size));
arch/riscv/mm/init.c void __init pgtable_cache_init(void) · line 1577
Quoted 10 lines
arch/riscv/mm/init.c +10
-0+} + +static void __meminit remove_pte_mapping (pte_t *pte_base,unsigned long addr,unsigned long end, +bool is_vmemmap,struct vmem_altmap *altmap) +{ +unsigned long next; +pte_t *ptep, pte; + +for (; addr < end; addr = next) { + next = (addr +PAGE_SIZE ) &PAGE_MASK ;
Nit: use ALIGN() instead.
arch/riscv/mm/init.c void __init pgtable_cache_init(void) · line 1582
Quoted 5 lines
arch/riscv/mm/init.c +5
-0+if (next > end) + next = end; + + ptep = pte_base +pte_index (addr); + pte =READ_ONCE (*ptep);
Nit: Use ptep_get()
Quoted 11 lines
arch/riscv/mm/init.c +11
-0+ +if (!pte_present (*ptep)) +continue ; + +pte_clear (&init_mm, addr, ptep); +if (is_vmemmap) +free_vmemmap_storage (pte_page (pte),PAGE_SIZE , altmap); + } +} + +static void __meminit remove_pmd_mapping(pmd_t *pmd_base, unsigned long addr, unsigned long end,
arch/riscv/mm/init.c void __init pgtable_cache_init(void) · line 1603
Quoted 10 lines
arch/riscv/mm/init.c +10
-0+ bool is_vmemmap, struct vmem_altmap *altmap) +{ + unsigned long next; +pte_t *pte_base; +pmd_t *pmdp, pmd; + +for (; addr < end; addr = next) { + next =pmd_addr_end (addr, end); + pmdp = pmd_base +pmd_index (addr); + pmd =READ_ONCE (*pmdp);
Nit: Use pmdp_get()
Quoted 18 lines
arch/riscv/mm/init.c +18
-0+ +if (!pmd_present (pmd)) +continue ; + +if (pmd_leaf (pmd)) { +pmd_clear (pmdp); +if (is_vmemmap) +free_vmemmap_storage (pmd_page (pmd),PMD_SIZE , altmap); +continue ; + } + + pte_base = (pte_t *)pmd_page_vaddr (*pmdp); +remove_pte_mapping (pte_base, addr, next, is_vmemmap, altmap); +free_pte_table (pte_base, pmdp); + } +} + +static void __meminit remove_pud_mapping(pud_t *pud_base, unsigned long addr, unsigned long end,
arch/riscv/mm/init.c void __init pgtable_cache_init(void) · line 1631
Quoted 10 lines
arch/riscv/mm/init.c +10
-0+ bool is_vmemmap, struct vmem_altmap *altmap) +{ + unsigned long next; +pud_t *pudp, pud; +pmd_t *pmd_base; + +for (; addr < end; addr = next) { + next =pud_addr_end (addr, end); + pudp = pud_base +pud_index (addr); + pud =READ_ONCE (*pudp);
Nit: Use pudp_get()
Quoted 22 lines
arch/riscv/mm/init.c +22
-0+ +if (!pud_present (pud)) +continue ; + +if (pud_leaf (pud)) { +if (pgtable_l4_enabled) { +pud_clear (pudp); +if (is_vmemmap) +free_vmemmap_storage (pud_page (pud),PUD_SIZE , altmap); + } +continue ; + } + + pmd_base =pmd_offset (pudp,0 ); +remove_pmd_mapping (pmd_base, addr, next, is_vmemmap, altmap); + +if (pgtable_l4_enabled) +free_pmd_table (pmd_base, pudp); + } +} + +static void __meminit remove_p4d_mapping(p4d_t *p4d_base, unsigned long addr, unsigned long end,
arch/riscv/mm/init.c void __init pgtable_cache_init(void) · line 1663
Quoted 10 lines
arch/riscv/mm/init.c +10
-0+ bool is_vmemmap, struct vmem_altmap *altmap) +{ + unsigned long next; +p4d_t *p4dp, p4d; +pud_t *pud_base; + +for (; addr < end; addr = next) { + next =p4d_addr_end (addr, end); + p4dp = p4d_base +p4d_index (addr); + p4d =READ_ONCE (*p4dp);
Nit: Use p4dp_get()
Quoted 96 lines
arch/riscv/mm/init.c +93
-1+ +if (!p4d_present (p4d)) +continue ; + +if (p4d_leaf (p4d)) { +if (pgtable_l5_enabled) { +p4d_clear (p4dp); +if (is_vmemmap) +free_vmemmap_storage (p4d_page (p4d),P4D_SIZE , altmap); + } +continue ; + } + + pud_base =pud_offset (p4dp,0 ); +remove_pud_mapping (pud_base, addr, next, is_vmemmap, altmap); + +if (pgtable_l5_enabled) + free_pud_table(pud_base, p4dp); + } +} + +static void __meminit remove_pgd_mapping (unsigned long va,unsigned long end,bool is_vmemmap, +struct vmem_altmap *altmap) +{ +unsigned long addr, next; +p4d_t *p4d_base; +pgd_t *pgd; + +for (addr = va; addr < end; addr = next) { + next =pgd_addr_end (addr, end); + pgd =pgd_offset_k (addr); + +if (!pgd_present (*pgd)) +continue ; + +if (pgd_leaf (*pgd)) +continue ; + + p4d_base =p4d_offset (pgd,0 ); +remove_p4d_mapping (p4d_base, addr, next, is_vmemmap, altmap); + } + +flush_tlb_all (); +} + +static void __meminit remove_linear_mapping (phys_addr_t start,u64 size) +{ +unsigned long va = (unsigned long )__va (start); +unsigned long end = (unsigned long )__va (start + size); + +remove_pgd_mapping (va, end, false,NULL ); +} + +struct range arch_get_mappable_range (void ) +{ +struct range mhp_range; + + mhp_range.start =__pa (PAGE_OFFSET ); + mhp_range.end =__pa (PAGE_END -1 ); +return mhp_range; +} + +int __ref arch_add_memory (int nid,u64 start,u64 size,struct mhp_params *params) +{ +int ret =0 ; + +create_linear_mapping_range (start, start + size,0 , ¶ms->pgprot); + ret =__add_pages (nid, start >>PAGE_SHIFT , size >>PAGE_SHIFT , params); +if (ret) { +remove_linear_mapping (start, size); + goto out; + } + + max_pfn =PFN_UP (start + size); + max_low_pfn = max_pfn; + + out: +flush_tlb_all (); +return ret; +} + +void __ref arch_remove_memory (u64 start,u64 size,struct vmem_altmap *altmap) +{ +__remove_pages (start >>PAGE_SHIFT , size >>PAGE_SHIFT , altmap); +remove_linear_mapping (start, size); +flush_tlb_all (); +} + +void __ref vmemmap_free (unsigned long start,unsigned long end,struct vmem_altmap *altmap) +{ +remove_pgd_mapping (start, end, true, altmap); +} +#endif /* CONFIG_MEMORY_HOTPLUG */ --2.40.1
Re: [PATCH v3 7/9] riscv: Enable memory hotplugging for RISC-V
In reply to Björn TöpelQuoted 16 lines · Björn Töpel
From: Björn Töpel <[email protected]>
Enable
ARCH_ENABLE_MEMORY_HOTPLUGandARCH_ENABLE_MEMORY_HOTREMOVEfor RISC-V.Signed-off-by Björn Töpel <[email protected]>--- arch/riscv/Kconfig | 2 ++ 1 file changed, 2 insertions(+)arch/riscv/Kconfig +0
-0
arch/riscv/Kconfig config RISCV · line 19
Quoted 4 lines
arch/riscv/Kconfig +1
-0@@ -16,6 +16,8 @@ config RISCV select ACPI_REDUCED_HARDWARE_ONLY if ACPI select ARCH_DMA_DEFAULT_COHERENT select ARCH_ENABLE_HUGEPAGE_MIGRATION if HUGETLB_PAGE && MIGRATION + select ARCH_ENABLE_MEMORY_HOTPLUG if SPARSEMEM_VMEMMAP && 64BIT && MMU
Not sure you need 64BIT && MMU here since ARCH_SPARSEMEM_ENABLE depends on MMU and SPARSEMEM_VMEMMAP_ENABLE is only enabled on 64BIT.
Quoted 7 lines
arch/riscv/Kconfig +1
-1+ select ARCH_ENABLE_MEMORY_HOTREMOVE if MEMORY_HOTPLUG select ARCH_ENABLE_SPLIT_PMD_PTLOCK if PGTABLE_LEVELS > 2 select ARCH_ENABLE_THP_MIGRATION if TRANSPARENT_HUGEPAGE select ARCH_HAS_BINFMT_FLAT --2.40.1
But anyway, to me that does not require a new version so you can add:
Thanks,
Alex
Re: [PATCH v3 9/9] riscv: mm: Add support for ZONE_DEVICE
In reply to Björn TöpelQuoted 74 lines · Björn Töpel
From: Björn Töpel <[email protected]>
ZONE_DEVICEpages need DEVMAP PTEs support to function (ARCH_HAS_PTE_DEVMAP). Claim another RSW (reserved for software) bit in the PTE for DEVMAP mark, add the corresponding helpers, and enableARCH_HAS_PTE_DEVMAPfor riscv64.Signed-off-by Björn Töpel <[email protected]>--- arch/riscv/Kconfig | 1 + arch/riscv/include/asm/pgtable-64.h | 20 ++++++++++++++++++++ arch/riscv/include/asm/pgtable-bits.h | 1 + arch/riscv/include/asm/pgtable.h | 17 +++++++++++++++++ 4 files changed, 39 insertions(+)arch/riscv/Kconfig +1
-0@@ -36,6 +36,7 @@ config RISCV select ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE select ARCH_HAS_PMEM_API select ARCH_HAS_PREPARE_SYNC_CORE_CMD + select ARCH_HAS_PTE_DEVMAP if 64BIT && MMU select ARCH_HAS_PTE_SPECIAL select ARCH_HAS_SET_DIRECT_MAP if MMU select ARCH_HAS_SET_MEMORY if MMUarch/riscv/include/asm/pgtable-64.h +20
-0@@ -400,4 +400,24 @@ static inline struct page *pgd_page(pgd_t pgd)#define p4d_offset p4d_offsetp4d_t *p4d_offset (pgd_t *pgd,unsigned long address); +#ifdef CONFIG_TRANSPARENT_HUGEPAGE +static inline int pte_devmap (pte_t pte); +static inline pte_t pmd_pte (pmd_t pmd); + +static inline int pmd_devmap (pmd_t pmd) +{ +return pte_devmap (pmd_pte (pmd)); +} + +static inline int pud_devmap (pud_t pud) +{ +return 0 ; +} + +static inline int pgd_devmap (pgd_t pgd) +{ +return 0 ; +} +#endif +#endif /* _ASM_RISCV_PGTABLE_64_H */ arch/riscv/include/asm/pgtable-bits.h +1
-0@@ -19,6 +19,7 @@#define _PAGE_SOFT (3 << 8)/* Reserved for software */ #define _PAGE_SPECIAL (1 << 8)/* RSW: 0x1 */ +#define _PAGE_DEVMAP (1 << 9)/* RSW, devmap */ #define _PAGE_TABLE _PAGE_PRESENT/* arch/riscv/include/asm/pgtable.h +0
-0
arch/riscv/include/asm/pgtable.h static inline int pte_special(pte_t pte) · line 395
Quoted 9 lines
arch/riscv/include/asm/pgtable.h +6
-0@@ -387,6 +387,13 @@ static inline int pte_special(pte_t pte)return pte_val (pte) & _PAGE_SPECIAL; } +#ifdef CONFIG_ARCH_HAS_PTE_DEVMAP +static inline int pte_devmap (pte_t pte) +{ +return pte_val (pte) & _PAGE_DEVMAP; +} +#endif
Not sure you need the #ifdef here.
Quoted 29 lines
arch/riscv/include/asm/pgtable.h +11
-1+/* static inline pte_t pte_rdprotect(pte_t pte) */ static inline pte_t pte_wrprotect (pte_t pte)@@ -428,6 +435,11 @@ static inline pte_t pte_mkspecial(pte_t pte)return __pte (pte_val (pte) | _PAGE_SPECIAL); } +static inline pte_t pte_mkdevmap (pte_t pte) +{ +return __pte (pte_val (pte) | _PAGE_DEVMAP); +} +static inline pte_t pte_mkhuge (pte_t pte) {return pte;@@ -711,6 +723,11 @@ static inline pmd_t pmd_mkdirty(pmd_t pmd)return pte_pmd (pte_mkdirty (pmd_pte (pmd))); } +static inline pmd_t pmd_mkdevmap (pmd_t pmd) +{ +return pte_pmd (pte_mkdevmap (pmd_pte (pmd))); +} +static inline void set_pmd_at (struct mm_struct *mm,unsigned long addr,pmd_t *pmdp,pmd_t pmd) { --
Quoted 2 lines
2.40.1
Otherwise, you can add:
Thanks,
Alex
Re: [PATCH v3 9/9] riscv: mm: Add support for ZONE_DEVICE
Quoted 78 lines · Alexandre Ghiti
Quoted 77 lines · Björn Töpel
From: Björn Töpel <[email protected]>
ZONE_DEVICEpages need DEVMAP PTEs support to function (ARCH_HAS_PTE_DEVMAP). Claim another RSW (reserved for software) bit in the PTE for DEVMAP mark, add the corresponding helpers, and enableARCH_HAS_PTE_DEVMAPfor riscv64.Signed-off-by Björn Töpel <[email protected]>--- arch/riscv/Kconfig | 1 + arch/riscv/include/asm/pgtable-64.h | 20 ++++++++++++++++++++ arch/riscv/include/asm/pgtable-bits.h | 1 + arch/riscv/include/asm/pgtable.h | 17 +++++++++++++++++ 4 files changed, 39 insertions(+)arch/riscv/Kconfig +1
-0@@ -36,6 +36,7 @@ config RISCV select ARCH_HAS_NON_OVERLAPPING_ADDRESS_SPACE select ARCH_HAS_PMEM_API select ARCH_HAS_PREPARE_SYNC_CORE_CMD + select ARCH_HAS_PTE_DEVMAP if 64BIT && MMU select ARCH_HAS_PTE_SPECIAL select ARCH_HAS_SET_DIRECT_MAP if MMU select ARCH_HAS_SET_MEMORY if MMUarch/riscv/include/asm/pgtable-64.h +20
-0@@ -400,4 +400,24 @@ static inline struct page *pgd_page(pgd_t pgd)#define p4d_offset p4d_offsetp4d_t *p4d_offset (pgd_t *pgd,unsigned long address); +#ifdef CONFIG_TRANSPARENT_HUGEPAGE +static inline int pte_devmap (pte_t pte); +static inline pte_t pmd_pte (pmd_t pmd); + +static inline int pmd_devmap (pmd_t pmd) +{ +return pte_devmap (pmd_pte (pmd)); +} + +static inline int pud_devmap (pud_t pud) +{ +return 0 ; +} + +static inline int pgd_devmap (pgd_t pgd) +{ +return 0 ; +} +#endif +#endif /* _ASM_RISCV_PGTABLE_64_H */ arch/riscv/include/asm/pgtable-bits.h +1
-0@@ -19,6 +19,7 @@#define _PAGE_SOFT (3 << 8)/* Reserved for software */ #define _PAGE_SPECIAL (1 << 8)/* RSW: 0x1 */ +#define _PAGE_DEVMAP (1 << 9)/* RSW, devmap */ #define _PAGE_TABLE _PAGE_PRESENT/* arch/riscv/include/asm/pgtable.h +0
-0@@ -387,6 +387,13 @@ static inline int pte_special(pte_t pte)return pte_val (pte) & _PAGE_SPECIAL; }
Quoted 8 lines
arch/riscv/include/asm/pgtable.h static inline int pte_special(pte_t pte) · line 395
Quoted 6 lines
arch/riscv/include/asm/pgtable.h +6
-0+#ifdef CONFIG_ARCH_HAS_PTE_DEVMAP +static inline int pte_devmap (pte_t pte) +{ +return pte_val (pte) & _PAGE_DEVMAP; +} +#endif Not sure you need the #ifdef here.
W/o it 32b builds break (!defined(CONFIG_ARCH_HAS_PTE_DEVMAP) will have a default implementation).. Maybe it's cleaner just to use that instead?
Quoted 34 lines
Quoted 29 lines
arch/riscv/include/asm/pgtable.h +11
-1+/* static inline pte_t pte_rdprotect(pte_t pte) */ static inline pte_t pte_wrprotect (pte_t pte)@@ -428,6 +435,11 @@ static inline pte_t pte_mkspecial(pte_t pte)return __pte (pte_val (pte) | _PAGE_SPECIAL); } +static inline pte_t pte_mkdevmap (pte_t pte) +{ +return __pte (pte_val (pte) | _PAGE_DEVMAP); +} +static inline pte_t pte_mkhuge (pte_t pte) {return pte;@@ -711,6 +723,11 @@ static inline pmd_t pmd_mkdirty(pmd_t pmd)return pte_pmd (pte_mkdirty (pmd_pte (pmd))); } +static inline pmd_t pmd_mkdevmap (pmd_t pmd) +{ +return pte_pmd (pte_mkdevmap (pmd_pte (pmd))); +} +static inline void set_pmd_at (struct mm_struct *mm,unsigned long addr,pmd_t *pmdp,pmd_t pmd) { --Quoted 2 lines
2.40.1
Otherwise, you can add:
Quoted 1 line
Reviewed-by Alexandre Ghiti <[email protected]>
Thank you!
Björn
Re: [PATCH v3 5/9] riscv: mm: Add memory hotplugging support
In reply to Alexandre GhitiQuoted 56 lines · Alexandre Ghiti
Quoted 55 lines · Björn Töpel
From: Björn Töpel <[email protected]>
For an architecture to support memory hotplugging, a couple of callbacks needs to be implemented:
arch_add_memory()
This callback is responsible for adding the physical memory into the direct map, and call into the memory hotplugging generic code via__add_pages()that adds the corresponding struct page entries, and updates the vmemmap mapping.
arch_remove_memory()
This is the inverse of the callback above.
vmemmap_free()
This function tears down the vmemmap mappings (ifCONFIG_SPARSEMEM_VMEMMAPis enabled), and also deallocates the backing vmemmap pages. Note that for persistent memory, an alternative allocator for the backing pages can be used; Thevmem_altmap. This means that when the backing pages are cleared, extra care is needed so that the correct deallocation method is used.
arch_get_mappable_range()
This functions returns the PA range that the direct map can map. Used by the MHP internals for sanity checks.The page table unmap/teardown functions are heavily based on code from the x86 tree. The same
remove_pgd_mapping()function is used in bothvmemmap_free()andarch_remove_memory(), but in the latter function the backing pages are not removed.Signed-off-by Björn Töpel <[email protected]>--- arch/riscv/mm/init.c | 261 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 261 insertions(+)arch/riscv/mm/init.c +9
-0@@ -1493,3 +1493,264 @@ void __init pgtable_cache_init(void) } }#endif + +#ifdef CONFIG_MEMORY_HOTPLUG +static void __meminit free_pagetable (struct page *page,int order) +{ +unsigned int nr_pages =1 << order; + +/* +* vmemmap/direct page tables can be reserved, if added at +* boot.
Quoted 8 lines
arch/riscv/mm/init.c void __init pgtable_cache_init(void) · line 1507
Quoted 3 lines
arch/riscv/mm/init.c +3
-0+*/ +if (PageReserved (page)) { +__ClearPageReserved (page);What's the difference between
__ClearPageReserved()andClearPageReserved()? Because it seems likefree_reserved_page()calls the latter already, so why would you need to call__ClearPageReserved()on the first page?
Indeed! x86 copy pasta (which uses bootmem info page that RV doesn't).
Quoted 162 lines
Quoted 60 lines
arch/riscv/mm/init.c +60
-0+while (nr_pages--) +free_reserved_page (page++); +return ; + } + +free_pages ((unsigned long )page_address (page), order); +} + +static void __meminit free_pte_table (pte_t *pte_start,pmd_t *pmd) +{ +pte_t *pte; +int i; + +for (i =0 ; i <PTRS_PER_PTE ; i++) { + pte = pte_start + i; +if (!pte_none (*pte)) +return ; + } + +free_pagetable (pmd_page (*pmd),0 ); +pmd_clear (pmd); +} + +static void __meminit free_pmd_table (pmd_t *pmd_start,pud_t *pud) +{ +pmd_t *pmd; +int i; + +for (i =0 ; i <PTRS_PER_PMD ; i++) { + pmd = pmd_start + i; +if (!pmd_none (*pmd)) +return ; + } + +free_pagetable (pud_page (*pud),0 ); +pud_clear (pud); +} + +static void __meminit free_pud_table (pud_t *pud_start,p4d_t *p4d) +{ +pud_t *pud; +int i; + +for (i =0 ; i <PTRS_PER_PUD ; i++) { + pud = pud_start + i; +if (!pud_none (*pud)) +return ; + } + +free_pagetable (p4d_page (*p4d),0 ); +p4d_clear (p4d); +} + +static void __meminit free_vmemmap_storage (struct page *page,size_t size, +struct vmem_altmap *altmap) +{ +if (altmap) +vmem_altmap_free (altmap, size >>PAGE_SHIFT ); +else +free_pagetable (page,get_order (size));arch/riscv/mm/init.c void __init pgtable_cache_init(void) · line 1577
Quoted 10 lines
arch/riscv/mm/init.c +10
-0+} + +static void __meminit remove_pte_mapping (pte_t *pte_base,unsigned long addr,unsigned long end, +bool is_vmemmap,struct vmem_altmap *altmap) +{ +unsigned long next; +pte_t *ptep, pte; + +for (; addr < end; addr = next) { + next = (addr +PAGE_SIZE ) &PAGE_MASK ;Nit: use
ALIGN()instead.arch/riscv/mm/init.c void __init pgtable_cache_init(void) · line 1582
Quoted 5 lines
arch/riscv/mm/init.c +5
-0+if (next > end) + next = end; + + ptep = pte_base +pte_index (addr); + pte =READ_ONCE (*ptep);Nit: Use
ptep_get()Quoted 11 lines
arch/riscv/mm/init.c +11
-0+ +if (!pte_present (*ptep)) +continue ; + +pte_clear (&init_mm, addr, ptep); +if (is_vmemmap) +free_vmemmap_storage (pte_page (pte),PAGE_SIZE , altmap); + } +} + +static void __meminit remove_pmd_mapping(pmd_t *pmd_base, unsigned long addr, unsigned long end,arch/riscv/mm/init.c void __init pgtable_cache_init(void) · line 1603
Quoted 10 lines
arch/riscv/mm/init.c +10
-0+ bool is_vmemmap, struct vmem_altmap *altmap) +{ + unsigned long next; +pte_t *pte_base; +pmd_t *pmdp, pmd; + +for (; addr < end; addr = next) { + next =pmd_addr_end (addr, end); + pmdp = pmd_base +pmd_index (addr); + pmd =READ_ONCE (*pmdp);Nit: Use
pmdp_get()Quoted 18 lines
arch/riscv/mm/init.c +18
-0+ +if (!pmd_present (pmd)) +continue ; + +if (pmd_leaf (pmd)) { +pmd_clear (pmdp); +if (is_vmemmap) +free_vmemmap_storage (pmd_page (pmd),PMD_SIZE , altmap); +continue ; + } + + pte_base = (pte_t *)pmd_page_vaddr (*pmdp); +remove_pte_mapping (pte_base, addr, next, is_vmemmap, altmap); +free_pte_table (pte_base, pmdp); + } +} + +static void __meminit remove_pud_mapping(pud_t *pud_base, unsigned long addr, unsigned long end,arch/riscv/mm/init.c void __init pgtable_cache_init(void) · line 1631
Quoted 10 lines
arch/riscv/mm/init.c +10
-0+ bool is_vmemmap, struct vmem_altmap *altmap) +{ + unsigned long next; +pud_t *pudp, pud; +pmd_t *pmd_base; + +for (; addr < end; addr = next) { + next =pud_addr_end (addr, end); + pudp = pud_base +pud_index (addr); + pud =READ_ONCE (*pudp);Nit: Use
pudp_get()Quoted 26 lines
arch/riscv/mm/init.c +26
-0+ +if (!pud_present (pud)) +continue ; + +if (pud_leaf (pud)) { +if (pgtable_l4_enabled) { +pud_clear (pudp); +if (is_vmemmap) +free_vmemmap_storage (pud_page (pud),PUD_SIZE , altmap); + } +continue ; + } + + pmd_base =pmd_offset (pudp,0 ); +remove_pmd_mapping (pmd_base, addr, next, is_vmemmap, altmap); + +if (pgtable_l4_enabled) +free_pmd_table (pmd_base, pudp); + } +} + +static void __meminit remove_p4d_mapping (p4d_t *p4d_base,unsigned long addr,unsigned long end, +bool is_vmemmap,struct vmem_altmap *altmap) +{ +unsigned long next; +p4d_t *p4dp, p4d;
Quoted 8 lines
arch/riscv/mm/init.c void __init pgtable_cache_init(void) · line 1663
Quoted 6 lines
arch/riscv/mm/init.c +6
-0+pud_t *pud_base; + +for (; addr < end; addr = next) { + next =p4d_addr_end (addr, end); + p4dp = p4d_base +p4d_index (addr); + p4d =READ_ONCE (*p4dp);Nit: Use
p4dp_get()
...and I'll make sure to address these nits as well.
Thanks!
Björn
Re: [PATCH v3 5/9] riscv: mm: Add memory hotplugging support
In reply to Alexandre GhitiQuoted 8 lines · Alexandre Ghiti
arch/riscv/mm/init.c void __init pgtable_cache_init(void) · line 1507
Quoted 2 lines · Björn Töpel
arch/riscv/mm/init.c +2
-0+if (PageReserved (page)) { +__ClearPageReserved (page);What's the difference between
__ClearPageReserved()andClearPageReserved()? Because it seems likefree_reserved_page()calls the latter already, so why would you need to call__ClearPageReserved()on the first page?
__{Set,Clear}Page are the non-atomic version.
Usually used when you know that no one else can fiddle with the page, which should be the case here since we are removing the memory.
As to why we have __ClearPageReserved and then having free_reserved_page() call ClearPageReserved I do not really know. Looking at the history, it has always been like this.
I remember I looked at this a few years ago but I cannot remember the outcome of that.
Maybe David remembers better, but I think we could remove that __ClearPageReserved.
Looking at powerpc implementation code, it does not do the __ClearPageReserved and relies only on free_reserved_page().
I will have a look.
Signature · 2 lines
Oscar Salvador SUSE Labs
Re: [PATCH v3 2/9] riscv: mm: Pre-allocate vmemmap/direct map PGD entries
In reply to Björn TöpelQuoted 63 lines · Björn Töpel
From: Björn Töpel <[email protected]>
The RISC-V port copies the PGD table from init_mm/swapper_pg_dir to all userland page tables, which means that if the PGD level table is changed, other page tables has to be updated as well.
Instead of having the PGD changes ripple out to all tables, the synchronization can be avoided by pre-allocating the PGD entries/pages at boot, avoiding the synchronization all together.
This is currently done for the bpf/modules, and vmalloc PGD regions. Extend this scheme for the PGD regions touched by memory hotplugging.
Prepare the RISC-V port for memory hotplug by pre-allocate vmemmap/direct map entries at the PGD level. This will roughly waste ~128 worth of 4K pages when memory hotplugging is enabled in the kernel configuration.
Reviewed-by Alexandre Ghiti <[email protected]>Signed-off-by Björn Töpel <[email protected]>--- arch/riscv/include/asm/kasan.h | 4 ++-- arch/riscv/mm/init.c | 7 +++++++ 2 files changed, 9 insertions(+), 2 deletions(-)arch/riscv/include/asm/kasan.h +2
-2@@ -6,8 +6,6 @@#ifndef __ASSEMBLY__ -#ifdef CONFIG_KASAN -/* * The following comment was copied from arm64: * KASAN_SHADOW_START: beginning of the kernel virtual addresses. @@ -34,6 +32,8 @@*/ #define KASAN_SHADOW_START ((KASAN_SHADOW_END - KASAN_SHADOW_SIZE) & PGDIR_MASK)#define KASAN_SHADOW_END MODULES_LOWEST_VADDR + +#ifdef CONFIG_KASAN #define KASAN_SHADOW_OFFSET _AC(CONFIG_KASAN_SHADOW_OFFSET, UL)void kasan_init (void );arch/riscv/mm/init.c +1
-0@@ -27,6 +27,7 @@#include <asm/fixmap.h> #include <asm/io.h> +#include <asm/kasan.h> #include <asm/numa.h> #include <asm/pgtable.h> #include <asm/sections.h> @@ -1488,10 +1489,16 @@ static void __init preallocate_pgd_pages_range(unsigned long start, unsigned lonpanic ("Failed to pre-allocate %s pages for %s area\n" , lvl, area); }
arch/riscv/mm/init.c static void __init preallocate_pgd_pages_range(unsigned long start, unsigned lon · line 1501
Quoted 10 lines
arch/riscv/mm/init.c +5
-0+#define PAGE_END KASAN_SHADOW_START +void __init pgtable_cache_init (void ) {preallocate_pgd_pages_range (VMALLOC_START ,VMALLOC_END ,"vmalloc" );if (IS_ENABLED (CONFIG_MODULES ))preallocate_pgd_pages_range (MODULES_VADDR ,MODULES_END ,"bpf/modules" ); +if (IS_ENABLED (CONFIG_MEMORY_HOTPLUG )) { +preallocate_pgd_pages_range (VMEMMAP_START ,VMEMMAP_END ,"vmemmap" ); +preallocate_pgd_pages_range (PAGE_OFFSET ,PAGE_END ,"direct map" );
Alex pointed out that KASAN PGDs should be preallocated as well! I'll address this in the next revision.
Björn