History

Merge tag 'libnvdimm-for-4.16' of git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm

Pull libnvdimm updates from Ross Zwisler: - Require struct page by default for filesystem DAX to remove a number of surprising failure cases. This includes failures with direct I/O, gdb and fork(2). - Add support for the new Platform Capabilities Structure added to the NFIT in ACPI 6.2a. This new table tells us whether the platform supports flushing of CPU and memory controller caches on unexpected power loss events. - Revamp vmem_altmap and dev_pagemap handling to clean up code and better support future future PCI P2P uses. - Deprecate the ND_IOCTL_SMART_THRESHOLD command whose payload has become out-of-sync with recent versions of the NVDIMM_FAMILY_INTEL spec, and instead rely on the generic ND_CMD_CALL approach used by the two other IOCTL families, NVDIMM_FAMILY_{HPE,MSFT}. - Enhance nfit_test so we can test some of the new things added in version 1.6 of the DSM specification. This includes testing firmware download and simulating the Last Shutdown State (LSS) status. * tag 'libnvdimm-for-4.16' of git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm: (37 commits) libnvdimm, namespace: remove redundant initialization of 'nd_mapping' acpi, nfit: fix register dimm error handling libnvdimm, namespace: make min namespace size 4K tools/testing/nvdimm: force nfit_test to depend on instrumented modules libnvdimm/nfit_test: adding support for unit testing enable LSS status libnvdimm/nfit_test: add firmware download emulation nfit-test: Add platform cap support from ACPI 6.2a to test libnvdimm: expose platform persistence attribute for nd_region acpi: nfit: add persistent memory control flag for nd_region acpi: nfit: Add support for detect platform CPU cache flush on power loss device-dax: Fix trailing semicolon libnvdimm, btt: fix uninitialized err_lock dax: require 'struct page' by default for filesystem dax ext2: auto disable dax instead of failing mount ext4: auto disable dax instead of failing mount mm, dax: introduce pfn_t_special() mm: Fix devm_memremap_pages() collision handling mm: Fix memory size alignment in devm_memremap_pages_release() memremap: merge find_dev_pagemap into get_dev_pagemap memremap: change devm_memremap_pages interface to use struct dev_pagemap ...

Linus Torvalds committed 8 years ago

Commit 3ff1b282 parents 105cf3c ee95f4052 files · +1120 −525Browse files

Unified · Split

52 files
  1. arch/arm64/mm/mmu.c +6 −3
  2. arch/ia64/mm/discontig.c +4 −2
  3. arch/ia64/mm/init.c +10 −8
  4. arch/powerpc/mm/init_64.c +8 −9
  5. arch/powerpc/mm/mem.c +5 −6
  6. arch/s390/mm/init.c +4 −3
  7. arch/s390/mm/vmem.c +4 −2
  8. arch/sh/mm/init.c +5 −5
  9. arch/sparc/mm/init_64.c +3 −2
  10. arch/x86/mm/init_32.c +5 −4
  11. arch/x86/mm/init_64.c +52 −42
  12. drivers/acpi/nfit/core.c +26 −0
  13. drivers/acpi/nfit/nfit.h +1 −0
  14. drivers/dax/device.c +1 −1
  15. drivers/dax/pmem.c +11 −9
  16. drivers/dax/super.c +10 −0
  17. drivers/nvdimm/btt.c +1 −1
  18. drivers/nvdimm/bus.c +0 −3
  19. drivers/nvdimm/namespace_devs.c +1 −1
  20. drivers/nvdimm/nd.h +4 −5
  21. drivers/nvdimm/pfn_devs.c +15 −12
  22. drivers/nvdimm/pmem.c +23 −18
  23. drivers/nvdimm/pmem.h +1 −0
  24. drivers/nvdimm/region_devs.c +13 −0
  25. drivers/s390/block/Kconfig +1 −0
  26. drivers/s390/block/dcssblk.c +2 −1
  27. fs/Kconfig +7 −0
  28. fs/ext2/super.c +5 −2
  29. fs/ext4/super.c +6 −3
  30. include/linux/libnvdimm.h +11 −0
  31. include/linux/memory_hotplug.h +17 −12
  32. include/linux/memremap.h +23 −54
  33. include/linux/mm.h +10 −12
  34. include/linux/pfn_t.h +13 −0
  35. include/uapi/linux/ndctl.h +1 −55
  36. kernel/memremap.c +71 −103
  37. mm/gup.c +5 −2
  38. mm/hmm.c +7 −6
  39. mm/memory.c +15 −1
  40. mm/memory_hotplug.c +18 −21
  41. mm/page_alloc.c +3 −3
  42. mm/sparse-vmemmap.c +23 −44
  43. mm/sparse.c +25 −18
  44. tools/testing/nvdimm/Kbuild +4 −0
  45. tools/testing/nvdimm/acpi_nfit_test.c +8 −0
  46. tools/testing/nvdimm/device_dax_test.c +8 −0
  47. tools/testing/nvdimm/libnvdimm_test.c +8 −0
  48. tools/testing/nvdimm/pmem_test.c +8 −0
  49. tools/testing/nvdimm/test/iomap.c +3 −4
  50. tools/testing/nvdimm/test/nfit.c +450 −48
  51. tools/testing/nvdimm/test/nfit_test.h +134 −0
  52. tools/testing/nvdimm/watermark.h +21 −0
arch/arm64/mm/mmu.c+6−3
@@ -685,12 +685,14 @@ int kern_addr_valid(unsigned long addr) · 684 unmodified lines
685685 }
686686 #ifdef CONFIG_SPARSEMEM_VMEMMAP
687687 #if !ARM64_SWAPPER_USES_SECTION_MAPS
688−int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node)
688+int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node,
689+ struct vmem_altmap *altmap)
689690 {
690691 return vmemmap_populate_basepages(start, end, node);
691692 }
692693 #else /* !ARM64_SWAPPER_USES_SECTION_MAPS */
693−int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node)
694+int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node,
695+ struct vmem_altmap *altmap)
694696 {
695697 unsigned long addr = start;
696698 unsigned long next;
@@ -725,7 +727,8 @@ int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node) · 28 unmodified lines
725727 return 0;
726728 }
727729 #endif /* CONFIG_ARM64_64K_PAGES */
728−void vmemmap_free(unsigned long start, unsigned long end)
730+void vmemmap_free(unsigned long start, unsigned long end,
731+ struct vmem_altmap *altmap)
729732 {
730733 }
731734 #endif /* CONFIG_SPARSEMEM_VMEMMAP */
arch/ia64/mm/discontig.c+4−2
@@ -754,12 +754,14 @@ void arch_refresh_nodedata(int update_node, pg_data_t *update_pgdat) · 753 unmodified lines
754754 #endif
755755
756756 #ifdef CONFIG_SPARSEMEM_VMEMMAP
757−int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node)
757+int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node,
758+ struct vmem_altmap *altmap)
758759 {
759760 return vmemmap_populate_basepages(start, end, node);
760761 }
761762
762−void vmemmap_free(unsigned long start, unsigned long end)
763+void vmemmap_free(unsigned long start, unsigned long end,
764+ struct vmem_altmap *altmap)
763765 {
764766 }
765767 #endif
arch/ia64/mm/init.c+10−8
@@ -501,7 +501,7 @@ virtual_memmap_init(u64 start, u64 end, void *arg) · 500 unmodified lines
501501 if (map_start < map_end)
502502 memmap_init_zone((unsigned long)(map_end - map_start),
503503 args->nid, args->zone, page_to_pfn(map_start),
504− MEMMAP_EARLY);
504+ MEMMAP_EARLY, NULL);
505505 return 0;
506506 }
507507
@@ -509,9 +509,10 @@ void __meminit · 1 unmodified line
509509 memmap_init (unsigned long size, int nid, unsigned long zone,
510510 unsigned long start_pfn)
511511 {
512− if (!vmem_map)
513− memmap_init_zone(size, nid, zone, start_pfn, MEMMAP_EARLY);
514− else {
512+ if (!vmem_map) {
513+ memmap_init_zone(size, nid, zone, start_pfn, MEMMAP_EARLY,
514+ NULL);
515+ } else {
515516 struct page *start;
516517 struct memmap_init_callback_data args;
517518
@@ -647,13 +648,14 @@ mem_init (void) · 129 unmodified lines
647648 }
648649
649650 #ifdef CONFIG_MEMORY_HOTPLUG
650−int arch_add_memory(int nid, u64 start, u64 size, bool want_memblock)
651+int arch_add_memory(int nid, u64 start, u64 size, struct vmem_altmap *altmap,
652+ bool want_memblock)
651653 {
652654 unsigned long start_pfn = start >> PAGE_SHIFT;
653655 unsigned long nr_pages = size >> PAGE_SHIFT;
654656 int ret;
655657
656− ret = __add_pages(nid, start_pfn, nr_pages, want_memblock);
658+ ret = __add_pages(nid, start_pfn, nr_pages, altmap, want_memblock);
657659 if (ret)
658660 printk("%s: Problem encountered in __add_pages() as ret=%d\n",
659661 __func__, ret);
@@ -662,7 +664,7 @@ int arch_add_memory(int nid, u64 start, u64 size, bool want_memblock) · 2 unmodified lines
662664 }
663665
664666 #ifdef CONFIG_MEMORY_HOTREMOVE
665−int arch_remove_memory(u64 start, u64 size)
667+int arch_remove_memory(u64 start, u64 size, struct vmem_altmap *altmap)
666668 {
667669 unsigned long start_pfn = start >> PAGE_SHIFT;
668670 unsigned long nr_pages = size >> PAGE_SHIFT;
@@ -670,7 +672,7 @@ int arch_remove_memory(u64 start, u64 size) · 1 unmodified line
670672 int ret;
671673
672674 zone = page_zone(pfn_to_page(start_pfn));
673− ret = __remove_pages(zone, start_pfn, nr_pages);
675+ ret = __remove_pages(zone, start_pfn, nr_pages, altmap);
674676 if (ret)
675677 pr_warn("%s: Problem encountered in __remove_pages() as"
676678 " ret=%d\n", __func__, ret);
arch/powerpc/mm/init_64.c+8−9
@@ -183,7 +183,8 @@ static __meminit void vmemmap_list_populate(unsigned long phys, · 182 unmodified lines
183183 vmemmap_list = vmem_back;
184184 }
185185
186−int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node)
186+int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node,
187+ struct vmem_altmap *altmap)
187188 {
188189 unsigned long page_size = 1 << mmu_psize_defs[mmu_vmemmap_psize].shift;
189190
@@ -193,17 +194,16 @@ int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node) · 3 unmodified lines
193194 pr_debug("vmemmap_populate %lx..%lx, node %d\n", start, end, node);
194195
195196 for (; start < end; start += page_size) {
196− struct vmem_altmap *altmap;
197197 void *p;
198198 int rc;
199199
200200 if (vmemmap_populated(start, page_size))
201201 continue;
202202
203− /* altmap lookups only work at section boundaries */
204− altmap = to_vmem_altmap(SECTION_ALIGN_DOWN(start));
205−
206− p = __vmemmap_alloc_block_buf(page_size, node, altmap);
203+ if (altmap)
204+ p = altmap_alloc_block_buf(page_size, altmap);
205+ else
206+ p = vmemmap_alloc_block_buf(page_size, node);
207207 if (!p)
208208 return -ENOMEM;
209209
@@ -256,7 +256,8 @@ static unsigned long vmemmap_list_free(unsigned long start) · 46 unmodified lines
256256 return vmem_back->phys;
257257 }
258258
259−void __ref vmemmap_free(unsigned long start, unsigned long end)
259+void __ref vmemmap_free(unsigned long start, unsigned long end,
260+ struct vmem_altmap *altmap)
260261 {
261262 unsigned long page_size = 1 << mmu_psize_defs[mmu_vmemmap_psize].shift;
262263 unsigned long page_order = get_order(page_size);
@@ -267,7 +268,6 @@ void __ref vmemmap_free(unsigned long start, unsigned long end) · 4 unmodified lines
267268
268269 for (; start < end; start += page_size) {
269270 unsigned long nr_pages, addr;
270− struct vmem_altmap *altmap;
271271 struct page *section_base;
272272 struct page *page;
273273
@@ -287,7 +287,6 @@ void __ref vmemmap_free(unsigned long start, unsigned long end) · 13 unmodified lines
287287 section_base = pfn_to_page(vmemmap_section_start(start));
288288 nr_pages = 1 << page_order;
289289
290− altmap = to_vmem_altmap((unsigned long) section_base);
291290 if (altmap) {
292291 vmem_altmap_free(altmap, nr_pages);
293292 } else if (PageReserved(page)) {
arch/powerpc/mm/mem.c+5−6
@@ -127,7 +127,8 @@ int __weak remove_section_mapping(unsigned long start, unsigned long end) · 126 unmodified lines
127127 return -ENODEV;
128128 }
129129
130−int arch_add_memory(int nid, u64 start, u64 size, bool want_memblock)
130+int arch_add_memory(int nid, u64 start, u64 size, struct vmem_altmap *altmap,
131+ bool want_memblock)
131132 {
132133 unsigned long start_pfn = start >> PAGE_SHIFT;
133134 unsigned long nr_pages = size >> PAGE_SHIFT;
@@ -143,15 +144,14 @@ int arch_add_memory(int nid, u64 start, u64 size, bool want_memblock) · 9 unmodified lines
143144 return -EFAULT;
144145 }
145146
146− return __add_pages(nid, start_pfn, nr_pages, want_memblock);
147+ return __add_pages(nid, start_pfn, nr_pages, altmap, want_memblock);
147148 }
148149
149150 #ifdef CONFIG_MEMORY_HOTREMOVE
150−int arch_remove_memory(u64 start, u64 size)
151+int arch_remove_memory(u64 start, u64 size, struct vmem_altmap *altmap)
151152 {
152153 unsigned long start_pfn = start >> PAGE_SHIFT;
153154 unsigned long nr_pages = size >> PAGE_SHIFT;
154− struct vmem_altmap *altmap;
155155 struct page *page;
156156 int ret;
157157
@@ -160,11 +160,10 @@ int arch_remove_memory(u64 start, u64 size) · 2 unmodified lines
160160 * when querying the zone.
161161 */
162162 page = pfn_to_page(start_pfn);
163− altmap = to_vmem_altmap((unsigned long) page);
164163 if (altmap)
165164 page += vmem_altmap_offset(altmap);
166165
167− ret = __remove_pages(page_zone(page), start_pfn, nr_pages);
166+ ret = __remove_pages(page_zone(page), start_pfn, nr_pages, altmap);
168167 if (ret)
169168 return ret;
170169
arch/s390/mm/init.c+4−3
@@ -222,7 +222,8 @@ device_initcall(s390_cma_mem_init); · 221 unmodified lines
222222
223223 #endif /* CONFIG_CMA */
224224
225−int arch_add_memory(int nid, u64 start, u64 size, bool want_memblock)
225+int arch_add_memory(int nid, u64 start, u64 size, struct vmem_altmap *altmap,
226+ bool want_memblock)
226227 {
227228 unsigned long start_pfn = PFN_DOWN(start);
228229 unsigned long size_pages = PFN_DOWN(size);
@@ -232,14 +233,14 @@ int arch_add_memory(int nid, u64 start, u64 size, bool want_memblock) · 3 unmodified lines
232233 if (rc)
233234 return rc;
234235
235− rc = __add_pages(nid, start_pfn, size_pages, want_memblock);
236+ rc = __add_pages(nid, start_pfn, size_pages, altmap, want_memblock);
236237 if (rc)
237238 vmem_remove_mapping(start, size);
238239 return rc;
239240 }
240241
241242 #ifdef CONFIG_MEMORY_HOTREMOVE
242−int arch_remove_memory(u64 start, u64 size)
243+int arch_remove_memory(u64 start, u64 size, struct vmem_altmap *altmap)
243244 {
244245 /*
245246 * There is no hardware or firmware interface which could trigger a
arch/s390/mm/vmem.c+4−2
@@ -211,7 +211,8 @@ static void vmem_remove_range(unsigned long start, unsigned long size) · 210 unmodified lines
211211 /*
212212 * Add a backed mem_map array to the virtual mem_map array.
213213 */
214−int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node)
214+int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node,
215+ struct vmem_altmap *altmap)
215216 {
216217 unsigned long pgt_prot, sgt_prot;
217218 unsigned long address = start;
@@ -296,7 +297,8 @@ out: · 78 unmodified lines
296297 return ret;
297298 }
298299
299−void vmemmap_free(unsigned long start, unsigned long end)
300+void vmemmap_free(unsigned long start, unsigned long end,
301+ struct vmem_altmap *altmap)
300302 {
301303 }
302304
arch/sh/mm/init.c+5−5
@@ -485,20 +485,20 @@ void free_initrd_mem(unsigned long start, unsigned long end) · 484 unmodified lines
485485 #endif
486486
487487 #ifdef CONFIG_MEMORY_HOTPLUG
488−int arch_add_memory(int nid, u64 start, u64 size, bool want_memblock)
488+int arch_add_memory(int nid, u64 start, u64 size, struct vmem_altmap *altmap,
489+ bool want_memblock)
489490 {
490491 unsigned long start_pfn = PFN_DOWN(start);
491492 unsigned long nr_pages = size >> PAGE_SHIFT;
492493 int ret;
493494
494495 /* We only have ZONE_NORMAL, so this is easy.. */
495− ret = __add_pages(nid, start_pfn, nr_pages, want_memblock);
496+ ret = __add_pages(nid, start_pfn, nr_pages, altmap, want_memblock);
496497 if (unlikely(ret))
497498 printk("%s: Failed, __add_pages() == %d\n", __func__, ret);
498499
499500 return ret;
500501 }
501−EXPORT_SYMBOL_GPL(arch_add_memory);
502502
503503 #ifdef CONFIG_NUMA
504504 int memory_add_physaddr_to_nid(u64 addr)
@@ -510,7 +510,7 @@ EXPORT_SYMBOL_GPL(memory_add_physaddr_to_nid); · 5 unmodified lines
510510 #endif
511511
512512 #ifdef CONFIG_MEMORY_HOTREMOVE
513−int arch_remove_memory(u64 start, u64 size)
513+int arch_remove_memory(u64 start, u64 size, struct vmem_altmap *altmap)
514514 {
515515 unsigned long start_pfn = PFN_DOWN(start);
516516 unsigned long nr_pages = size >> PAGE_SHIFT;
@@ -518,7 +518,7 @@ int arch_remove_memory(u64 start, u64 size) · 1 unmodified line
518518 int ret;
519519
520520 zone = page_zone(pfn_to_page(start_pfn));
521− ret = __remove_pages(zone, start_pfn, nr_pages);
521+ ret = __remove_pages(zone, start_pfn, nr_pages, altmap);
522522 if (unlikely(ret))
523523 pr_warn("%s: Failed, __remove_pages() == %d\n", __func__,
524524 ret);
arch/sparc/mm/init_64.c+3−2
@@ -2628,7 +2628,7 @@ EXPORT_SYMBOL(_PAGE_CACHE); · 2627 unmodified lines
26282628
26292629 #ifdef CONFIG_SPARSEMEM_VMEMMAP
26302630 int __meminit vmemmap_populate(unsigned long vstart, unsigned long vend,
2631− int node)
2631+ int node, struct vmem_altmap *altmap)
26322632 {
26332633 unsigned long pte_base;
26342634
@@ -2671,7 +2671,8 @@ int __meminit vmemmap_populate(unsigned long vstart, unsigned long vend, · 36 unmodified lines
26712671 return 0;
26722672 }
26732673
2674−void vmemmap_free(unsigned long start, unsigned long end)
2674+void vmemmap_free(unsigned long start, unsigned long end,
2675+ struct vmem_altmap *altmap)
26752676 {
26762677 }
26772678 #endif /* CONFIG_SPARSEMEM_VMEMMAP */
arch/x86/mm/init_32.c+5−4
@@ -829,23 +829,24 @@ void __init mem_init(void) · 828 unmodified lines
829829 }
830830
831831 #ifdef CONFIG_MEMORY_HOTPLUG
832−int arch_add_memory(int nid, u64 start, u64 size, bool want_memblock)
832+int arch_add_memory(int nid, u64 start, u64 size, struct vmem_altmap *altmap,
833+ bool want_memblock)
833834 {
834835 unsigned long start_pfn = start >> PAGE_SHIFT;
835836 unsigned long nr_pages = size >> PAGE_SHIFT;
836837
837− return __add_pages(nid, start_pfn, nr_pages, want_memblock);
838+ return __add_pages(nid, start_pfn, nr_pages, altmap, want_memblock);
838839 }
839840
840841 #ifdef CONFIG_MEMORY_HOTREMOVE
841−int arch_remove_memory(u64 start, u64 size)
842+int arch_remove_memory(u64 start, u64 size, struct vmem_altmap *altmap)
842843 {
843844 unsigned long start_pfn = start >> PAGE_SHIFT;
844845 unsigned long nr_pages = size >> PAGE_SHIFT;
845846 struct zone *zone;
846847
847848 zone = page_zone(pfn_to_page(start_pfn));
848− return __remove_pages(zone, start_pfn, nr_pages);
849+ return __remove_pages(zone, start_pfn, nr_pages, altmap);
849850 }
850851 #endif
851852 #endif
arch/x86/mm/init_64.c+52−42
@@ -772,12 +772,12 @@ static void update_end_of_memory_vars(u64 start, u64 size) · 771 unmodified lines
772772 }
773773 }
774774
775−int add_pages(int nid, unsigned long start_pfn,
776− unsigned long nr_pages, bool want_memblock)
775+int add_pages(int nid, unsigned long start_pfn, unsigned long nr_pages,
776+ struct vmem_altmap *altmap, bool want_memblock)
777777 {
778778 int ret;
779779
780− ret = __add_pages(nid, start_pfn, nr_pages, want_memblock);
780+ ret = __add_pages(nid, start_pfn, nr_pages, altmap, want_memblock);
781781 WARN_ON_ONCE(ret);
782782
783783 /* update max_pfn, max_low_pfn and high_memory */
@@ -787,24 +787,24 @@ int add_pages(int nid, unsigned long start_pfn, · 3 unmodified lines
787787 return ret;
788788 }
789789
790−int arch_add_memory(int nid, u64 start, u64 size, bool want_memblock)
790+int arch_add_memory(int nid, u64 start, u64 size, struct vmem_altmap *altmap,
791+ bool want_memblock)
791792 {
792793 unsigned long start_pfn = start >> PAGE_SHIFT;
793794 unsigned long nr_pages = size >> PAGE_SHIFT;
794795
795796 init_memory_mapping(start, start + size);
796797
797− return add_pages(nid, start_pfn, nr_pages, want_memblock);
798+ return add_pages(nid, start_pfn, nr_pages, altmap, want_memblock);
798799 }
799−EXPORT_SYMBOL_GPL(arch_add_memory);
800800
801801 #define PAGE_INUSE 0xFD
802802
803−static void __meminit free_pagetable(struct page *page, int order)
803+static void __meminit free_pagetable(struct page *page, int order,
804+ struct vmem_altmap *altmap)
804805 {
805806 unsigned long magic;
806807 unsigned int nr_pages = 1 << order;
807− struct vmem_altmap *altmap = to_vmem_altmap((unsigned long) page);
808808
809809 if (altmap) {
810810 vmem_altmap_free(altmap, nr_pages);
@@ -826,7 +826,8 @@ static void __meminit free_pagetable(struct page *page, int order) · 15 unmodified lines
826826 free_pages((unsigned long)page_address(page), order);
827827 }
828828
829−static void __meminit free_pte_table(pte_t *pte_start, pmd_t *pmd)
829+static void __meminit free_pte_table(pte_t *pte_start, pmd_t *pmd,
830+ struct vmem_altmap *altmap)
830831 {
831832 pte_t *pte;
832833 int i;
@@ -838,13 +839,14 @@ static void __meminit free_pte_table(pte_t *pte_start, pmd_t *pmd) · 5 unmodified lines
838839 }
839840
840841 /* free a pte talbe */
841− free_pagetable(pmd_page(*pmd), 0);
842+ free_pagetable(pmd_page(*pmd), 0, altmap);
842843 spin_lock(&init_mm.page_table_lock);
843844 pmd_clear(pmd);
844845 spin_unlock(&init_mm.page_table_lock);
845846 }
846847
847−static void __meminit free_pmd_table(pmd_t *pmd_start, pud_t *pud)
848+static void __meminit free_pmd_table(pmd_t *pmd_start, pud_t *pud,
849+ struct vmem_altmap *altmap)
848850 {
849851 pmd_t *pmd;
850852 int i;
@@ -856,13 +858,14 @@ static void __meminit free_pmd_table(pmd_t *pmd_start, pud_t *pud) · 5 unmodified lines
856858 }
857859
858860 /* free a pmd talbe */
859− free_pagetable(pud_page(*pud), 0);
861+ free_pagetable(pud_page(*pud), 0, altmap);
860862 spin_lock(&init_mm.page_table_lock);
861863 pud_clear(pud);
862864 spin_unlock(&init_mm.page_table_lock);
863865 }
864866
865−static void __meminit free_pud_table(pud_t *pud_start, p4d_t *p4d)
867+static void __meminit free_pud_table(pud_t *pud_start, p4d_t *p4d,
868+ struct vmem_altmap *altmap)
866869 {
867870 pud_t *pud;
868871 int i;
@@ -874,7 +877,7 @@ static void __meminit free_pud_table(pud_t *pud_start, p4d_t *p4d) · 5 unmodified lines
874877 }
875878
876879 /* free a pud talbe */
877− free_pagetable(p4d_page(*p4d), 0);
880+ free_pagetable(p4d_page(*p4d), 0, altmap);
878881 spin_lock(&init_mm.page_table_lock);
879882 p4d_clear(p4d);
880883 spin_unlock(&init_mm.page_table_lock);
@@ -882,7 +885,7 @@ static void __meminit free_pud_table(pud_t *pud_start, p4d_t *p4d) · 1 unmodified line
882885
883886 static void __meminit
884887 remove_pte_table(pte_t *pte_start, unsigned long addr, unsigned long end,
885− bool direct)
888+ struct vmem_altmap *altmap, bool direct)
886889 {
887890 unsigned long next, pages = 0;
888891 pte_t *pte;
@@ -913,7 +916,7 @@ remove_pte_table(pte_t *pte_start, unsigned long addr, unsigned long end, · 24 unmodified lines
913916 * freed when offlining, or simplely not in use.
914917 */
915918 if (!direct)
916− free_pagetable(pte_page(*pte), 0);
919+ free_pagetable(pte_page(*pte), 0, altmap);
917920
918921 spin_lock(&init_mm.page_table_lock);
919922 pte_clear(&init_mm, addr, pte);
@@ -936,7 +939,7 @@ remove_pte_table(pte_t *pte_start, unsigned long addr, unsigned long end, · 16 unmodified lines
936939
937940 page_addr = page_address(pte_page(*pte));
938941 if (!memchr_inv(page_addr, PAGE_INUSE, PAGE_SIZE)) {
939− free_pagetable(pte_page(*pte), 0);
942+ free_pagetable(pte_page(*pte), 0, altmap);
940943
941944 spin_lock(&init_mm.page_table_lock);
942945 pte_clear(&init_mm, addr, pte);
@@ -953,7 +956,7 @@ remove_pte_table(pte_t *pte_start, unsigned long addr, unsigned long end, · 10 unmodified lines
953956
954957 static void __meminit
955958 remove_pmd_table(pmd_t *pmd_start, unsigned long addr, unsigned long end,
956− bool direct)
959+ bool direct, struct vmem_altmap *altmap)
957960 {
958961 unsigned long next, pages = 0;
959962 pte_t *pte_base;
@@ -972,7 +975,8 @@ remove_pmd_table(pmd_t *pmd_start, unsigned long addr, unsigned long end, · 12 unmodified lines
972975 IS_ALIGNED(next, PMD_SIZE)) {
973976 if (!direct)
974977 free_pagetable(pmd_page(*pmd),
975− get_order(PMD_SIZE));
978+ get_order(PMD_SIZE),
979+ altmap);
976980
977981 spin_lock(&init_mm.page_table_lock);
978982 pmd_clear(pmd);
@@ -986,7 +990,8 @@ remove_pmd_table(pmd_t *pmd_start, unsigned long addr, unsigned long end, · 7 unmodified lines
986990 if (!memchr_inv(page_addr, PAGE_INUSE,
987991 PMD_SIZE)) {
988992 free_pagetable(pmd_page(*pmd),
989− get_order(PMD_SIZE));
993+ get_order(PMD_SIZE),
994+ altmap);
990995
991996 spin_lock(&init_mm.page_table_lock);
992997 pmd_clear(pmd);
@@ -998,8 +1003,8 @@ remove_pmd_table(pmd_t *pmd_start, unsigned long addr, unsigned long end, · 5 unmodified lines
9981003 }
9991004
10001005 pte_base = (pte_t *)pmd_page_vaddr(*pmd);
1001− remove_pte_table(pte_base, addr, next, direct);
1002− free_pte_table(pte_base, pmd);
1006+ remove_pte_table(pte_base, addr, next, altmap, direct);
1007+ free_pte_table(pte_base, pmd, altmap);
10031008 }
10041009
10051010 /* Call free_pmd_table() in remove_pud_table(). */
@@ -1009,7 +1014,7 @@ remove_pmd_table(pmd_t *pmd_start, unsigned long addr, unsigned long end, · 3 unmodified lines
10091014
10101015 static void __meminit
10111016 remove_pud_table(pud_t *pud_start, unsigned long addr, unsigned long end,
1012− bool direct)
1017+ struct vmem_altmap *altmap, bool direct)
10131018 {
10141019 unsigned long next, pages = 0;
10151020 pmd_t *pmd_base;
@@ -1028,7 +1033,8 @@ remove_pud_table(pud_t *pud_start, unsigned long addr, unsigned long end, · 12 unmodified lines
10281033 IS_ALIGNED(next, PUD_SIZE)) {
10291034 if (!direct)
10301035 free_pagetable(pud_page(*pud),
1031− get_order(PUD_SIZE));
1036+ get_order(PUD_SIZE),
1037+ altmap);
10321038
10331039 spin_lock(&init_mm.page_table_lock);
10341040 pud_clear(pud);
@@ -1042,7 +1048,8 @@ remove_pud_table(pud_t *pud_start, unsigned long addr, unsigned long end, · 7 unmodified lines
10421048 if (!memchr_inv(page_addr, PAGE_INUSE,
10431049 PUD_SIZE)) {
10441050 free_pagetable(pud_page(*pud),
1045− get_order(PUD_SIZE));
1051+ get_order(PUD_SIZE),
1052+ altmap);
10461053
10471054 spin_lock(&init_mm.page_table_lock);
10481055 pud_clear(pud);
@@ -1054,8 +1061,8 @@ remove_pud_table(pud_t *pud_start, unsigned long addr, unsigned long end, · 5 unmodified lines
10541061 }
10551062
10561063 pmd_base = pmd_offset(pud, 0);
1057− remove_pmd_table(pmd_base, addr, next, direct);
1058− free_pmd_table(pmd_base, pud);
1064+ remove_pmd_table(pmd_base, addr, next, direct, altmap);
1065+ free_pmd_table(pmd_base, pud, altmap);
10591066 }
10601067
10611068 if (direct)
@@ -1064,7 +1071,7 @@ remove_pud_table(pud_t *pud_start, unsigned long addr, unsigned long end, · 2 unmodified lines
10641071
10651072 static void __meminit
10661073 remove_p4d_table(p4d_t *p4d_start, unsigned long addr, unsigned long end,
1067− bool direct)
1074+ struct vmem_altmap *altmap, bool direct)
10681075 {
10691076 unsigned long next, pages = 0;
10701077 pud_t *pud_base;
@@ -1080,14 +1087,14 @@ remove_p4d_table(p4d_t *p4d_start, unsigned long addr, unsigned long end, · 9 unmodified lines
10801087 BUILD_BUG_ON(p4d_large(*p4d));
10811088
10821089 pud_base = pud_offset(p4d, 0);
1083− remove_pud_table(pud_base, addr, next, direct);
1090+ remove_pud_table(pud_base, addr, next, altmap, direct);
10841091 /*
10851092 * For 4-level page tables we do not want to free PUDs, but in the
10861093 * 5-level case we should free them. This code will have to change
10871094 * to adapt for boot-time switching between 4 and 5 level page tables.
10881095 */
10891096 if (CONFIG_PGTABLE_LEVELS == 5)
1090− free_pud_table(pud_base, p4d);
1097+ free_pud_table(pud_base, p4d, altmap);
10911098 }
10921099
10931100 if (direct)
@@ -1096,7 +1103,8 @@ remove_p4d_table(p4d_t *p4d_start, unsigned long addr, unsigned long end, · 2 unmodified lines
10961103
10971104 /* start and end are both virtual address. */
10981105 static void __meminit
1099−remove_pagetable(unsigned long start, unsigned long end, bool direct)
1106+remove_pagetable(unsigned long start, unsigned long end, bool direct,
1107+ struct vmem_altmap *altmap)
11001108 {
11011109 unsigned long next;
11021110 unsigned long addr;
@@ -1111,15 +1119,16 @@ remove_pagetable(unsigned long start, unsigned long end, bool direct) · 8 unmodified lines
11111119 continue;
11121120
11131121 p4d = p4d_offset(pgd, 0);
1114− remove_p4d_table(p4d, addr, next, direct);
1122+ remove_p4d_table(p4d, addr, next, altmap, direct);
11151123 }
11161124
11171125 flush_tlb_all();
11181126 }
11191127
1120−void __ref vmemmap_free(unsigned long start, unsigned long end)
1128+void __ref vmemmap_free(unsigned long start, unsigned long end,
1129+ struct vmem_altmap *altmap)
11211130 {
1122− remove_pagetable(start, end, false);
1131+ remove_pagetable(start, end, false, altmap);
11231132 }
11241133
11251134 #ifdef CONFIG_MEMORY_HOTREMOVE
@@ -1129,24 +1138,22 @@ kernel_physical_mapping_remove(unsigned long start, unsigned long end) · 3 unmodified lines
11291138 start = (unsigned long)__va(start);
11301139 end = (unsigned long)__va(end);
11311140
1132− remove_pagetable(start, end, true);
1141+ remove_pagetable(start, end, true, NULL);
11331142 }
11341143
1135−int __ref arch_remove_memory(u64 start, u64 size)
1144+int __ref arch_remove_memory(u64 start, u64 size, struct vmem_altmap *altmap)
11361145 {
11371146 unsigned long start_pfn = start >> PAGE_SHIFT;
11381147 unsigned long nr_pages = size >> PAGE_SHIFT;
11391148 struct page *page = pfn_to_page(start_pfn);
1140− struct vmem_altmap *altmap;
11411149 struct zone *zone;
11421150 int ret;
11431151
11441152 /* With altmap the first mapped page is offset from @start */
1145− altmap = to_vmem_altmap((unsigned long) page);
11461153 if (altmap)
11471154 page += vmem_altmap_offset(altmap);
11481155 zone = page_zone(page);
1149− ret = __remove_pages(zone, start_pfn, nr_pages);
1156+ ret = __remove_pages(zone, start_pfn, nr_pages, altmap);
11501157 WARN_ON_ONCE(ret);
11511158 kernel_physical_mapping_remove(start, start + size);
11521159
@@ -1378,7 +1385,10 @@ static int __meminit vmemmap_populate_hugepages(unsigned long start, · 225 unmodified lines
13781385 if (pmd_none(*pmd)) {
13791386 void *p;
13801387
1381− p = __vmemmap_alloc_block_buf(PMD_SIZE, node, altmap);
1388+ if (altmap)
1389+ p = altmap_alloc_block_buf(PMD_SIZE, altmap);
1390+ else
1391+ p = vmemmap_alloc_block_buf(PMD_SIZE, node);
13821392 if (p) {
13831393 pte_t entry;
13841394
@@ -1411,9 +1421,9 @@ static int __meminit vmemmap_populate_hugepages(unsigned long start, · 26 unmodified lines
14111421 return 0;
14121422 }
14131423
1414−int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node)
1424+int __meminit vmemmap_populate(unsigned long start, unsigned long end, int node,
1425+ struct vmem_altmap *altmap)
14151426 {
1416− struct vmem_altmap *altmap = to_vmem_altmap(start);
14171427 int err;
14181428
14191429 if (boot_cpu_has(X86_FEATURE_PSE))
drivers/acpi/nfit/core.c+26−0
@@ -838,6 +838,18 @@ static bool add_flush(struct acpi_nfit_desc *acpi_desc, · 837 unmodified lines
838838 return true;
839839 }
840840
841+static bool add_platform_cap(struct acpi_nfit_desc *acpi_desc,
842+ struct acpi_nfit_capabilities *pcap)
843+{
844+ struct device *dev = acpi_desc->dev;
845+ u32 mask;
846+
847+ mask = (1 << (pcap->highest_capability + 1)) - 1;
848+ acpi_desc->platform_cap = pcap->capabilities & mask;
849+ dev_dbg(dev, "%s: cap: %#x\n", __func__, acpi_desc->platform_cap);
850+ return true;
851+}
852+
841853 static void *add_table(struct acpi_nfit_desc *acpi_desc,
842854 struct nfit_table_prev *prev, void *table, const void *end)
843855 {
@@ -883,6 +895,10 @@ static void *add_table(struct acpi_nfit_desc *acpi_desc, · 39 unmodified lines
883895 case ACPI_NFIT_TYPE_SMBIOS:
884896 dev_dbg(dev, "%s: smbios\n", __func__);
885897 break;
898+ case ACPI_NFIT_TYPE_CAPABILITIES:
899+ if (!add_platform_cap(acpi_desc, table))
900+ return err;
901+ break;
886902 default:
887903 dev_err(dev, "unknown table '%d' parsing nfit\n", hdr->type);
888904 break;
@@ -1867,6 +1883,9 @@ static int acpi_nfit_register_dimms(struct acpi_nfit_desc *acpi_desc) · 978 unmodified lines
18671883 struct kernfs_node *nfit_kernfs;
18681884
18691885 nvdimm = nfit_mem->nvdimm;
1886+ if (!nvdimm)
1887+ continue;
1888+
18701889 nfit_kernfs = sysfs_get_dirent(nvdimm_kobj(nvdimm)->sd, "nfit");
18711890 if (nfit_kernfs)
18721891 nfit_mem->flags_attr = sysfs_get_dirent(nfit_kernfs,
@@ -2656,6 +2675,12 @@ static int acpi_nfit_register_region(struct acpi_nfit_desc *acpi_desc, · 783 unmodified lines
26562675 else
26572676 ndr_desc->numa_node = NUMA_NO_NODE;
26582677
2678+ if(acpi_desc->platform_cap & ACPI_NFIT_CAPABILITY_CACHE_FLUSH)
2679+ set_bit(ND_REGION_PERSIST_CACHE, &ndr_desc->flags);
2680+
2681+ if (acpi_desc->platform_cap & ACPI_NFIT_CAPABILITY_MEM_FLUSH)
2682+ set_bit(ND_REGION_PERSIST_MEMCTRL, &ndr_desc->flags);
2683+
26592684 list_for_each_entry(nfit_memdev, &acpi_desc->memdevs, list) {
26602685 struct acpi_nfit_memory_map *memdev = nfit_memdev->memdev;
26612686 struct nd_mapping_desc *mapping;
@@ -3464,6 +3489,7 @@ static __init int nfit_init(void) · 802 unmodified lines
34643489 BUILD_BUG_ON(sizeof(struct acpi_nfit_smbios) != 9);
34653490 BUILD_BUG_ON(sizeof(struct acpi_nfit_control_region) != 80);
34663491 BUILD_BUG_ON(sizeof(struct acpi_nfit_data_region) != 40);
3492+ BUILD_BUG_ON(sizeof(struct acpi_nfit_capabilities) != 16);
34673493
34683494 guid_parse(UUID_VOLATILE_MEMORY, &nfit_uuid[NFIT_SPA_VOLATILE]);
34693495 guid_parse(UUID_PERSISTENT_MEMORY, &nfit_uuid[NFIT_SPA_PM]);
drivers/acpi/nfit/nfit.h+1−0
@@ -202,6 +202,7 @@ struct acpi_nfit_desc { · 201 unmodified lines
202202 unsigned long dimm_cmd_force_en;
203203 unsigned long bus_cmd_force_en;
204204 unsigned long bus_nfit_cmd_force_en;
205+ unsigned int platform_cap;
205206 int (*blk_do_io)(struct nd_blk_region *ndbr, resource_size_t dpa,
206207 void *iobuf, u64 len, int rw);
207208 };
drivers/dax/device.c+1−1
@@ -133,7 +133,7 @@ struct dax_region *alloc_dax_region(struct device *parent, int region_id, · 132 unmodified lines
133133 dax_region->base = addr;
134134 if (sysfs_create_groups(&parent->kobj, dax_region_attribute_groups)) {
135135 kfree(dax_region);
136− return NULL;;
136+ return NULL;
137137 }
138138
139139 kref_get(&dax_region->kref);
drivers/dax/pmem.c+11−9
@@ -21,6 +21,7 @@ · 20 unmodified lines
2121 struct dax_pmem {
2222 struct device *dev;
2323 struct percpu_ref ref;
24+ struct dev_pagemap pgmap;
2425 struct completion cmp;
2526 };
2627
@@ -69,20 +70,23 @@ static int dax_pmem_probe(struct device *dev) · 42 unmodified lines
6970 struct nd_namespace_common *ndns;
7071 struct nd_dax *nd_dax = to_nd_dax(dev);
7172 struct nd_pfn *nd_pfn = &nd_dax->nd_pfn;
72− struct vmem_altmap __altmap, *altmap = NULL;
7373
7474 ndns = nvdimm_namespace_common_probe(dev);
7575 if (IS_ERR(ndns))
7676 return PTR_ERR(ndns);
7777 nsio = to_nd_namespace_io(&ndns->dev);
7878
79+ dax_pmem = devm_kzalloc(dev, sizeof(*dax_pmem), GFP_KERNEL);
80+ if (!dax_pmem)
81+ return -ENOMEM;
82+
7983 /* parse the 'pfn' info block via ->rw_bytes */
8084 rc = devm_nsio_enable(dev, nsio);
8185 if (rc)
8286 return rc;
83− altmap = nvdimm_setup_pfn(nd_pfn, &res, &__altmap);
84− if (IS_ERR(altmap))
85− return PTR_ERR(altmap);
87+ rc = nvdimm_setup_pfn(nd_pfn, &dax_pmem->pgmap);
88+ if (rc)
89+ return rc;
8690 devm_nsio_disable(dev, nsio);
8791
8892 pfn_sb = nd_pfn->pfn_sb;
@@ -94,10 +98,6 @@ static int dax_pmem_probe(struct device *dev) · 5 unmodified lines
9498 return -EBUSY;
9599 }
96100
97− dax_pmem = devm_kzalloc(dev, sizeof(*dax_pmem), GFP_KERNEL);
98− if (!dax_pmem)
99− return -ENOMEM;
100−
101101 dax_pmem->dev = dev;
102102 init_completion(&dax_pmem->cmp);
103103 rc = percpu_ref_init(&dax_pmem->ref, dax_pmem_percpu_release, 0,
@@ -110,7 +110,8 @@ static int dax_pmem_probe(struct device *dev) · 6 unmodified lines
110110 if (rc)
111111 return rc;
112112
113− addr = devm_memremap_pages(dev, &res, &dax_pmem->ref, altmap);
113+ dax_pmem->pgmap.ref = &dax_pmem->ref;
114+ addr = devm_memremap_pages(dev, &dax_pmem->pgmap);
114115 if (IS_ERR(addr))
115116 return PTR_ERR(addr);
116117
@@ -120,6 +121,7 @@ static int dax_pmem_probe(struct device *dev) · 3 unmodified lines
120121 return rc;
121122
122123 /* adjust the dax_region resource to the start of data */
124+ memcpy(&res, &dax_pmem->pgmap.res, sizeof(res));
123125 res.start += le64_to_cpu(pfn_sb->dataoff);
124126
125127 rc = sscanf(dev_name(&ndns->dev), "namespace%d.%d", &region_id, &id);
drivers/dax/super.c+10−0
@@ -15,6 +15,7 @@ · 14 unmodified lines
1515 #include <linux/mount.h>
1616 #include <linux/magic.h>
1717 #include <linux/genhd.h>
18+#include <linux/pfn_t.h>
1819 #include <linux/cdev.h>
1920 #include <linux/hash.h>
2021 #include <linux/slab.h>
@@ -123,6 +124,15 @@ int __bdev_dax_supported(struct super_block *sb, int blocksize) · 102 unmodified lines
123124 return len < 0 ? len : -EIO;
124125 }
125126
127+ if ((IS_ENABLED(CONFIG_FS_DAX_LIMITED) && pfn_t_special(pfn))
128+ || pfn_t_devmap(pfn))
129+ /* pass */;
130+ else {
131+ pr_debug("VFS (%s): error: dax support not enabled\n",
132+ sb->s_id);
133+ return -EOPNOTSUPP;
134+ }
135+
126136 return 0;
127137 }
128138 EXPORT_SYMBOL_GPL(__bdev_dax_supported);
drivers/nvdimm/btt.c+1−1
@@ -753,6 +753,7 @@ static struct arena_info *alloc_arena(struct btt *btt, size_t size, · 752 unmodified lines
753753 return NULL;
754754 arena->nd_btt = btt->nd_btt;
755755 arena->sector_size = btt->sector_size;
756+ mutex_init(&arena->err_lock);
756757
757758 if (!size)
758759 return arena;
@@ -891,7 +892,6 @@ static int discover_arenas(struct btt *btt) · 132 unmodified lines
891892 goto out;
892893 }
893894
894− mutex_init(&arena->err_lock);
895895 ret = btt_freelist_init(arena);
896896 if (ret)
897897 goto out;
drivers/nvdimm/bus.c+0−3
@@ -1142,9 +1142,6 @@ int __init nvdimm_bus_init(void) · 1141 unmodified lines
11421142 {
11431143 int rc;
11441144
1145− BUILD_BUG_ON(sizeof(struct nd_smart_payload) != 128);
1146− BUILD_BUG_ON(sizeof(struct nd_smart_threshold_payload) != 8);
1147−
11481145 rc = bus_register(&nvdimm_bus_type);
11491146 if (rc)
11501147 return rc;
drivers/nvdimm/namespace_devs.c+1−1
@@ -2408,7 +2408,7 @@ static struct device **scan_labels(struct nd_region *nd_region) · 2407 unmodified lines
24082408
24092409 static struct device **create_namespaces(struct nd_region *nd_region)
24102410 {
2411− struct nd_mapping *nd_mapping = &nd_region->mapping[0];
2411+ struct nd_mapping *nd_mapping;
24122412 struct device **devs;
24132413 int i;
24142414
drivers/nvdimm/nd.h+4−5
@@ -368,15 +368,14 @@ unsigned int pmem_sector_size(struct nd_namespace_common *ndns); · 367 unmodified lines
368368 void nvdimm_badblocks_populate(struct nd_region *nd_region,
369369 struct badblocks *bb, const struct resource *res);
370370 #if IS_ENABLED(CONFIG_ND_CLAIM)
371−struct vmem_altmap *nvdimm_setup_pfn(struct nd_pfn *nd_pfn,
372− struct resource *res, struct vmem_altmap *altmap);
371+int nvdimm_setup_pfn(struct nd_pfn *nd_pfn, struct dev_pagemap *pgmap);
373372 int devm_nsio_enable(struct device *dev, struct nd_namespace_io *nsio);
374373 void devm_nsio_disable(struct device *dev, struct nd_namespace_io *nsio);
375374 #else
376−static inline struct vmem_altmap *nvdimm_setup_pfn(struct nd_pfn *nd_pfn,
377− struct resource *res, struct vmem_altmap *altmap)
375+static inline int nvdimm_setup_pfn(struct nd_pfn *nd_pfn,
376+ struct dev_pagemap *pgmap)
378377 {
379− return ERR_PTR(-ENXIO);
378+ return -ENXIO;
380379 }
381380 static inline int devm_nsio_enable(struct device *dev,
382381 struct nd_namespace_io *nsio)
drivers/nvdimm/pfn_devs.c+15−12
@@ -542,9 +542,10 @@ static unsigned long init_altmap_reserve(resource_size_t base) · 541 unmodified lines
542542 return reserve;
543543 }
544544
545−static struct vmem_altmap *__nvdimm_setup_pfn(struct nd_pfn *nd_pfn,
546− struct resource *res, struct vmem_altmap *altmap)
545+static int __nvdimm_setup_pfn(struct nd_pfn *nd_pfn, struct dev_pagemap *pgmap)
547546 {
547+ struct resource *res = &pgmap->res;
548+ struct vmem_altmap *altmap = &pgmap->altmap;
548549 struct nd_pfn_sb *pfn_sb = nd_pfn->pfn_sb;
549550 u64 offset = le64_to_cpu(pfn_sb->dataoff);
550551 u32 start_pad = __le32_to_cpu(pfn_sb->start_pad);
@@ -561,11 +562,13 @@ static struct vmem_altmap *__nvdimm_setup_pfn(struct nd_pfn *nd_pfn, · 10 unmodified lines
561562 res->start += start_pad;
562563 res->end -= end_trunc;
563564
565+ pgmap->type = MEMORY_DEVICE_HOST;
566+
564567 if (nd_pfn->mode == PFN_MODE_RAM) {
565568 if (offset < SZ_8K)
566− return ERR_PTR(-EINVAL);
569+ return -EINVAL;
567570 nd_pfn->npfns = le64_to_cpu(pfn_sb->npfns);
568− altmap = NULL;
571+ pgmap->altmap_valid = false;
569572 } else if (nd_pfn->mode == PFN_MODE_PMEM) {
570573 nd_pfn->npfns = PFN_SECTION_ALIGN_UP((resource_size(res)
571574 - offset) / PAGE_SIZE);
@@ -577,10 +580,11 @@ static struct vmem_altmap *__nvdimm_setup_pfn(struct nd_pfn *nd_pfn, · 5 unmodified lines
577580 memcpy(altmap, &__altmap, sizeof(*altmap));
578581 altmap->free = PHYS_PFN(offset - SZ_8K);
579582 altmap->alloc = 0;
583+ pgmap->altmap_valid = true;
580584 } else
581− return ERR_PTR(-ENXIO);
585+ return -ENXIO;
582586
583− return altmap;
587+ return 0;
584588 }
585589
586590 static u64 phys_pmem_align_down(struct nd_pfn *nd_pfn, u64 phys)
@@ -708,19 +712,18 @@ static int nd_pfn_init(struct nd_pfn *nd_pfn) · 121 unmodified lines
708712 * Determine the effective resource range and vmem_altmap from an nd_pfn
709713 * instance.
710714 */
711−struct vmem_altmap *nvdimm_setup_pfn(struct nd_pfn *nd_pfn,
712− struct resource *res, struct vmem_altmap *altmap)
715+int nvdimm_setup_pfn(struct nd_pfn *nd_pfn, struct dev_pagemap *pgmap)
713716 {
714717 int rc;
715718
716719 if (!nd_pfn->uuid || !nd_pfn->ndns)
717− return ERR_PTR(-ENODEV);
720+ return -ENODEV;
718721
719722 rc = nd_pfn_init(nd_pfn);
720723 if (rc)
721− return ERR_PTR(rc);
724+ return rc;
722725
723− /* we need a valid pfn_sb before we can init a vmem_altmap */
724− return __nvdimm_setup_pfn(nd_pfn, res, altmap);
726+ /* we need a valid pfn_sb before we can init a dev_pagemap */
727+ return __nvdimm_setup_pfn(nd_pfn, pgmap);
725728 }
726729 EXPORT_SYMBOL_GPL(nvdimm_setup_pfn);
drivers/nvdimm/pmem.c+23−18
@@ -35,6 +35,7 @@ · 34 unmodified lines
3535 #include "pmem.h"
3636 #include "pfn.h"
3737 #include "nd.h"
38+#include "nd-core.h"
3839
3940 static struct device *to_dev(struct pmem_device *pmem)
4041 {
@@ -298,34 +299,34 @@ static int pmem_attach_disk(struct device *dev, · 257 unmodified lines
298299 {
299300 struct nd_namespace_io *nsio = to_nd_namespace_io(&ndns->dev);
300301 struct nd_region *nd_region = to_nd_region(dev->parent);
301− struct vmem_altmap __altmap, *altmap = NULL;
302302 int nid = dev_to_node(dev), fua, wbc;
303303 struct resource *res = &nsio->res;
304+ struct resource bb_res;
304305 struct nd_pfn *nd_pfn = NULL;
305306 struct dax_device *dax_dev;
306307 struct nd_pfn_sb *pfn_sb;
307308 struct pmem_device *pmem;
308− struct resource pfn_res;
309309 struct request_queue *q;
310310 struct device *gendev;
311311 struct gendisk *disk;
312312 void *addr;
313+ int rc;
314+
315+ pmem = devm_kzalloc(dev, sizeof(*pmem), GFP_KERNEL);
316+ if (!pmem)
317+ return -ENOMEM;
313318
314319 /* while nsio_rw_bytes is active, parse a pfn info block if present */
315320 if (is_nd_pfn(dev)) {
316321 nd_pfn = to_nd_pfn(dev);
317− altmap = nvdimm_setup_pfn(nd_pfn, &pfn_res, &__altmap);
318− if (IS_ERR(altmap))
319− return PTR_ERR(altmap);
322+ rc = nvdimm_setup_pfn(nd_pfn, &pmem->pgmap);
323+ if (rc)
324+ return rc;
320325 }
321326
322327 /* we're attaching a block device, disable raw namespace access */
323328 devm_nsio_disable(dev, nsio);
324329
325− pmem = devm_kzalloc(dev, sizeof(*pmem), GFP_KERNEL);
326− if (!pmem)
327− return -ENOMEM;
328−
329330 dev_set_drvdata(dev, pmem);
330331 pmem->phys_addr = res->start;
331332 pmem->size = resource_size(res);
@@ -334,7 +335,8 @@ static int pmem_attach_disk(struct device *dev, · 2 unmodified lines
334335 dev_warn(dev, "unable to guarantee persistence of writes\n");
335336 fua = 0;
336337 }
337− wbc = nvdimm_has_cache(nd_region);
338+ wbc = nvdimm_has_cache(nd_region) &&
339+ !test_bit(ND_REGION_PERSIST_CACHE, &nd_region->flags);
338340
339341 if (!devm_request_mem_region(dev, res->start, resource_size(res),
340342 dev_name(&ndns->dev))) {
@@ -350,19 +352,22 @@ static int pmem_attach_disk(struct device *dev, · 9 unmodified lines
350352 return -ENOMEM;
351353
352354 pmem->pfn_flags = PFN_DEV;
355+ pmem->pgmap.ref = &q->q_usage_counter;
353356 if (is_nd_pfn(dev)) {
354− addr = devm_memremap_pages(dev, &pfn_res, &q->q_usage_counter,
355− altmap);
357+ addr = devm_memremap_pages(dev, &pmem->pgmap);
356358 pfn_sb = nd_pfn->pfn_sb;
357359 pmem->data_offset = le64_to_cpu(pfn_sb->dataoff);
358− pmem->pfn_pad = resource_size(res) - resource_size(&pfn_res);
360+ pmem->pfn_pad = resource_size(res) -
361+ resource_size(&pmem->pgmap.res);
359362 pmem->pfn_flags |= PFN_MAP;
360− res = &pfn_res; /* for badblocks populate */
361− res->start += pmem->data_offset;
363+ memcpy(&bb_res, &pmem->pgmap.res, sizeof(bb_res));
364+ bb_res.start += pmem->data_offset;
362365 } else if (pmem_should_map_pages(dev)) {
363− addr = devm_memremap_pages(dev, &nsio->res,
364− &q->q_usage_counter, NULL);
366+ memcpy(&pmem->pgmap.res, &nsio->res, sizeof(pmem->pgmap.res));
367+ pmem->pgmap.altmap_valid = false;
368+ addr = devm_memremap_pages(dev, &pmem->pgmap);
365369 pmem->pfn_flags |= PFN_MAP;
370+ memcpy(&bb_res, &pmem->pgmap.res, sizeof(bb_res));
366371 } else
367372 addr = devm_memremap(dev, pmem->phys_addr,
368373 pmem->size, ARCH_MEMREMAP_PMEM);
@@ -401,7 +406,7 @@ static int pmem_attach_disk(struct device *dev, · 32 unmodified lines
401406 / 512);
402407 if (devm_init_badblocks(dev, &pmem->bb))
403408 return -ENOMEM;
404− nvdimm_badblocks_populate(nd_region, &pmem->bb, res);
409+ nvdimm_badblocks_populate(nd_region, &pmem->bb, &bb_res);
405410 disk->bb = &pmem->bb;
406411
407412 dax_dev = alloc_dax(pmem, disk->disk_name, &pmem_dax_ops);
drivers/nvdimm/pmem.h+1−0
@@ -22,6 +22,7 @@ struct pmem_device { · 21 unmodified lines
2222 struct badblocks bb;
2323 struct dax_device *dax_dev;
2424 struct gendisk *disk;
25+ struct dev_pagemap pgmap;
2526 };
2627
2728 long __pmem_direct_access(struct pmem_device *pmem, pgoff_t pgoff,
drivers/nvdimm/region_devs.c+13−0
@@ -528,6 +528,18 @@ static ssize_t resource_show(struct device *dev, · 527 unmodified lines
528528 }
529529 static DEVICE_ATTR_RO(resource);
530530
531+static ssize_t persistence_domain_show(struct device *dev,
532+ struct device_attribute *attr, char *buf)
533+{
534+ struct nd_region *nd_region = to_nd_region(dev);
535+ unsigned long flags = nd_region->flags;
536+
537+ return sprintf(buf, "%s%s\n",
538+ flags & BIT(ND_REGION_PERSIST_CACHE) ? "cpu_cache " : "",
539+ flags & BIT(ND_REGION_PERSIST_MEMCTRL) ? "memory_controller " : "");
540+}
541+static DEVICE_ATTR_RO(persistence_domain);
542+
531543 static struct attribute *nd_region_attributes[] = {
532544 &dev_attr_size.attr,
533545 &dev_attr_nstype.attr,
@@ -543,6 +555,7 @@ static struct attribute *nd_region_attributes[] = { · 9 unmodified lines
543555 &dev_attr_init_namespaces.attr,
544556 &dev_attr_badblocks.attr,
545557 &dev_attr_resource.attr,
558+ &dev_attr_persistence_domain.attr,
546559 NULL,
547560 };
548561
drivers/s390/block/Kconfig+1−0
@@ -16,6 +16,7 @@ config BLK_DEV_XPRAM · 15 unmodified lines
1616 config DCSSBLK
1717 def_tristate m
1818 select DAX
19+ select FS_DAX_LIMITED
1920 prompt "DCSSBLK support"
2021 depends on S390 && BLOCK
2122 help
drivers/s390/block/dcssblk.c+2−1
@@ -916,7 +916,8 @@ __dcssblk_direct_access(struct dcssblk_dev_info *dev_info, pgoff_t pgoff, · 915 unmodified lines
916916
917917 dev_sz = dev_info->end - dev_info->start + 1;
918918 *kaddr = (void *) dev_info->start + offset;
919− *pfn = __pfn_to_pfn_t(PFN_DOWN(dev_info->start + offset), PFN_DEV);
919+ *pfn = __pfn_to_pfn_t(PFN_DOWN(dev_info->start + offset),
920+ PFN_DEV|PFN_SPECIAL);
920921
921922 return (dev_sz - offset) / PAGE_SIZE;
922923 }
fs/Kconfig+7−0
@@ -58,6 +58,13 @@ config FS_DAX_PMD · 57 unmodified lines
5858 depends on ZONE_DEVICE
5959 depends on TRANSPARENT_HUGEPAGE
6060
61+# Selected by DAX drivers that do not expect filesystem DAX to support
62+# get_user_pages() of DAX mappings. I.e. "limited" indicates no support
63+# for fork() of processes with MAP_SHARED mappings or support for
64+# direct-I/O to a DAX mapping.
65+config FS_DAX_LIMITED
66+ bool
67+
6168 endif # BLOCK
6269
6370 # Posix ACL utility routines
fs/ext2/super.c+5−2
@@ -962,8 +962,11 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent) · 961 unmodified lines
962962
963963 if (sbi->s_mount_opt & EXT2_MOUNT_DAX) {
964964 err = bdev_dax_supported(sb, blocksize);
965− if (err)
966− goto failed_mount;
965+ if (err) {
966+ ext2_msg(sb, KERN_ERR,
967+ "DAX unsupported by block device. Turning off DAX.");
968+ sbi->s_mount_opt &= ~EXT2_MOUNT_DAX;
969+ }
967970 }
968971
969972 /* If the blocksize doesn't match, re-read the thing.. */
fs/ext4/super.c+6−3
@@ -3712,11 +3712,14 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) · 3711 unmodified lines
37123712 if (ext4_has_feature_inline_data(sb)) {
37133713 ext4_msg(sb, KERN_ERR, "Cannot use DAX on a filesystem"
37143714 " that may contain inline data");
3715− goto failed_mount;
3715+ sbi->s_mount_opt &= ~EXT4_MOUNT_DAX;
37163716 }
37173717 err = bdev_dax_supported(sb, blocksize);
3718− if (err)
3719− goto failed_mount;
3718+ if (err) {
3719+ ext4_msg(sb, KERN_ERR,
3720+ "DAX unsupported by block device. Turning off DAX.");
3721+ sbi->s_mount_opt &= ~EXT4_MOUNT_DAX;
3722+ }
37203723 }
37213724
37223725 if (ext4_has_feature_encrypt(sb) && es->s_encryption_level) {
include/linux/libnvdimm.h+11−0
@@ -47,6 +47,17 @@ enum { · 46 unmodified lines
4747
4848 /* region flag indicating to direct-map persistent memory by default */
4949 ND_REGION_PAGEMAP = 0,
50+ /*
51+ * Platform ensures entire CPU store data path is flushed to pmem on
52+ * system power loss.
53+ */
54+ ND_REGION_PERSIST_CACHE = 1,
55+ /*
56+ * Platform provides mechanisms to automatically flush outstanding
57+ * write data from memory controler to pmem on system power loss.
58+ * (ADR)
59+ */
60+ ND_REGION_PERSIST_MEMCTRL = 2,
5061
5162 /* mark newly adjusted resources as requiring a label update */
5263 DPA_RESOURCE_ADJUSTED = 1 << 0,
include/linux/memory_hotplug.h+17−12
@@ -13,6 +13,7 @@ struct pglist_data; · 12 unmodified lines
1313 struct mem_section;
1414 struct memory_block;
1515 struct resource;
16+struct vmem_altmap;
1617
1718 #ifdef CONFIG_MEMORY_HOTPLUG
1819 /*
@@ -125,24 +126,26 @@ static inline bool movable_node_is_enabled(void) · 106 unmodified lines
125126
126127 #ifdef CONFIG_MEMORY_HOTREMOVE
127128 extern bool is_pageblock_removable_nolock(struct page *page);
128−extern int arch_remove_memory(u64 start, u64 size);
129+extern int arch_remove_memory(u64 start, u64 size,
130+ struct vmem_altmap *altmap);
129131 extern int __remove_pages(struct zone *zone, unsigned long start_pfn,
130− unsigned long nr_pages);
132+ unsigned long nr_pages, struct vmem_altmap *altmap);
131133 #endif /* CONFIG_MEMORY_HOTREMOVE */
132134
133135 /* reasonably generic interface to expand the physical pages */
134−extern int __add_pages(int nid, unsigned long start_pfn,
135− unsigned long nr_pages, bool want_memblock);
136+extern int __add_pages(int nid, unsigned long start_pfn, unsigned long nr_pages,
137+ struct vmem_altmap *altmap, bool want_memblock);
136138
137139 #ifndef CONFIG_ARCH_HAS_ADD_PAGES
138140 static inline int add_pages(int nid, unsigned long start_pfn,
139− unsigned long nr_pages, bool want_memblock)
141+ unsigned long nr_pages, struct vmem_altmap *altmap,
142+ bool want_memblock)
140143 {
141− return __add_pages(nid, start_pfn, nr_pages, want_memblock);
144+ return __add_pages(nid, start_pfn, nr_pages, altmap, want_memblock);
142145 }
143146 #else /* ARCH_HAS_ADD_PAGES */
144−int add_pages(int nid, unsigned long start_pfn,
145− unsigned long nr_pages, bool want_memblock);
147+int add_pages(int nid, unsigned long start_pfn, unsigned long nr_pages,
148+ struct vmem_altmap *altmap, bool want_memblock);
146149 #endif /* ARCH_HAS_ADD_PAGES */
147150
148151 #ifdef CONFIG_NUMA
@@ -318,15 +321,17 @@ extern int walk_memory_range(unsigned long start_pfn, unsigned long end_pfn, · 169 unmodified lines
318321 void *arg, int (*func)(struct memory_block *, void *));
319322 extern int add_memory(int nid, u64 start, u64 size);
320323 extern int add_memory_resource(int nid, struct resource *resource, bool online);
321−extern int arch_add_memory(int nid, u64 start, u64 size, bool want_memblock);
324+extern int arch_add_memory(int nid, u64 start, u64 size,
325+ struct vmem_altmap *altmap, bool want_memblock);
322326 extern void move_pfn_range_to_zone(struct zone *zone, unsigned long start_pfn,
323− unsigned long nr_pages);
327+ unsigned long nr_pages, struct vmem_altmap *altmap);
324328 extern int offline_pages(unsigned long start_pfn, unsigned long nr_pages);
325329 extern bool is_memblock_offlined(struct memory_block *mem);
326330 extern void remove_memory(int nid, u64 start, u64 size);
327−extern int sparse_add_one_section(struct pglist_data *pgdat, unsigned long start_pfn);
331+extern int sparse_add_one_section(struct pglist_data *pgdat,
332+ unsigned long start_pfn, struct vmem_altmap *altmap);
328333 extern void sparse_remove_one_section(struct zone *zone, struct mem_section *ms,
329− unsigned long map_offset);
334+ unsigned long map_offset, struct vmem_altmap *altmap);
330335 extern struct page *sparse_decode_mem_map(unsigned long coded_mem_map,
331336 unsigned long pnum);
332337 extern bool allow_online_pfn_range(int nid, unsigned long pfn, unsigned long nr_pages,
include/linux/memremap.h+23−54
@@ -26,18 +26,6 @@ struct vmem_altmap { · 25 unmodified lines
2626 unsigned long alloc;
2727 };
2828
29−unsigned long vmem_altmap_offset(struct vmem_altmap *altmap);
30−void vmem_altmap_free(struct vmem_altmap *altmap, unsigned long nr_pfns);
31−
32−#ifdef CONFIG_ZONE_DEVICE
33−struct vmem_altmap *to_vmem_altmap(unsigned long memmap_start);
34−#else
35−static inline struct vmem_altmap *to_vmem_altmap(unsigned long memmap_start)
36−{
37− return NULL;
38−}
39−#endif
40−
4129 /*
4230 * Specialize ZONE_DEVICE memory into multiple types each having differents
4331 * usage.
@@ -125,8 +113,9 @@ typedef void (*dev_page_free_t)(struct page *page, void *data); · 81 unmodified lines
125113 struct dev_pagemap {
126114 dev_page_fault_t page_fault;
127115 dev_page_free_t page_free;
128− struct vmem_altmap *altmap;
129− const struct resource *res;
116+ struct vmem_altmap altmap;
117+ bool altmap_valid;
118+ struct resource res;
130119 struct percpu_ref *ref;
131120 struct device *dev;
132121 void *data;
@@ -134,15 +123,17 @@ struct dev_pagemap { · 1 unmodified line
134123 };
135124
136125 #ifdef CONFIG_ZONE_DEVICE
137−void *devm_memremap_pages(struct device *dev, struct resource *res,
138− struct percpu_ref *ref, struct vmem_altmap *altmap);
139−struct dev_pagemap *find_dev_pagemap(resource_size_t phys);
126+void *devm_memremap_pages(struct device *dev, struct dev_pagemap *pgmap);
127+struct dev_pagemap *get_dev_pagemap(unsigned long pfn,
128+ struct dev_pagemap *pgmap);
129+
130+unsigned long vmem_altmap_offset(struct vmem_altmap *altmap);
131+void vmem_altmap_free(struct vmem_altmap *altmap, unsigned long nr_pfns);
140132
141133 static inline bool is_zone_device_page(const struct page *page);
142134 #else
143135 static inline void *devm_memremap_pages(struct device *dev,
144− struct resource *res, struct percpu_ref *ref,
145− struct vmem_altmap *altmap)
136+ struct dev_pagemap *pgmap)
146137 {
147138 /*
148139 * Fail attempts to call devm_memremap_pages() without
@@ -153,11 +144,22 @@ static inline void *devm_memremap_pages(struct device *dev, · 4 unmodified lines
153144 return ERR_PTR(-ENXIO);
154145 }
155146
156−static inline struct dev_pagemap *find_dev_pagemap(resource_size_t phys)
147+static inline struct dev_pagemap *get_dev_pagemap(unsigned long pfn,
148+ struct dev_pagemap *pgmap)
157149 {
158150 return NULL;
159151 }
160−#endif
152+
153+static inline unsigned long vmem_altmap_offset(struct vmem_altmap *altmap)
154+{
155+ return 0;
156+}
157+
158+static inline void vmem_altmap_free(struct vmem_altmap *altmap,
159+ unsigned long nr_pfns)
160+{
161+}
162+#endif /* CONFIG_ZONE_DEVICE */
161163
162164 #if defined(CONFIG_DEVICE_PRIVATE) || defined(CONFIG_DEVICE_PUBLIC)
163165 static inline bool is_device_private_page(const struct page *page)
@@ -173,39 +175,6 @@ static inline bool is_device_public_page(const struct page *page) · 9 unmodified lines
173175 }
174176 #endif /* CONFIG_DEVICE_PRIVATE || CONFIG_DEVICE_PUBLIC */
175177
176−/**
177− * get_dev_pagemap() - take a new live reference on the dev_pagemap for @pfn
178− * @pfn: page frame number to lookup page_map
179− * @pgmap: optional known pgmap that already has a reference
180− *
181− * @pgmap allows the overhead of a lookup to be bypassed when @pfn lands in the
182− * same mapping.
183− */
184−static inline struct dev_pagemap *get_dev_pagemap(unsigned long pfn,
185− struct dev_pagemap *pgmap)
186−{
187− const struct resource *res = pgmap ? pgmap->res : NULL;
188− resource_size_t phys = PFN_PHYS(pfn);
189−
190− /*
191− * In the cached case we're already holding a live reference so
192− * we can simply do a blind increment
193− */
194− if (res && phys >= res->start && phys <= res->end) {
195− percpu_ref_get(pgmap->ref);
196− return pgmap;
197− }
198−
199− /* fall back to slow path lookup */
200− rcu_read_lock();
201− pgmap = find_dev_pagemap(phys);
202− if (pgmap && !percpu_ref_tryget_live(pgmap->ref))
203− pgmap = NULL;
204− rcu_read_unlock();
205−
206− return pgmap;
207−}
208−
209178 static inline void put_dev_pagemap(struct dev_pagemap *pgmap)
210179 {
211180 if (pgmap)
include/linux/mm.h+10−12
@@ -2075,8 +2075,8 @@ static inline void zero_resv_unavail(void) {} · 2074 unmodified lines
20752075 #endif
20762076
20772077 extern void set_dma_reserve(unsigned long new_dma_reserve);
2078−extern void memmap_init_zone(unsigned long, int, unsigned long,
2079− unsigned long, enum memmap_context);
2078+extern void memmap_init_zone(unsigned long, int, unsigned long, unsigned long,
2079+ enum memmap_context, struct vmem_altmap *);
20802080 extern void setup_per_zone_wmarks(void);
20812081 extern int __meminit init_per_zone_wmark_min(void);
20822082 extern void mem_init(void);
@@ -2544,7 +2544,8 @@ void sparse_mem_maps_populate_node(struct page **map_map, · 461 unmodified lines
25442544 unsigned long map_count,
25452545 int nodeid);
25462546
2547−struct page *sparse_mem_map_populate(unsigned long pnum, int nid);
2547+struct page *sparse_mem_map_populate(unsigned long pnum, int nid,
2548+ struct vmem_altmap *altmap);
25482549 pgd_t *vmemmap_pgd_populate(unsigned long addr, int node);
25492550 p4d_t *vmemmap_p4d_populate(pgd_t *pgd, unsigned long addr, int node);
25502551 pud_t *vmemmap_pud_populate(p4d_t *p4d, unsigned long addr, int node);
@@ -2552,20 +2553,17 @@ pmd_t *vmemmap_pmd_populate(pud_t *pud, unsigned long addr, int node); · 1 unmodified line
25522553 pte_t *vmemmap_pte_populate(pmd_t *pmd, unsigned long addr, int node);
25532554 void *vmemmap_alloc_block(unsigned long size, int node);
25542555 struct vmem_altmap;
2555−void *__vmemmap_alloc_block_buf(unsigned long size, int node,
2556− struct vmem_altmap *altmap);
2557−static inline void *vmemmap_alloc_block_buf(unsigned long size, int node)
2558−{
2559− return __vmemmap_alloc_block_buf(size, node, NULL);
2560−}
2561−
2556+void *vmemmap_alloc_block_buf(unsigned long size, int node);
2557+void *altmap_alloc_block_buf(unsigned long size, struct vmem_altmap *altmap);
25622558 void vmemmap_verify(pte_t *, int, unsigned long, unsigned long);
25632559 int vmemmap_populate_basepages(unsigned long start, unsigned long end,
25642560 int node);
2565−int vmemmap_populate(unsigned long start, unsigned long end, int node);
2561+int vmemmap_populate(unsigned long start, unsigned long end, int node,
2562+ struct vmem_altmap *altmap);
25662563 void vmemmap_populate_print_last(void);
25672564 #ifdef CONFIG_MEMORY_HOTPLUG
2568−void vmemmap_free(unsigned long start, unsigned long end);
2565+void vmemmap_free(unsigned long start, unsigned long end,
2566+ struct vmem_altmap *altmap);
25692567 #endif
25702568 void register_page_bootmem_memmap(unsigned long section_nr, struct page *map,
25712569 unsigned long nr_pages);
include/linux/pfn_t.h+13−0
@@ -15,8 +15,10 @@ · 14 unmodified lines
1515 #define PFN_SG_LAST (1ULL << (BITS_PER_LONG_LONG - 2))
1616 #define PFN_DEV (1ULL << (BITS_PER_LONG_LONG - 3))
1717 #define PFN_MAP (1ULL << (BITS_PER_LONG_LONG - 4))
18+#define PFN_SPECIAL (1ULL << (BITS_PER_LONG_LONG - 5))
1819
1920 #define PFN_FLAGS_TRACE \
21+ { PFN_SPECIAL, "SPECIAL" }, \
2022 { PFN_SG_CHAIN, "SG_CHAIN" }, \
2123 { PFN_SG_LAST, "SG_LAST" }, \
2224 { PFN_DEV, "DEV" }, \
@@ -120,4 +122,15 @@ pud_t pud_mkdevmap(pud_t pud); · 97 unmodified lines
120122 #endif
121123 #endif /* __HAVE_ARCH_PTE_DEVMAP */
122124
125+#ifdef __HAVE_ARCH_PTE_SPECIAL
126+static inline bool pfn_t_special(pfn_t pfn)
127+{
128+ return (pfn.val & PFN_SPECIAL) == PFN_SPECIAL;
129+}
130+#else
131+static inline bool pfn_t_special(pfn_t pfn)
132+{
133+ return false;
134+}
135+#endif /* __HAVE_ARCH_PTE_SPECIAL */
123136 #endif /* _LINUX_PFN_T_H_ */
include/uapi/linux/ndctl.h+1−55
@@ -15,54 +15,6 @@ · 14 unmodified lines
1515
1616 #include <linux/types.h>
1717
18−struct nd_cmd_smart {
19− __u32 status;
20− __u8 data[128];
21−} __packed;
22−
23−#define ND_SMART_HEALTH_VALID (1 << 0)
24−#define ND_SMART_SPARES_VALID (1 << 1)
25−#define ND_SMART_USED_VALID (1 << 2)
26−#define ND_SMART_TEMP_VALID (1 << 3)
27−#define ND_SMART_CTEMP_VALID (1 << 4)
28−#define ND_SMART_ALARM_VALID (1 << 9)
29−#define ND_SMART_SHUTDOWN_VALID (1 << 10)
30−#define ND_SMART_VENDOR_VALID (1 << 11)
31−#define ND_SMART_SPARE_TRIP (1 << 0)
32−#define ND_SMART_TEMP_TRIP (1 << 1)
33−#define ND_SMART_CTEMP_TRIP (1 << 2)
34−#define ND_SMART_NON_CRITICAL_HEALTH (1 << 0)
35−#define ND_SMART_CRITICAL_HEALTH (1 << 1)
36−#define ND_SMART_FATAL_HEALTH (1 << 2)
37−
38−struct nd_smart_payload {
39− __u32 flags;
40− __u8 reserved0[4];
41− __u8 health;
42− __u8 spares;
43− __u8 life_used;
44− __u8 alarm_flags;
45− __u16 temperature;
46− __u16 ctrl_temperature;
47− __u8 reserved1[15];
48− __u8 shutdown_state;
49− __u32 vendor_size;
50− __u8 vendor_data[92];
51−} __packed;
52−
53−struct nd_cmd_smart_threshold {
54− __u32 status;
55− __u8 data[8];
56−} __packed;
57−
58−struct nd_smart_threshold_payload {
59− __u8 alarm_control;
60− __u8 reserved0;
61− __u16 temperature;
62− __u8 spares;
63− __u8 reserved[3];
64−} __packed;
65−
6618 struct nd_cmd_dimm_flags {
6719 __u32 status;
6820 __u32 flags;
@@ -211,12 +163,6 @@ static inline const char *nvdimm_cmd_name(unsigned cmd) · 142 unmodified lines
211163
212164 #define ND_IOCTL 'N'
213165
214−#define ND_IOCTL_SMART _IOWR(ND_IOCTL, ND_CMD_SMART,\
215− struct nd_cmd_smart)
216−
217−#define ND_IOCTL_SMART_THRESHOLD _IOWR(ND_IOCTL, ND_CMD_SMART_THRESHOLD,\
218− struct nd_cmd_smart_threshold)
219−
220166 #define ND_IOCTL_DIMM_FLAGS _IOWR(ND_IOCTL, ND_CMD_DIMM_FLAGS,\
221167 struct nd_cmd_dimm_flags)
222168
@@ -263,7 +209,7 @@ enum nd_driver_flags { · 40 unmodified lines
263209 };
264210
265211 enum {
266− ND_MIN_NAMESPACE_SIZE = 0x00400000,
212+ ND_MIN_NAMESPACE_SIZE = PAGE_SIZE,
267213 };
268214
269215 enum ars_masks {
kernel/memremap.c+71−103
@@ -188,13 +188,6 @@ static RADIX_TREE(pgmap_radix, GFP_KERNEL); · 187 unmodified lines
188188 #define SECTION_MASK ~((1UL << PA_SECTION_SHIFT) - 1)
189189 #define SECTION_SIZE (1UL << PA_SECTION_SHIFT)
190190
191−struct page_map {
192− struct resource res;
193− struct percpu_ref *ref;
194− struct dev_pagemap pgmap;
195− struct vmem_altmap altmap;
196−};
197−
198191 static unsigned long order_at(struct resource *res, unsigned long pgoff)
199192 {
200193 unsigned long phys_pgoff = PHYS_PFN(res->start) + pgoff;
@@ -248,34 +241,36 @@ int device_private_entry_fault(struct vm_area_struct *vma, · 47 unmodified lines
248241 EXPORT_SYMBOL(device_private_entry_fault);
249242 #endif /* CONFIG_DEVICE_PRIVATE */
250243
251−static void pgmap_radix_release(struct resource *res)
244+static void pgmap_radix_release(struct resource *res, unsigned long end_pgoff)
252245 {
253246 unsigned long pgoff, order;
254247
255248 mutex_lock(&pgmap_lock);
256− foreach_order_pgoff(res, order, pgoff)
249+ foreach_order_pgoff(res, order, pgoff) {
250+ if (pgoff >= end_pgoff)
251+ break;
257252 radix_tree_delete(&pgmap_radix, PHYS_PFN(res->start) + pgoff);
253+ }
258254 mutex_unlock(&pgmap_lock);
259255
260256 synchronize_rcu();
261257 }
262258
263−static unsigned long pfn_first(struct page_map *page_map)
259+static unsigned long pfn_first(struct dev_pagemap *pgmap)
264260 {
265− struct dev_pagemap *pgmap = &page_map->pgmap;
266− const struct resource *res = &page_map->res;
267− struct vmem_altmap *altmap = pgmap->altmap;
261+ const struct resource *res = &pgmap->res;
262+ struct vmem_altmap *altmap = &pgmap->altmap;
268263 unsigned long pfn;
269264
270265 pfn = res->start >> PAGE_SHIFT;
271− if (altmap)
266+ if (pgmap->altmap_valid)
272267 pfn += vmem_altmap_offset(altmap);
273268 return pfn;
274269 }
275270
276−static unsigned long pfn_end(struct page_map *page_map)
271+static unsigned long pfn_end(struct dev_pagemap *pgmap)
277272 {
278− const struct resource *res = &page_map->res;
273+ const struct resource *res = &pgmap->res;
279274
280275 return (res->start + resource_size(res)) >> PAGE_SHIFT;
281276 }
@@ -283,15 +278,15 @@ static unsigned long pfn_end(struct page_map *page_map) · 1 unmodified line
283278 #define for_each_device_pfn(pfn, map) \
284279 for (pfn = pfn_first(map); pfn < pfn_end(map); pfn++)
285280
286−static void devm_memremap_pages_release(struct device *dev, void *data)
281+static void devm_memremap_pages_release(void *data)
287282 {
288− struct page_map *page_map = data;
289− struct resource *res = &page_map->res;
283+ struct dev_pagemap *pgmap = data;
284+ struct device *dev = pgmap->dev;
285+ struct resource *res = &pgmap->res;
290286 resource_size_t align_start, align_size;
291− struct dev_pagemap *pgmap = &page_map->pgmap;
292287 unsigned long pfn;
293288
294− for_each_device_pfn(pfn, page_map)
289+ for_each_device_pfn(pfn, pgmap)
295290 put_page(pfn_to_page(pfn));
296291
297292 if (percpu_ref_tryget_live(pgmap->ref)) {
@@ -301,56 +296,51 @@ static void devm_memremap_pages_release(struct device *dev, void *data) · 3 unmodified lines
301296
302297 /* pages are dead and unused, undo the arch mapping */
303298 align_start = res->start & ~(SECTION_SIZE - 1);
304− align_size = ALIGN(resource_size(res), SECTION_SIZE);
299+ align_size = ALIGN(res->start + resource_size(res), SECTION_SIZE)
300+ - align_start;
305301
306302 mem_hotplug_begin();
307− arch_remove_memory(align_start, align_size);
303+ arch_remove_memory(align_start, align_size, pgmap->altmap_valid ?
304+ &pgmap->altmap : NULL);
308305 mem_hotplug_done();
309306
310307 untrack_pfn(NULL, PHYS_PFN(align_start), align_size);
311− pgmap_radix_release(res);
312− dev_WARN_ONCE(dev, pgmap->altmap && pgmap->altmap->alloc,
313− "%s: failed to free all reserved pages\n", __func__);
314−}
315−
316−/* assumes rcu_read_lock() held at entry */
317−struct dev_pagemap *find_dev_pagemap(resource_size_t phys)
318−{
319− struct page_map *page_map;
320−
321− WARN_ON_ONCE(!rcu_read_lock_held());
322−
323− page_map = radix_tree_lookup(&pgmap_radix, PHYS_PFN(phys));
324− return page_map ? &page_map->pgmap : NULL;
308+ pgmap_radix_release(res, -1);
309+ dev_WARN_ONCE(dev, pgmap->altmap.alloc,
310+ "%s: failed to free all reserved pages\n", __func__);
325311 }
326312
327313 /**
328314 * devm_memremap_pages - remap and provide memmap backing for the given resource
329315 * @dev: hosting device for @res
330− * @res: "host memory" address range
331− * @ref: a live per-cpu reference count
332− * @altmap: optional descriptor for allocating the memmap from @res
316+ * @pgmap: pointer to a struct dev_pgmap
333317 *
334318 * Notes:
335− * 1/ @ref must be 'live' on entry and 'dead' before devm_memunmap_pages() time
336− * (or devm release event). The expected order of events is that @ref has
319+ * 1/ At a minimum the res, ref and type members of @pgmap must be initialized
320+ * by the caller before passing it to this function
321+ *
322+ * 2/ The altmap field may optionally be initialized, in which case altmap_valid
323+ * must be set to true
324+ *
325+ * 3/ pgmap.ref must be 'live' on entry and 'dead' before devm_memunmap_pages()
326+ * time (or devm release event). The expected order of events is that ref has
337327 * been through percpu_ref_kill() before devm_memremap_pages_release(). The
338328 * wait for the completion of all references being dropped and
339329 * percpu_ref_exit() must occur after devm_memremap_pages_release().
340330 *
341− * 2/ @res is expected to be a host memory range that could feasibly be
331+ * 4/ res is expected to be a host memory range that could feasibly be
342332 * treated as a "System RAM" range, i.e. not a device mmio range, but
343333 * this is not enforced.
344334 */
345−void *devm_memremap_pages(struct device *dev, struct resource *res,
346− struct percpu_ref *ref, struct vmem_altmap *altmap)
335+void *devm_memremap_pages(struct device *dev, struct dev_pagemap *pgmap)
347336 {
348337 resource_size_t align_start, align_size, align_end;
338+ struct vmem_altmap *altmap = pgmap->altmap_valid ?
339+ &pgmap->altmap : NULL;
349340 unsigned long pfn, pgoff, order;
350341 pgprot_t pgprot = PAGE_KERNEL;
351− struct dev_pagemap *pgmap;
352− struct page_map *page_map;
353342 int error, nid, is_ram, i = 0;
343+ struct resource *res = &pgmap->res;
354344
355345 align_start = res->start & ~(SECTION_SIZE - 1);
356346 align_size = ALIGN(res->start + resource_size(res), SECTION_SIZE)
@@ -367,47 +357,18 @@ void *devm_memremap_pages(struct device *dev, struct resource *res, · 10 unmodified lines
367357 if (is_ram == REGION_INTERSECTS)
368358 return __va(res->start);
369359
370− if (!ref)
360+ if (!pgmap->ref)
371361 return ERR_PTR(-EINVAL);
372362
373− page_map = devres_alloc_node(devm_memremap_pages_release,
374− sizeof(*page_map), GFP_KERNEL, dev_to_node(dev));
375− if (!page_map)
376− return ERR_PTR(-ENOMEM);
377− pgmap = &page_map->pgmap;
378−
379− memcpy(&page_map->res, res, sizeof(*res));
380−
381363 pgmap->dev = dev;
382− if (altmap) {
383− memcpy(&page_map->altmap, altmap, sizeof(*altmap));
384− pgmap->altmap = &page_map->altmap;
385− }
386− pgmap->ref = ref;
387− pgmap->res = &page_map->res;
388− pgmap->type = MEMORY_DEVICE_HOST;
389− pgmap->page_fault = NULL;
390− pgmap->page_free = NULL;
391− pgmap->data = NULL;
392364
393365 mutex_lock(&pgmap_lock);
394366 error = 0;
395367 align_end = align_start + align_size - 1;
396368
397369 foreach_order_pgoff(res, order, pgoff) {
398− struct dev_pagemap *dup;
399−
400− rcu_read_lock();
401− dup = find_dev_pagemap(res->start + PFN_PHYS(pgoff));
402− rcu_read_unlock();
403− if (dup) {
404− dev_err(dev, "%s: %pr collides with mapping for %s\n",
405− __func__, res, dev_name(dup->dev));
406− error = -EBUSY;
407− break;
408− }
409370 error = __radix_tree_insert(&pgmap_radix,
410− PHYS_PFN(res->start) + pgoff, order, page_map);
371+ PHYS_PFN(res->start) + pgoff, order, pgmap);
411372 if (error) {
412373 dev_err(dev, "%s: failed: %d\n", __func__, error);
413374 break;
@@ -427,16 +388,16 @@ void *devm_memremap_pages(struct device *dev, struct resource *res, · 13 unmodified lines
427388 goto err_pfn_remap;
428389
429390 mem_hotplug_begin();
430− error = arch_add_memory(nid, align_start, align_size, false);
391+ error = arch_add_memory(nid, align_start, align_size, altmap, false);
431392 if (!error)
432393 move_pfn_range_to_zone(&NODE_DATA(nid)->node_zones[ZONE_DEVICE],
433394 align_start >> PAGE_SHIFT,
434− align_size >> PAGE_SHIFT);
395+ align_size >> PAGE_SHIFT, altmap);
435396 mem_hotplug_done();
436397 if (error)
437398 goto err_add_memory;
438399
439− for_each_device_pfn(pfn, page_map) {
400+ for_each_device_pfn(pfn, pgmap) {
440401 struct page *page = pfn_to_page(pfn);
441402
442403 /*
@@ -447,19 +408,21 @@ void *devm_memremap_pages(struct device *dev, struct resource *res, · 4 unmodified lines
447408 */
448409 list_del(&page->lru);
449410 page->pgmap = pgmap;
450− percpu_ref_get(ref);
411+ percpu_ref_get(pgmap->ref);
451412 if (!(++i % 1024))
452413 cond_resched();
453414 }
454− devres_add(dev, page_map);
415+
416+ devm_add_action(dev, devm_memremap_pages_release, pgmap);
417+
455418 return __va(res->start);
456419
457420 err_add_memory:
458421 untrack_pfn(NULL, PHYS_PFN(align_start), align_size);
459422 err_pfn_remap:
460423 err_radix:
461− pgmap_radix_release(res);
462− devres_free(page_map);
424+ pgmap_radix_release(res, pgoff);
425+ devres_free(pgmap);
463426 return ERR_PTR(error);
464427 }
465428 EXPORT_SYMBOL(devm_memremap_pages);
@@ -475,34 +438,39 @@ void vmem_altmap_free(struct vmem_altmap *altmap, unsigned long nr_pfns) · 9 unmodified lines
475438 altmap->alloc -= nr_pfns;
476439 }
477440
478−struct vmem_altmap *to_vmem_altmap(unsigned long memmap_start)
441+/**
442+ * get_dev_pagemap() - take a new live reference on the dev_pagemap for @pfn
443+ * @pfn: page frame number to lookup page_map
444+ * @pgmap: optional known pgmap that already has a reference
445+ *
446+ * If @pgmap is non-NULL and covers @pfn it will be returned as-is. If @pgmap
447+ * is non-NULL but does not cover @pfn the reference to it will be released.
448+ */
449+struct dev_pagemap *get_dev_pagemap(unsigned long pfn,
450+ struct dev_pagemap *pgmap)
479451 {
480− /*
481− * 'memmap_start' is the virtual address for the first "struct
482− * page" in this range of the vmemmap array. In the case of
483− * CONFIG_SPARSEMEM_VMEMMAP a page_to_pfn conversion is simple
484− * pointer arithmetic, so we can perform this to_vmem_altmap()
485− * conversion without concern for the initialization state of
486− * the struct page fields.
487− */
488− struct page *page = (struct page *) memmap_start;
489− struct dev_pagemap *pgmap;
452+ resource_size_t phys = PFN_PHYS(pfn);
490453
491454 /*
492− * Unconditionally retrieve a dev_pagemap associated with the
493− * given physical address, this is only for use in the
494− * arch_{add|remove}_memory() for setting up and tearing down
495− * the memmap.
455+ * In the cached case we're already holding a live reference.
496456 */
457+ if (pgmap) {
458+ if (phys >= pgmap->res.start && phys <= pgmap->res.end)
459+ return pgmap;
460+ put_dev_pagemap(pgmap);
461+ }
462+
463+ /* fall back to slow path lookup */
497464 rcu_read_lock();
498− pgmap = find_dev_pagemap(__pfn_to_phys(page_to_pfn(page)));
465+ pgmap = radix_tree_lookup(&pgmap_radix, PHYS_PFN(phys));
466+ if (pgmap && !percpu_ref_tryget_live(pgmap->ref))
467+ pgmap = NULL;
499468 rcu_read_unlock();
500469
501− return pgmap ? pgmap->altmap : NULL;
470+ return pgmap;
502471 }
503472 #endif /* CONFIG_ZONE_DEVICE */
504473
505−
506474 #if IS_ENABLED(CONFIG_DEVICE_PRIVATE) || IS_ENABLED(CONFIG_DEVICE_PUBLIC)
507475 void put_zone_device_private_or_public_page(struct page *page)
508476 {
mm/gup.c+5−2
@@ -1394,7 +1394,6 @@ static int gup_pte_range(pmd_t pmd, unsigned long addr, unsigned long end, · 1393 unmodified lines
13941394
13951395 VM_BUG_ON_PAGE(compound_head(page) != head, page);
13961396
1397− put_dev_pagemap(pgmap);
13981397 SetPageReferenced(page);
13991398 pages[*nr] = page;
14001399 (*nr)++;
@@ -1404,6 +1403,8 @@ static int gup_pte_range(pmd_t pmd, unsigned long addr, unsigned long end, · 3 unmodified lines
14041403 ret = 1;
14051404
14061405 pte_unmap:
1406+ if (pgmap)
1407+ put_dev_pagemap(pgmap);
14071408 pte_unmap(ptem);
14081409 return ret;
14091410 }
@@ -1443,10 +1444,12 @@ static int __gup_device_huge(unsigned long pfn, unsigned long addr, · 33 unmodified lines
14431444 SetPageReferenced(page);
14441445 pages[*nr] = page;
14451446 get_page(page);
1446− put_dev_pagemap(pgmap);
14471447 (*nr)++;
14481448 pfn++;
14491449 } while (addr += PAGE_SIZE, addr != end);
1450+
1451+ if (pgmap)
1452+ put_dev_pagemap(pgmap);
14501453 return 1;
14511454 }
14521455
mm/hmm.c+7−6
@@ -836,10 +836,10 @@ static void hmm_devmem_release(struct device *dev, void *data) · 835 unmodified lines
836836
837837 mem_hotplug_begin();
838838 if (resource->desc == IORES_DESC_DEVICE_PRIVATE_MEMORY)
839− __remove_pages(zone, start_pfn, npages);
839+ __remove_pages(zone, start_pfn, npages, NULL);
840840 else
841841 arch_remove_memory(start_pfn << PAGE_SHIFT,
842− npages << PAGE_SHIFT);
842+ npages << PAGE_SHIFT, NULL);
843843 mem_hotplug_done();
844844
845845 hmm_devmem_radix_release(resource);
@@ -880,7 +880,7 @@ static int hmm_devmem_pages_create(struct hmm_devmem *devmem) · 34 unmodified lines
880880 else
881881 devmem->pagemap.type = MEMORY_DEVICE_PRIVATE;
882882
883− devmem->pagemap.res = devmem->resource;
883+ devmem->pagemap.res = *devmem->resource;
884884 devmem->pagemap.page_fault = hmm_devmem_fault;
885885 devmem->pagemap.page_free = hmm_devmem_free;
886886 devmem->pagemap.dev = devmem->device;
@@ -929,17 +929,18 @@ static int hmm_devmem_pages_create(struct hmm_devmem *devmem) · 42 unmodified lines
929929 * want the linear mapping and thus use arch_add_memory().
930930 */
931931 if (devmem->pagemap.type == MEMORY_DEVICE_PUBLIC)
932− ret = arch_add_memory(nid, align_start, align_size, false);
932+ ret = arch_add_memory(nid, align_start, align_size, NULL,
933+ false);
933934 else
934935 ret = add_pages(nid, align_start >> PAGE_SHIFT,
935− align_size >> PAGE_SHIFT, false);
936+ align_size >> PAGE_SHIFT, NULL, false);
936937 if (ret) {
937938 mem_hotplug_done();
938939 goto error_add_memory;
939940 }
940941 move_pfn_range_to_zone(&NODE_DATA(nid)->node_zones[ZONE_DEVICE],
941942 align_start >> PAGE_SHIFT,
942− align_size >> PAGE_SHIFT);
943+ align_size >> PAGE_SHIFT, NULL);
943944 mem_hotplug_done();
944945
945946 for (pfn = devmem->pfn_first; pfn < devmem->pfn_last; pfn++) {
mm/memory.c+15−1
@@ -1904,12 +1904,26 @@ int vm_insert_pfn_prot(struct vm_area_struct *vma, unsigned long addr, · 1903 unmodified lines
19041904 }
19051905 EXPORT_SYMBOL(vm_insert_pfn_prot);
19061906
1907+static bool vm_mixed_ok(struct vm_area_struct *vma, pfn_t pfn)
1908+{
1909+ /* these checks mirror the abort conditions in vm_normal_page */
1910+ if (vma->vm_flags & VM_MIXEDMAP)
1911+ return true;
1912+ if (pfn_t_devmap(pfn))
1913+ return true;
1914+ if (pfn_t_special(pfn))
1915+ return true;
1916+ if (is_zero_pfn(pfn_t_to_pfn(pfn)))
1917+ return true;
1918+ return false;
1919+}
1920+
19071921 static int __vm_insert_mixed(struct vm_area_struct *vma, unsigned long addr,
19081922 pfn_t pfn, bool mkwrite)
19091923 {
19101924 pgprot_t pgprot = vma->vm_page_prot;
19111925
1912− BUG_ON(!(vma->vm_flags & VM_MIXEDMAP));
1926+ BUG_ON(!vm_mixed_ok(vma, pfn));
19131927
19141928 if (addr < vma->vm_start || addr >= vma->vm_end)
19151929 return -EFAULT;
mm/memory_hotplug.c+18−21
@@ -247,7 +247,7 @@ void __init register_page_bootmem_info_node(struct pglist_data *pgdat) · 246 unmodified lines
247247 #endif /* CONFIG_HAVE_BOOTMEM_INFO_NODE */
248248
249249 static int __meminit __add_section(int nid, unsigned long phys_start_pfn,
250− bool want_memblock)
250+ struct vmem_altmap *altmap, bool want_memblock)
251251 {
252252 int ret;
253253 int i;
@@ -255,7 +255,7 @@ static int __meminit __add_section(int nid, unsigned long phys_start_pfn, · 1 unmodified line
255255 if (pfn_valid(phys_start_pfn))
256256 return -EEXIST;
257257
258− ret = sparse_add_one_section(NODE_DATA(nid), phys_start_pfn);
258+ ret = sparse_add_one_section(NODE_DATA(nid), phys_start_pfn, altmap);
259259 if (ret < 0)
260260 return ret;
261261
@@ -289,18 +289,17 @@ static int __meminit __add_section(int nid, unsigned long phys_start_pfn, · 27 unmodified lines
289289 * add the new pages.
290290 */
291291 int __ref __add_pages(int nid, unsigned long phys_start_pfn,
292− unsigned long nr_pages, bool want_memblock)
292+ unsigned long nr_pages, struct vmem_altmap *altmap,
293+ bool want_memblock)
293294 {
294295 unsigned long i;
295296 int err = 0;
296297 int start_sec, end_sec;
297− struct vmem_altmap *altmap;
298298
299299 /* during initialize mem_map, align hot-added range to section */
300300 start_sec = pfn_to_section_nr(phys_start_pfn);
301301 end_sec = pfn_to_section_nr(phys_start_pfn + nr_pages - 1);
302302
303− altmap = to_vmem_altmap((unsigned long) pfn_to_page(phys_start_pfn));
304303 if (altmap) {
305304 /*
306305 * Validate altmap is within bounds of the total request
@@ -315,7 +314,8 @@ int __ref __add_pages(int nid, unsigned long phys_start_pfn, · 8 unmodified lines
315314 }
316315
317316 for (i = start_sec; i <= end_sec; i++) {
318− err = __add_section(nid, section_nr_to_pfn(i), want_memblock);
317+ err = __add_section(nid, section_nr_to_pfn(i), altmap,
318+ want_memblock);
319319
320320 /*
321321 * EEXIST is finally dealt with by ioresource collision
@@ -331,7 +331,6 @@ int __ref __add_pages(int nid, unsigned long phys_start_pfn, · 9 unmodified lines
331331 out:
332332 return err;
333333 }
334−EXPORT_SYMBOL_GPL(__add_pages);
335334
336335 #ifdef CONFIG_MEMORY_HOTREMOVE
337336 /* find the smallest valid pfn in the range [start_pfn, end_pfn) */
@@ -534,7 +533,7 @@ static void __remove_zone(struct zone *zone, unsigned long start_pfn) · 196 unmodified lines
534533 }
535534
536535 static int __remove_section(struct zone *zone, struct mem_section *ms,
537− unsigned long map_offset)
536+ unsigned long map_offset, struct vmem_altmap *altmap)
538537 {
539538 unsigned long start_pfn;
540539 int scn_nr;
@@ -551,7 +550,7 @@ static int __remove_section(struct zone *zone, struct mem_section *ms, · 10 unmodified lines
551550 start_pfn = section_nr_to_pfn((unsigned long)scn_nr);
552551 __remove_zone(zone, start_pfn);
553552
554− sparse_remove_one_section(zone, ms, map_offset);
553+ sparse_remove_one_section(zone, ms, map_offset, altmap);
555554 return 0;
556555 }
557556
@@ -567,7 +566,7 @@ static int __remove_section(struct zone *zone, struct mem_section *ms, · 9 unmodified lines
567566 * calling offline_pages().
568567 */
569568 int __remove_pages(struct zone *zone, unsigned long phys_start_pfn,
570− unsigned long nr_pages)
569+ unsigned long nr_pages, struct vmem_altmap *altmap)
571570 {
572571 unsigned long i;
573572 unsigned long map_offset = 0;
@@ -575,10 +574,6 @@ int __remove_pages(struct zone *zone, unsigned long phys_start_pfn, · 1 unmodified line
575574
576575 /* In the ZONE_DEVICE case device driver owns the memory region */
577576 if (is_dev_zone(zone)) {
578− struct page *page = pfn_to_page(phys_start_pfn);
579− struct vmem_altmap *altmap;
580−
581− altmap = to_vmem_altmap((unsigned long) page);
582577 if (altmap)
583578 map_offset = vmem_altmap_offset(altmap);
584579 } else {
@@ -609,7 +604,8 @@ int __remove_pages(struct zone *zone, unsigned long phys_start_pfn, · 24 unmodified lines
609604 for (i = 0; i < sections_to_remove; i++) {
610605 unsigned long pfn = phys_start_pfn + i*PAGES_PER_SECTION;
611606
612− ret = __remove_section(zone, __pfn_to_section(pfn), map_offset);
607+ ret = __remove_section(zone, __pfn_to_section(pfn), map_offset,
608+ altmap);
613609 map_offset = 0;
614610 if (ret)
615611 break;
@@ -799,8 +795,8 @@ static void __meminit resize_pgdat_range(struct pglist_data *pgdat, unsigned lon · 183 unmodified lines
799795 pgdat->node_spanned_pages = max(start_pfn + nr_pages, old_end_pfn) - pgdat->node_start_pfn;
800796 }
801797
802−void __ref move_pfn_range_to_zone(struct zone *zone,
803− unsigned long start_pfn, unsigned long nr_pages)
798+void __ref move_pfn_range_to_zone(struct zone *zone, unsigned long start_pfn,
799+ unsigned long nr_pages, struct vmem_altmap *altmap)
804800 {
805801 struct pglist_data *pgdat = zone->zone_pgdat;
806802 int nid = pgdat->node_id;
@@ -825,7 +821,8 @@ void __ref move_pfn_range_to_zone(struct zone *zone, · 18 unmodified lines
825821 * expects the zone spans the pfn range. All the pages in the range
826822 * are reserved so nobody should be touching them so we should be safe
827823 */
828− memmap_init_zone(nr_pages, nid, zone_idx(zone), start_pfn, MEMMAP_HOTPLUG);
824+ memmap_init_zone(nr_pages, nid, zone_idx(zone), start_pfn,
825+ MEMMAP_HOTPLUG, altmap);
829826
830827 set_zone_contiguous(zone);
831828 }
@@ -897,7 +894,7 @@ static struct zone * __meminit move_pfn_range(int online_type, int nid, · 65 unmodified lines
897894 struct zone *zone;
898895
899896 zone = zone_for_pfn_range(online_type, nid, start_pfn, nr_pages);
900− move_pfn_range_to_zone(zone, start_pfn, nr_pages);
897+ move_pfn_range_to_zone(zone, start_pfn, nr_pages, NULL);
901898 return zone;
902899 }
903900
@@ -1146,7 +1143,7 @@ int __ref add_memory_resource(int nid, struct resource *res, bool online) · 242 unmodified lines
11461143 }
11471144
11481145 /* call arch's memory hotadd */
1149− ret = arch_add_memory(nid, start, size, true);
1146+ ret = arch_add_memory(nid, start, size, NULL, true);
11501147
11511148 if (ret < 0)
11521149 goto error;
@@ -1888,7 +1885,7 @@ void __ref remove_memory(int nid, u64 start, u64 size) · 735 unmodified lines
18881885 memblock_free(start, size);
18891886 memblock_remove(start, size);
18901887
1891− arch_remove_memory(start, size);
1888+ arch_remove_memory(start, size, NULL);
18921889
18931890 try_offline_node(nid);
18941891
mm/page_alloc.c+3−3
@@ -5321,9 +5321,9 @@ void __ref build_all_zonelists(pg_data_t *pgdat) · 5320 unmodified lines
53215321 * done. Non-atomic initialization, single-pass.
53225322 */
53235323 void __meminit memmap_init_zone(unsigned long size, int nid, unsigned long zone,
5324− unsigned long start_pfn, enum memmap_context context)
5324+ unsigned long start_pfn, enum memmap_context context,
5325+ struct vmem_altmap *altmap)
53255326 {
5326− struct vmem_altmap *altmap = to_vmem_altmap(__pfn_to_phys(start_pfn));
53275327 unsigned long end_pfn = start_pfn + size;
53285328 pg_data_t *pgdat = NODE_DATA(nid);
53295329 unsigned long pfn;
@@ -5429,7 +5429,7 @@ static void __meminit zone_init_free_lists(struct zone *zone) · 99 unmodified lines
54295429
54305430 #ifndef __HAVE_ARCH_MEMMAP_INIT
54315431 #define memmap_init(size, nid, zone, start_pfn) \
5432− memmap_init_zone((size), (nid), (zone), (start_pfn), MEMMAP_EARLY)
5432+ memmap_init_zone((size), (nid), (zone), (start_pfn), MEMMAP_EARLY, NULL)
54335433 #endif
54345434
54355435 static int zone_batchsize(struct zone *zone)
mm/sparse-vmemmap.c+23−44
@@ -74,7 +74,7 @@ void * __meminit vmemmap_alloc_block(unsigned long size, int node) · 73 unmodified lines
7474 }
7575
7676 /* need to make sure size is all the same during early stage */
77−static void * __meminit alloc_block_buf(unsigned long size, int node)
77+void * __meminit vmemmap_alloc_block_buf(unsigned long size, int node)
7878 {
7979 void *ptr;
8080
@@ -107,33 +107,16 @@ static unsigned long __meminit vmem_altmap_nr_free(struct vmem_altmap *altmap) · 26 unmodified lines
107107 }
108108
109109 /**
110− * vmem_altmap_alloc - allocate pages from the vmem_altmap reservation
111− * @altmap - reserved page pool for the allocation
112− * @nr_pfns - size (in pages) of the allocation
110+ * altmap_alloc_block_buf - allocate pages from the device page map
111+ * @altmap: device page map
112+ * @size: size (in bytes) of the allocation
113113 *
114− * Allocations are aligned to the size of the request
114+ * Allocations are aligned to the size of the request.
115115 */
116−static unsigned long __meminit vmem_altmap_alloc(struct vmem_altmap *altmap,
117− unsigned long nr_pfns)
118−{
119− unsigned long pfn = vmem_altmap_next_pfn(altmap);
120− unsigned long nr_align;
121−
122− nr_align = 1UL << find_first_bit(&nr_pfns, BITS_PER_LONG);
123− nr_align = ALIGN(pfn, nr_align) - pfn;
124−
125− if (nr_pfns + nr_align > vmem_altmap_nr_free(altmap))
126− return ULONG_MAX;
127− altmap->alloc += nr_pfns;
128− altmap->align += nr_align;
129− return pfn + nr_align;
130−}
131−
132−static void * __meminit altmap_alloc_block_buf(unsigned long size,
116+void * __meminit altmap_alloc_block_buf(unsigned long size,
133117 struct vmem_altmap *altmap)
134118 {
135− unsigned long pfn, nr_pfns;
136− void *ptr;
119+ unsigned long pfn, nr_pfns, nr_align;
137120
138121 if (size & ~PAGE_MASK) {
139122 pr_warn_once("%s: allocations must be multiple of PAGE_SIZE (%ld)\n",
@@ -141,25 +124,20 @@ static void * __meminit altmap_alloc_block_buf(unsigned long size, · 1 unmodified line
141124 return NULL;
142125 }
143126
127+ pfn = vmem_altmap_next_pfn(altmap);
144128 nr_pfns = size >> PAGE_SHIFT;
145− pfn = vmem_altmap_alloc(altmap, nr_pfns);
146− if (pfn < ULONG_MAX)
147− ptr = __va(__pfn_to_phys(pfn));
148− else
149− ptr = NULL;
150− pr_debug("%s: pfn: %#lx alloc: %ld align: %ld nr: %#lx\n",
151− __func__, pfn, altmap->alloc, altmap->align, nr_pfns);
129+ nr_align = 1UL << find_first_bit(&nr_pfns, BITS_PER_LONG);
130+ nr_align = ALIGN(pfn, nr_align) - pfn;
131+ if (nr_pfns + nr_align > vmem_altmap_nr_free(altmap))
132+ return NULL;
152133
153− return ptr;
154−}
134+ altmap->alloc += nr_pfns;
135+ altmap->align += nr_align;
136+ pfn += nr_align;
155137
156−/* need to make sure size is all the same during early stage */
157−void * __meminit __vmemmap_alloc_block_buf(unsigned long size, int node,
158− struct vmem_altmap *altmap)
159−{
160− if (altmap)
161− return altmap_alloc_block_buf(size, altmap);
162− return alloc_block_buf(size, node);
138+ pr_debug("%s: pfn: %#lx alloc: %ld align: %ld nr: %#lx\n",
139+ __func__, pfn, altmap->alloc, altmap->align, nr_pfns);
140+ return __va(__pfn_to_phys(pfn));
163141 }
164142
165143 void __meminit vmemmap_verify(pte_t *pte, int node,
@@ -178,7 +156,7 @@ pte_t * __meminit vmemmap_pte_populate(pmd_t *pmd, unsigned long addr, int node) · 12 unmodified lines
178156 pte_t *pte = pte_offset_kernel(pmd, addr);
179157 if (pte_none(*pte)) {
180158 pte_t entry;
181− void *p = alloc_block_buf(PAGE_SIZE, node);
159+ void *p = vmemmap_alloc_block_buf(PAGE_SIZE, node);
182160 if (!p)
183161 return NULL;
184162 entry = pfn_pte(__pa(p) >> PAGE_SHIFT, PAGE_KERNEL);
@@ -278,7 +256,8 @@ int __meminit vmemmap_populate_basepages(unsigned long start, · 93 unmodified lines
278256 return 0;
279257 }
280258
281−struct page * __meminit sparse_mem_map_populate(unsigned long pnum, int nid)
259+struct page * __meminit sparse_mem_map_populate(unsigned long pnum, int nid,
260+ struct vmem_altmap *altmap)
282261 {
283262 unsigned long start;
284263 unsigned long end;
@@ -288,7 +267,7 @@ struct page * __meminit sparse_mem_map_populate(unsigned long pnum, int nid) · 3 unmodified lines
288267 start = (unsigned long)map;
289268 end = (unsigned long)(map + PAGES_PER_SECTION);
290269
291− if (vmemmap_populate(start, end, nid))
270+ if (vmemmap_populate(start, end, nid, altmap))
292271 return NULL;
293272
294273 return map;
@@ -318,7 +297,7 @@ void __init sparse_mem_maps_populate_node(struct page **map_map, · 23 unmodified lines
318297 if (!present_section_nr(pnum))
319298 continue;
320299
321− map_map[pnum] = sparse_mem_map_populate(pnum, nodeid);
300+ map_map[pnum] = sparse_mem_map_populate(pnum, nodeid, NULL);
322301 if (map_map[pnum])
323302 continue;
324303 ms = __nr_to_section(pnum);
mm/sparse.c+25−18
@@ -421,7 +421,8 @@ static void __init sparse_early_usemaps_alloc_node(void *data, · 420 unmodified lines
421421 }
422422
423423 #ifndef CONFIG_SPARSEMEM_VMEMMAP
424−struct page __init *sparse_mem_map_populate(unsigned long pnum, int nid)
424+struct page __init *sparse_mem_map_populate(unsigned long pnum, int nid,
425+ struct vmem_altmap *altmap)
425426 {
426427 struct page *map;
427428 unsigned long size;
@@ -476,7 +477,7 @@ void __init sparse_mem_maps_populate_node(struct page **map_map, · 48 unmodified lines
476477
477478 if (!present_section_nr(pnum))
478479 continue;
479− map_map[pnum] = sparse_mem_map_populate(pnum, nodeid);
480+ map_map[pnum] = sparse_mem_map_populate(pnum, nodeid, NULL);
480481 if (map_map[pnum])
481482 continue;
482483 ms = __nr_to_section(pnum);
@@ -504,7 +505,7 @@ static struct page __init *sparse_early_mem_map_alloc(unsigned long pnum) · 21 unmodified lines
504505 struct mem_section *ms = __nr_to_section(pnum);
505506 int nid = sparse_early_nid(ms);
506507
507− map = sparse_mem_map_populate(pnum, nid);
508+ map = sparse_mem_map_populate(pnum, nid, NULL);
508509 if (map)
509510 return map;
510511
@@ -682,17 +683,19 @@ void offline_mem_sections(unsigned long start_pfn, unsigned long end_pfn) · 171 unmodified lines
682683 #endif
683684
684685 #ifdef CONFIG_SPARSEMEM_VMEMMAP
685−static inline struct page *kmalloc_section_memmap(unsigned long pnum, int nid)
686+static inline struct page *kmalloc_section_memmap(unsigned long pnum, int nid,
687+ struct vmem_altmap *altmap)
686688 {
687689 /* This will make the necessary allocations eventually. */
688− return sparse_mem_map_populate(pnum, nid);
690+ return sparse_mem_map_populate(pnum, nid, altmap);
689691 }
690−static void __kfree_section_memmap(struct page *memmap)
692+static void __kfree_section_memmap(struct page *memmap,
693+ struct vmem_altmap *altmap)
691694 {
692695 unsigned long start = (unsigned long)memmap;
693696 unsigned long end = (unsigned long)(memmap + PAGES_PER_SECTION);
694697
695− vmemmap_free(start, end);
698+ vmemmap_free(start, end, altmap);
696699 }
697700 #ifdef CONFIG_MEMORY_HOTREMOVE
698701 static void free_map_bootmem(struct page *memmap)
@@ -700,7 +703,7 @@ static void free_map_bootmem(struct page *memmap) · 1 unmodified line
700703 unsigned long start = (unsigned long)memmap;
701704 unsigned long end = (unsigned long)(memmap + PAGES_PER_SECTION);
702705
703− vmemmap_free(start, end);
706+ vmemmap_free(start, end, NULL);
704707 }
705708 #endif /* CONFIG_MEMORY_HOTREMOVE */
706709 #else
@@ -725,12 +728,14 @@ got_map_ptr: · 18 unmodified lines
725728 return ret;
726729 }
727730
728−static inline struct page *kmalloc_section_memmap(unsigned long pnum, int nid)
731+static inline struct page *kmalloc_section_memmap(unsigned long pnum, int nid,
732+ struct vmem_altmap *altmap)
729733 {
730734 return __kmalloc_section_memmap();
731735 }
732736
733−static void __kfree_section_memmap(struct page *memmap)
737+static void __kfree_section_memmap(struct page *memmap,
738+ struct vmem_altmap *altmap)
734739 {
735740 if (is_vmalloc_addr(memmap))
736741 vfree(memmap);
@@ -777,7 +782,8 @@ static void free_map_bootmem(struct page *memmap) · 40 unmodified lines
777782 * set. If this is <=0, then that means that the passed-in
778783 * map was not consumed and must be freed.
779784 */
780−int __meminit sparse_add_one_section(struct pglist_data *pgdat, unsigned long start_pfn)
785+int __meminit sparse_add_one_section(struct pglist_data *pgdat,
786+ unsigned long start_pfn, struct vmem_altmap *altmap)
781787 {
782788 unsigned long section_nr = pfn_to_section_nr(start_pfn);
783789 struct mem_section *ms;
@@ -793,12 +799,12 @@ int __meminit sparse_add_one_section(struct pglist_data *pgdat, unsigned long st · 9 unmodified lines
793799 ret = sparse_index_init(section_nr, pgdat->node_id);
794800 if (ret < 0 && ret != -EEXIST)
795801 return ret;
796− memmap = kmalloc_section_memmap(section_nr, pgdat->node_id);
802+ memmap = kmalloc_section_memmap(section_nr, pgdat->node_id, altmap);
797803 if (!memmap)
798804 return -ENOMEM;
799805 usemap = __kmalloc_section_usemap();
800806 if (!usemap) {
801− __kfree_section_memmap(memmap);
807+ __kfree_section_memmap(memmap, altmap);
802808 return -ENOMEM;
803809 }
804810
@@ -820,7 +826,7 @@ out: · 15 unmodified lines
820826 pgdat_resize_unlock(pgdat, &flags);
821827 if (ret <= 0) {
822828 kfree(usemap);
823− __kfree_section_memmap(memmap);
829+ __kfree_section_memmap(memmap, altmap);
824830 }
825831 return ret;
826832 }
@@ -847,7 +853,8 @@ static inline void clear_hwpoisoned_pages(struct page *memmap, int nr_pages) · 20 unmodified lines
847853 }
848854 #endif
849855
850−static void free_section_usemap(struct page *memmap, unsigned long *usemap)
856+static void free_section_usemap(struct page *memmap, unsigned long *usemap,
857+ struct vmem_altmap *altmap)
851858 {
852859 struct page *usemap_page;
853860
@@ -861,7 +868,7 @@ static void free_section_usemap(struct page *memmap, unsigned long *usemap) · 7 unmodified lines
861868 if (PageSlab(usemap_page) || PageCompound(usemap_page)) {
862869 kfree(usemap);
863870 if (memmap)
864− __kfree_section_memmap(memmap);
871+ __kfree_section_memmap(memmap, altmap);
865872 return;
866873 }
867874
@@ -875,7 +882,7 @@ static void free_section_usemap(struct page *memmap, unsigned long *usemap) · 7 unmodified lines
875882 }
876883
877884 void sparse_remove_one_section(struct zone *zone, struct mem_section *ms,
878− unsigned long map_offset)
885+ unsigned long map_offset, struct vmem_altmap *altmap)
879886 {
880887 struct page *memmap = NULL;
881888 unsigned long *usemap = NULL, flags;
@@ -893,7 +900,7 @@ void sparse_remove_one_section(struct zone *zone, struct mem_section *ms, · 11 unmodified lines
893900
894901 clear_hwpoisoned_pages(memmap + map_offset,
895902 PAGES_PER_SECTION - map_offset);
896− free_section_usemap(memmap, usemap);
903+ free_section_usemap(memmap, usemap, altmap);
897904 }
898905 #endif /* CONFIG_MEMORY_HOTREMOVE */
899906 #endif /* CONFIG_MEMORY_HOTPLUG */
tools/testing/nvdimm/Kbuild+4−0
@@ -37,10 +37,12 @@ obj-$(CONFIG_DEV_DAX_PMEM) += dax_pmem.o · 36 unmodified lines
3737
3838 nfit-y := $(ACPI_SRC)/core.o
3939 nfit-$(CONFIG_X86_MCE) += $(ACPI_SRC)/mce.o
40+nfit-y += acpi_nfit_test.o
4041 nfit-y += config_check.o
4142
4243 nd_pmem-y := $(NVDIMM_SRC)/pmem.o
4344 nd_pmem-y += pmem-dax.o
45+nd_pmem-y += pmem_test.o
4446 nd_pmem-y += config_check.o
4547
4648 nd_btt-y := $(NVDIMM_SRC)/btt.o
@@ -57,6 +59,7 @@ dax-y += config_check.o · 10 unmodified lines
5759
5860 device_dax-y := $(DAX_SRC)/device.o
5961 device_dax-y += dax-dev.o
62+device_dax-y += device_dax_test.o
6063 device_dax-y += config_check.o
6164
6265 dax_pmem-y := $(DAX_SRC)/pmem.o
@@ -75,6 +78,7 @@ libnvdimm-$(CONFIG_ND_CLAIM) += $(NVDIMM_SRC)/claim.o · 12 unmodified lines
7578 libnvdimm-$(CONFIG_BTT) += $(NVDIMM_SRC)/btt_devs.o
7679 libnvdimm-$(CONFIG_NVDIMM_PFN) += $(NVDIMM_SRC)/pfn_devs.o
7780 libnvdimm-$(CONFIG_NVDIMM_DAX) += $(NVDIMM_SRC)/dax_devs.o
81+libnvdimm-y += libnvdimm_test.o
7882 libnvdimm-y += config_check.o
7983
8084 obj-m += test/
tools/testing/nvdimm/acpi_nfit_test.c+8−0
@@ -0,0 +1,8 @@
1+// SPDX-License-Identifier: GPL-2.0
2+// Copyright(c) 2018 Intel Corporation. All rights reserved.
3+
4+#include <linux/module.h>
5+#include <linux/printk.h>
6+#include "watermark.h"
7+
8+nfit_test_watermark(acpi_nfit);
tools/testing/nvdimm/device_dax_test.c+8−0
@@ -0,0 +1,8 @@
1+// SPDX-License-Identifier: GPL-2.0
2+// Copyright(c) 2018 Intel Corporation. All rights reserved.
3+
4+#include <linux/module.h>
5+#include <linux/printk.h>
6+#include "watermark.h"
7+
8+nfit_test_watermark(device_dax);
tools/testing/nvdimm/libnvdimm_test.c+8−0
@@ -0,0 +1,8 @@
1+// SPDX-License-Identifier: GPL-2.0
2+// Copyright(c) 2018 Intel Corporation. All rights reserved.
3+
4+#include <linux/module.h>
5+#include <linux/printk.h>
6+#include "watermark.h"
7+
8+nfit_test_watermark(libnvdimm);
tools/testing/nvdimm/pmem_test.c+8−0
@@ -0,0 +1,8 @@
1+// SPDX-License-Identifier: GPL-2.0
2+// Copyright(c) 2018 Intel Corporation. All rights reserved.
3+
4+#include <linux/module.h>
5+#include <linux/printk.h>
6+#include "watermark.h"
7+
8+nfit_test_watermark(pmem);
tools/testing/nvdimm/test/iomap.c+3−4
@@ -104,15 +104,14 @@ void *__wrap_devm_memremap(struct device *dev, resource_size_t offset, · 103 unmodified lines
104104 }
105105 EXPORT_SYMBOL(__wrap_devm_memremap);
106106
107−void *__wrap_devm_memremap_pages(struct device *dev, struct resource *res,
108− struct percpu_ref *ref, struct vmem_altmap *altmap)
107+void *__wrap_devm_memremap_pages(struct device *dev, struct dev_pagemap *pgmap)
109108 {
110− resource_size_t offset = res->start;
109+ resource_size_t offset = pgmap->res.start;
111110 struct nfit_test_resource *nfit_res = get_nfit_res(offset);
112111
113112 if (nfit_res)
114113 return nfit_res->buf + offset - nfit_res->res.start;
115− return devm_memremap_pages(dev, res, ref, altmap);
114+ return devm_memremap_pages(dev, pgmap);
116115 }
117116 EXPORT_SYMBOL(__wrap_devm_memremap_pages);
118117
tools/testing/nvdimm/test/nfit.c+450−48
@@ -27,6 +27,7 @@ · 26 unmodified lines
2727 #include <nfit.h>
2828 #include <nd.h>
2929 #include "nfit_test.h"
30+#include "../watermark.h"
3031
3132 /*
3233 * Generate an NFIT table to describe the following topology:
@@ -137,6 +138,14 @@ static u32 handle[] = { · 104 unmodified lines
137138
138139 static unsigned long dimm_fail_cmd_flags[NUM_DCR];
139140
141+struct nfit_test_fw {
142+ enum intel_fw_update_state state;
143+ u32 context;
144+ u64 version;
145+ u32 size_received;
146+ u64 end_time;
147+};
148+
140149 struct nfit_test {
141150 struct acpi_nfit_desc acpi_desc;
142151 struct platform_device pdev;
@@ -168,8 +177,11 @@ struct nfit_test { · 25 unmodified lines
168177 spinlock_t lock;
169178 } ars_state;
170179 struct device *dimm_dev[NUM_DCR];
180+ struct nd_intel_smart *smart;
181+ struct nd_intel_smart_threshold *smart_threshold;
171182 struct badrange badrange;
172183 struct work_struct work;
184+ struct nfit_test_fw *fw;
173185 };
174186
175187 static struct workqueue_struct *nfit_wq;
@@ -181,6 +193,226 @@ static struct nfit_test *to_nfit_test(struct device *dev) · 5 unmodified lines
181193 return container_of(pdev, struct nfit_test, pdev);
182194 }
183195
196+static int nd_intel_test_get_fw_info(struct nfit_test *t,
197+ struct nd_intel_fw_info *nd_cmd, unsigned int buf_len,
198+ int idx)
199+{
200+ struct device *dev = &t->pdev.dev;
201+ struct nfit_test_fw *fw = &t->fw[idx];
202+
203+ dev_dbg(dev, "%s(nfit_test: %p nd_cmd: %p, buf_len: %u, idx: %d\n",
204+ __func__, t, nd_cmd, buf_len, idx);
205+
206+ if (buf_len < sizeof(*nd_cmd))
207+ return -EINVAL;
208+
209+ nd_cmd->status = 0;
210+ nd_cmd->storage_size = INTEL_FW_STORAGE_SIZE;
211+ nd_cmd->max_send_len = INTEL_FW_MAX_SEND_LEN;
212+ nd_cmd->query_interval = INTEL_FW_QUERY_INTERVAL;
213+ nd_cmd->max_query_time = INTEL_FW_QUERY_MAX_TIME;
214+ nd_cmd->update_cap = 0;
215+ nd_cmd->fis_version = INTEL_FW_FIS_VERSION;
216+ nd_cmd->run_version = 0;
217+ nd_cmd->updated_version = fw->version;
218+
219+ return 0;
220+}
221+
222+static int nd_intel_test_start_update(struct nfit_test *t,
223+ struct nd_intel_fw_start *nd_cmd, unsigned int buf_len,
224+ int idx)
225+{
226+ struct device *dev = &t->pdev.dev;
227+ struct nfit_test_fw *fw = &t->fw[idx];
228+
229+ dev_dbg(dev, "%s(nfit_test: %p nd_cmd: %p buf_len: %u idx: %d)\n",
230+ __func__, t, nd_cmd, buf_len, idx);
231+
232+ if (buf_len < sizeof(*nd_cmd))
233+ return -EINVAL;
234+
235+ if (fw->state != FW_STATE_NEW) {
236+ /* extended status, FW update in progress */
237+ nd_cmd->status = 0x10007;
238+ return 0;
239+ }
240+
241+ fw->state = FW_STATE_IN_PROGRESS;
242+ fw->context++;
243+ fw->size_received = 0;
244+ nd_cmd->status = 0;
245+ nd_cmd->context = fw->context;
246+
247+ dev_dbg(dev, "%s: context issued: %#x\n", __func__, nd_cmd->context);
248+
249+ return 0;
250+}
251+
252+static int nd_intel_test_send_data(struct nfit_test *t,
253+ struct nd_intel_fw_send_data *nd_cmd, unsigned int buf_len,
254+ int idx)
255+{
256+ struct device *dev = &t->pdev.dev;
257+ struct nfit_test_fw *fw = &t->fw[idx];
258+ u32 *status = (u32 *)&nd_cmd->data[nd_cmd->length];
259+
260+ dev_dbg(dev, "%s(nfit_test: %p nd_cmd: %p buf_len: %u idx: %d)\n",
261+ __func__, t, nd_cmd, buf_len, idx);
262+
263+ if (buf_len < sizeof(*nd_cmd))
264+ return -EINVAL;
265+
266+
267+ dev_dbg(dev, "%s: cmd->status: %#x\n", __func__, *status);
268+ dev_dbg(dev, "%s: cmd->data[0]: %#x\n", __func__, nd_cmd->data[0]);
269+ dev_dbg(dev, "%s: cmd->data[%u]: %#x\n", __func__, nd_cmd->length-1,
270+ nd_cmd->data[nd_cmd->length-1]);
271+
272+ if (fw->state != FW_STATE_IN_PROGRESS) {
273+ dev_dbg(dev, "%s: not in IN_PROGRESS state\n", __func__);
274+ *status = 0x5;
275+ return 0;
276+ }
277+
278+ if (nd_cmd->context != fw->context) {
279+ dev_dbg(dev, "%s: incorrect context: in: %#x correct: %#x\n",
280+ __func__, nd_cmd->context, fw->context);
281+ *status = 0x10007;
282+ return 0;
283+ }
284+
285+ /*
286+ * check offset + len > size of fw storage
287+ * check length is > max send length
288+ */
289+ if (nd_cmd->offset + nd_cmd->length > INTEL_FW_STORAGE_SIZE ||
290+ nd_cmd->length > INTEL_FW_MAX_SEND_LEN) {
291+ *status = 0x3;
292+ dev_dbg(dev, "%s: buffer boundary violation\n", __func__);
293+ return 0;
294+ }
295+
296+ fw->size_received += nd_cmd->length;
297+ dev_dbg(dev, "%s: copying %u bytes, %u bytes so far\n",
298+ __func__, nd_cmd->length, fw->size_received);
299+ *status = 0;
300+ return 0;
301+}
302+
303+static int nd_intel_test_finish_fw(struct nfit_test *t,
304+ struct nd_intel_fw_finish_update *nd_cmd,
305+ unsigned int buf_len, int idx)
306+{
307+ struct device *dev = &t->pdev.dev;
308+ struct nfit_test_fw *fw = &t->fw[idx];
309+
310+ dev_dbg(dev, "%s(nfit_test: %p nd_cmd: %p buf_len: %u idx: %d)\n",
311+ __func__, t, nd_cmd, buf_len, idx);
312+
313+ if (fw->state == FW_STATE_UPDATED) {
314+ /* update already done, need cold boot */
315+ nd_cmd->status = 0x20007;
316+ return 0;
317+ }
318+
319+ dev_dbg(dev, "%s: context: %#x ctrl_flags: %#x\n",
320+ __func__, nd_cmd->context, nd_cmd->ctrl_flags);
321+
322+ switch (nd_cmd->ctrl_flags) {
323+ case 0: /* finish */
324+ if (nd_cmd->context != fw->context) {
325+ dev_dbg(dev, "%s: incorrect context: in: %#x correct: %#x\n",
326+ __func__, nd_cmd->context,
327+ fw->context);
328+ nd_cmd->status = 0x10007;
329+ return 0;
330+ }
331+ nd_cmd->status = 0;
332+ fw->state = FW_STATE_VERIFY;
333+ /* set 1 second of time for firmware "update" */
334+ fw->end_time = jiffies + HZ;
335+ break;
336+
337+ case 1: /* abort */
338+ fw->size_received = 0;
339+ /* successfully aborted status */
340+ nd_cmd->status = 0x40007;
341+ fw->state = FW_STATE_NEW;
342+ dev_dbg(dev, "%s: abort successful\n", __func__);
343+ break;
344+
345+ default: /* bad control flag */
346+ dev_warn(dev, "%s: unknown control flag: %#x\n",
347+ __func__, nd_cmd->ctrl_flags);
348+ return -EINVAL;
349+ }
350+
351+ return 0;
352+}
353+
354+static int nd_intel_test_finish_query(struct nfit_test *t,
355+ struct nd_intel_fw_finish_query *nd_cmd,
356+ unsigned int buf_len, int idx)
357+{
358+ struct device *dev = &t->pdev.dev;
359+ struct nfit_test_fw *fw = &t->fw[idx];
360+
361+ dev_dbg(dev, "%s(nfit_test: %p nd_cmd: %p buf_len: %u idx: %d)\n",
362+ __func__, t, nd_cmd, buf_len, idx);
363+
364+ if (buf_len < sizeof(*nd_cmd))
365+ return -EINVAL;
366+
367+ if (nd_cmd->context != fw->context) {
368+ dev_dbg(dev, "%s: incorrect context: in: %#x correct: %#x\n",
369+ __func__, nd_cmd->context, fw->context);
370+ nd_cmd->status = 0x10007;
371+ return 0;
372+ }
373+
374+ dev_dbg(dev, "%s context: %#x\n", __func__, nd_cmd->context);
375+
376+ switch (fw->state) {
377+ case FW_STATE_NEW:
378+ nd_cmd->updated_fw_rev = 0;
379+ nd_cmd->status = 0;
380+ dev_dbg(dev, "%s: new state\n", __func__);
381+ break;
382+
383+ case FW_STATE_IN_PROGRESS:
384+ /* sequencing error */
385+ nd_cmd->status = 0x40007;
386+ nd_cmd->updated_fw_rev = 0;
387+ dev_dbg(dev, "%s: sequence error\n", __func__);
388+ break;
389+
390+ case FW_STATE_VERIFY:
391+ if (time_is_after_jiffies64(fw->end_time)) {
392+ nd_cmd->updated_fw_rev = 0;
393+ nd_cmd->status = 0x20007;
394+ dev_dbg(dev, "%s: still verifying\n", __func__);
395+ break;
396+ }
397+
398+ dev_dbg(dev, "%s: transition out verify\n", __func__);
399+ fw->state = FW_STATE_UPDATED;
400+ /* we are going to fall through if it's "done" */
401+ case FW_STATE_UPDATED:
402+ nd_cmd->status = 0;
403+ /* bogus test version */
404+ fw->version = nd_cmd->updated_fw_rev =
405+ INTEL_FW_FAKE_VERSION;
406+ dev_dbg(dev, "%s: updated\n", __func__);
407+ break;
408+
409+ default: /* we should never get here */
410+ return -EINVAL;
411+ }
412+
413+ return 0;
414+}
415+
184416 static int nfit_test_cmd_get_config_size(struct nd_cmd_get_config_size *nd_cmd,
185417 unsigned int buf_len)
186418 {
@@ -440,39 +672,66 @@ static int nfit_test_cmd_translate_spa(struct nvdimm_bus *bus, · 253 unmodified lines
440672 return 0;
441673 }
442674
443−static int nfit_test_cmd_smart(struct nd_cmd_smart *smart, unsigned int buf_len)
675+static int nfit_test_cmd_smart(struct nd_intel_smart *smart, unsigned int buf_len,
676+ struct nd_intel_smart *smart_data)
444677 {
445− static const struct nd_smart_payload smart_data = {
446− .flags = ND_SMART_HEALTH_VALID | ND_SMART_TEMP_VALID
447− | ND_SMART_SPARES_VALID | ND_SMART_ALARM_VALID
448− | ND_SMART_USED_VALID | ND_SMART_SHUTDOWN_VALID,
449− .health = ND_SMART_NON_CRITICAL_HEALTH,
450− .temperature = 23 * 16,
451− .spares = 75,
452− .alarm_flags = ND_SMART_SPARE_TRIP | ND_SMART_TEMP_TRIP,
453− .life_used = 5,
454− .shutdown_state = 0,
455− .vendor_size = 0,
456− };
457−
458678 if (buf_len < sizeof(*smart))
459679 return -EINVAL;
460− memcpy(smart->data, &smart_data, sizeof(smart_data));
680+ memcpy(smart, smart_data, sizeof(*smart));
461681 return 0;
462682 }
463683
464−static int nfit_test_cmd_smart_threshold(struct nd_cmd_smart_threshold *smart_t,
465− unsigned int buf_len)
684+static int nfit_test_cmd_smart_threshold(
685+ struct nd_intel_smart_threshold *out,
686+ unsigned int buf_len,
687+ struct nd_intel_smart_threshold *smart_t)
466688 {
467− static const struct nd_smart_threshold_payload smart_t_data = {
468− .alarm_control = ND_SMART_SPARE_TRIP | ND_SMART_TEMP_TRIP,
469− .temperature = 40 * 16,
470− .spares = 5,
471− };
472−
473689 if (buf_len < sizeof(*smart_t))
474690 return -EINVAL;
475− memcpy(smart_t->data, &smart_t_data, sizeof(smart_t_data));
691+ memcpy(out, smart_t, sizeof(*smart_t));
692+ return 0;
693+}
694+
695+static void smart_notify(struct device *bus_dev,
696+ struct device *dimm_dev, struct nd_intel_smart *smart,
697+ struct nd_intel_smart_threshold *thresh)
698+{
699+ dev_dbg(dimm_dev, "%s: alarm: %#x spares: %d (%d) mtemp: %d (%d) ctemp: %d (%d)\n",
700+ __func__, thresh->alarm_control, thresh->spares,
701+ smart->spares, thresh->media_temperature,
702+ smart->media_temperature, thresh->ctrl_temperature,
703+ smart->ctrl_temperature);
704+ if (((thresh->alarm_control & ND_INTEL_SMART_SPARE_TRIP)
705+ && smart->spares
706+ <= thresh->spares)
707+ || ((thresh->alarm_control & ND_INTEL_SMART_TEMP_TRIP)
708+ && smart->media_temperature
709+ >= thresh->media_temperature)
710+ || ((thresh->alarm_control & ND_INTEL_SMART_CTEMP_TRIP)
711+ && smart->ctrl_temperature
712+ >= thresh->ctrl_temperature)) {
713+ device_lock(bus_dev);
714+ __acpi_nvdimm_notify(dimm_dev, 0x81);
715+ device_unlock(bus_dev);
716+ }
717+}
718+
719+static int nfit_test_cmd_smart_set_threshold(
720+ struct nd_intel_smart_set_threshold *in,
721+ unsigned int buf_len,
722+ struct nd_intel_smart_threshold *thresh,
723+ struct nd_intel_smart *smart,
724+ struct device *bus_dev, struct device *dimm_dev)
725+{
726+ unsigned int size;
727+
728+ size = sizeof(*in) - 4;
729+ if (buf_len < size)
730+ return -EINVAL;
731+ memcpy(thresh->data, in, size);
732+ in->status = 0;
733+ smart_notify(bus_dev, dimm_dev, smart, thresh);
734+
476735 return 0;
477736 }
478737
@@ -563,6 +822,52 @@ static int nfit_test_cmd_ars_inject_status(struct nfit_test *t, · 84 unmodified lines
563822 return 0;
564823 }
565824
825+static int nd_intel_test_cmd_set_lss_status(struct nfit_test *t,
826+ struct nd_intel_lss *nd_cmd, unsigned int buf_len)
827+{
828+ struct device *dev = &t->pdev.dev;
829+
830+ if (buf_len < sizeof(*nd_cmd))
831+ return -EINVAL;
832+
833+ switch (nd_cmd->enable) {
834+ case 0:
835+ nd_cmd->status = 0;
836+ dev_dbg(dev, "%s: Latch System Shutdown Status disabled\n",
837+ __func__);
838+ break;
839+ case 1:
840+ nd_cmd->status = 0;
841+ dev_dbg(dev, "%s: Latch System Shutdown Status enabled\n",
842+ __func__);
843+ break;
844+ default:
845+ dev_warn(dev, "Unknown enable value: %#x\n", nd_cmd->enable);
846+ nd_cmd->status = 0x3;
847+ break;
848+ }
849+
850+
851+ return 0;
852+}
853+
854+static int get_dimm(struct nfit_mem *nfit_mem, unsigned int func)
855+{
856+ int i;
857+
858+ /* lookup per-dimm data */
859+ for (i = 0; i < ARRAY_SIZE(handle); i++)
860+ if (__to_nfit_memdev(nfit_mem)->device_handle == handle[i])
861+ break;
862+ if (i >= ARRAY_SIZE(handle))
863+ return -ENXIO;
864+
865+ if ((1 << func) & dimm_fail_cmd_flags[i])
866+ return -EIO;
867+
868+ return i;
869+}
870+
566871 static int nfit_test_ctl(struct nvdimm_bus_descriptor *nd_desc,
567872 struct nvdimm *nvdimm, unsigned int cmd, void *buf,
568873 unsigned int buf_len, int *cmd_rc)
@@ -591,22 +896,57 @@ static int nfit_test_ctl(struct nvdimm_bus_descriptor *nd_desc, · 22 unmodified lines
591896 func = call_pkg->nd_command;
592897 if (call_pkg->nd_family != nfit_mem->family)
593898 return -ENOTTY;
899+
900+ i = get_dimm(nfit_mem, func);
901+ if (i < 0)
902+ return i;
903+
904+ switch (func) {
905+ case ND_INTEL_ENABLE_LSS_STATUS:
906+ return nd_intel_test_cmd_set_lss_status(t,
907+ buf, buf_len);
908+ case ND_INTEL_FW_GET_INFO:
909+ return nd_intel_test_get_fw_info(t, buf,
910+ buf_len, i - t->dcr_idx);
911+ case ND_INTEL_FW_START_UPDATE:
912+ return nd_intel_test_start_update(t, buf,
913+ buf_len, i - t->dcr_idx);
914+ case ND_INTEL_FW_SEND_DATA:
915+ return nd_intel_test_send_data(t, buf,
916+ buf_len, i - t->dcr_idx);
917+ case ND_INTEL_FW_FINISH_UPDATE:
918+ return nd_intel_test_finish_fw(t, buf,
919+ buf_len, i - t->dcr_idx);
920+ case ND_INTEL_FW_FINISH_QUERY:
921+ return nd_intel_test_finish_query(t, buf,
922+ buf_len, i - t->dcr_idx);
923+ case ND_INTEL_SMART:
924+ return nfit_test_cmd_smart(buf, buf_len,
925+ &t->smart[i - t->dcr_idx]);
926+ case ND_INTEL_SMART_THRESHOLD:
927+ return nfit_test_cmd_smart_threshold(buf,
928+ buf_len,
929+ &t->smart_threshold[i -
930+ t->dcr_idx]);
931+ case ND_INTEL_SMART_SET_THRESHOLD:
932+ return nfit_test_cmd_smart_set_threshold(buf,
933+ buf_len,
934+ &t->smart_threshold[i -
935+ t->dcr_idx],
936+ &t->smart[i - t->dcr_idx],
937+ &t->pdev.dev, t->dimm_dev[i]);
938+ default:
939+ return -ENOTTY;
940+ }
594941 }
595942
596943 if (!test_bit(cmd, &cmd_mask)
597944 || !test_bit(func, &nfit_mem->dsm_mask))
598945 return -ENOTTY;
599946
600− /* lookup label space for the given dimm */
601− for (i = 0; i < ARRAY_SIZE(handle); i++)
602− if (__to_nfit_memdev(nfit_mem)->device_handle ==
603− handle[i])
604− break;
605− if (i >= ARRAY_SIZE(handle))
606− return -ENXIO;
607−
608− if ((1 << func) & dimm_fail_cmd_flags[i])
609− return -EIO;
947+ i = get_dimm(nfit_mem, func);
948+ if (i < 0)
949+ return i;
610950
611951 switch (func) {
612952 case ND_CMD_GET_CONFIG_SIZE:
@@ -620,15 +960,6 @@ static int nfit_test_ctl(struct nvdimm_bus_descriptor *nd_desc, · 7 unmodified lines
620960 rc = nfit_test_cmd_set_config_data(buf, buf_len,
621961 t->label[i - t->dcr_idx]);
622962 break;
623− case ND_CMD_SMART:
624− rc = nfit_test_cmd_smart(buf, buf_len);
625− break;
626− case ND_CMD_SMART_THRESHOLD:
627− rc = nfit_test_cmd_smart_threshold(buf, buf_len);
628− device_lock(&t->pdev.dev);
629− __acpi_nvdimm_notify(t->dimm_dev[i], 0x81);
630− device_unlock(&t->pdev.dev);
631− break;
632963 default:
633964 return -ENOTTY;
634965 }
@@ -872,6 +1203,44 @@ static const struct attribute_group *nfit_test_dimm_attribute_groups[] = { · 237 unmodified lines
8721203 NULL,
8731204 };
8741205
1206+static void smart_init(struct nfit_test *t)
1207+{
1208+ int i;
1209+ const struct nd_intel_smart_threshold smart_t_data = {
1210+ .alarm_control = ND_INTEL_SMART_SPARE_TRIP
1211+ | ND_INTEL_SMART_TEMP_TRIP,
1212+ .media_temperature = 40 * 16,
1213+ .ctrl_temperature = 30 * 16,
1214+ .spares = 5,
1215+ };
1216+ const struct nd_intel_smart smart_data = {
1217+ .flags = ND_INTEL_SMART_HEALTH_VALID
1218+ | ND_INTEL_SMART_SPARES_VALID
1219+ | ND_INTEL_SMART_ALARM_VALID
1220+ | ND_INTEL_SMART_USED_VALID
1221+ | ND_INTEL_SMART_SHUTDOWN_VALID
1222+ | ND_INTEL_SMART_MTEMP_VALID,
1223+ .health = ND_INTEL_SMART_NON_CRITICAL_HEALTH,
1224+ .media_temperature = 23 * 16,
1225+ .ctrl_temperature = 30 * 16,
1226+ .pmic_temperature = 40 * 16,
1227+ .spares = 75,
1228+ .alarm_flags = ND_INTEL_SMART_SPARE_TRIP
1229+ | ND_INTEL_SMART_TEMP_TRIP,
1230+ .ait_status = 1,
1231+ .life_used = 5,
1232+ .shutdown_state = 0,
1233+ .vendor_size = 0,
1234+ .shutdown_count = 100,
1235+ };
1236+
1237+ for (i = 0; i < t->num_dcr; i++) {
1238+ memcpy(&t->smart[i], &smart_data, sizeof(smart_data));
1239+ memcpy(&t->smart_threshold[i], &smart_t_data,
1240+ sizeof(smart_t_data));
1241+ }
1242+}
1243+
8751244 static int nfit_test0_alloc(struct nfit_test *t)
8761245 {
8771246 size_t nfit_size = sizeof(struct acpi_nfit_system_address) * NUM_SPA
@@ -881,7 +1250,8 @@ static int nfit_test0_alloc(struct nfit_test *t) · 3 unmodified lines
8811250 window_size) * NUM_DCR
8821251 + sizeof(struct acpi_nfit_data_region) * NUM_BDW
8831252 + (sizeof(struct acpi_nfit_flush_address)
884− + sizeof(u64) * NUM_HINTS) * NUM_DCR;
1253+ + sizeof(u64) * NUM_HINTS) * NUM_DCR
1254+ + sizeof(struct acpi_nfit_capabilities);
8851255 int i;
8861256
8871257 t->nfit_buf = test_alloc(t, nfit_size, &t->nfit_dma);
@@ -939,6 +1309,7 @@ static int nfit_test0_alloc(struct nfit_test *t) · 51 unmodified lines
9391309 return -ENOMEM;
9401310 }
9411311
1312+ smart_init(t);
9421313 return ars_state_init(&t->pdev.dev, &t->ars_state);
9431314 }
9441315
@@ -969,6 +1340,7 @@ static int nfit_test1_alloc(struct nfit_test *t) · 24 unmodified lines
9691340 if (!t->spa_set[1])
9701341 return -ENOMEM;
9711342
1343+ smart_init(t);
9721344 return ars_state_init(&t->pdev.dev, &t->ars_state);
9731345 }
9741346
@@ -993,6 +1365,7 @@ static void nfit_test0_setup(struct nfit_test *t) · 18 unmodified lines
9931365 struct acpi_nfit_control_region *dcr;
9941366 struct acpi_nfit_data_region *bdw;
9951367 struct acpi_nfit_flush_address *flush;
1368+ struct acpi_nfit_capabilities *pcap;
9961369 unsigned int offset, i;
9971370
9981371 /*
@@ -1500,8 +1873,16 @@ static void nfit_test0_setup(struct nfit_test *t) · 501 unmodified lines
15001873 for (i = 0; i < NUM_HINTS; i++)
15011874 flush->hint_address[i] = t->flush_dma[3] + i * sizeof(u64);
15021875
1876+ /* platform capabilities */
1877+ pcap = nfit_buf + offset + flush_hint_size * 4;
1878+ pcap->header.type = ACPI_NFIT_TYPE_CAPABILITIES;
1879+ pcap->header.length = sizeof(*pcap);
1880+ pcap->highest_capability = 1;
1881+ pcap->capabilities = ACPI_NFIT_CAPABILITY_CACHE_FLUSH |
1882+ ACPI_NFIT_CAPABILITY_MEM_FLUSH;
1883+
15031884 if (t->setup_hotplug) {
1504− offset = offset + flush_hint_size * 4;
1885+ offset = offset + flush_hint_size * 4 + sizeof(*pcap);
15051886 /* dcr-descriptor4: blk */
15061887 dcr = nfit_buf + offset;
15071888 dcr->header.type = ACPI_NFIT_TYPE_CONTROL_REGION;
@@ -1642,17 +2023,24 @@ static void nfit_test0_setup(struct nfit_test *t) · 134 unmodified lines
16422023 set_bit(ND_CMD_GET_CONFIG_SIZE, &acpi_desc->dimm_cmd_force_en);
16432024 set_bit(ND_CMD_GET_CONFIG_DATA, &acpi_desc->dimm_cmd_force_en);
16442025 set_bit(ND_CMD_SET_CONFIG_DATA, &acpi_desc->dimm_cmd_force_en);
1645− set_bit(ND_CMD_SMART, &acpi_desc->dimm_cmd_force_en);
2026+ set_bit(ND_INTEL_SMART, &acpi_desc->dimm_cmd_force_en);
2027+ set_bit(ND_INTEL_SMART_THRESHOLD, &acpi_desc->dimm_cmd_force_en);
2028+ set_bit(ND_INTEL_SMART_SET_THRESHOLD, &acpi_desc->dimm_cmd_force_en);
16462029 set_bit(ND_CMD_ARS_CAP, &acpi_desc->bus_cmd_force_en);
16472030 set_bit(ND_CMD_ARS_START, &acpi_desc->bus_cmd_force_en);
16482031 set_bit(ND_CMD_ARS_STATUS, &acpi_desc->bus_cmd_force_en);
16492032 set_bit(ND_CMD_CLEAR_ERROR, &acpi_desc->bus_cmd_force_en);
16502033 set_bit(ND_CMD_CALL, &acpi_desc->bus_cmd_force_en);
1651− set_bit(ND_CMD_SMART_THRESHOLD, &acpi_desc->dimm_cmd_force_en);
16522034 set_bit(NFIT_CMD_TRANSLATE_SPA, &acpi_desc->bus_nfit_cmd_force_en);
16532035 set_bit(NFIT_CMD_ARS_INJECT_SET, &acpi_desc->bus_nfit_cmd_force_en);
16542036 set_bit(NFIT_CMD_ARS_INJECT_CLEAR, &acpi_desc->bus_nfit_cmd_force_en);
16552037 set_bit(NFIT_CMD_ARS_INJECT_GET, &acpi_desc->bus_nfit_cmd_force_en);
2038+ set_bit(ND_INTEL_FW_GET_INFO, &acpi_desc->dimm_cmd_force_en);
2039+ set_bit(ND_INTEL_FW_START_UPDATE, &acpi_desc->dimm_cmd_force_en);
2040+ set_bit(ND_INTEL_FW_SEND_DATA, &acpi_desc->dimm_cmd_force_en);
2041+ set_bit(ND_INTEL_FW_FINISH_UPDATE, &acpi_desc->dimm_cmd_force_en);
2042+ set_bit(ND_INTEL_FW_FINISH_QUERY, &acpi_desc->dimm_cmd_force_en);
2043+ set_bit(ND_INTEL_ENABLE_LSS_STATUS, &acpi_desc->dimm_cmd_force_en);
16562044 }
16572045
16582046 static void nfit_test1_setup(struct nfit_test *t)
@@ -1750,6 +2138,7 @@ static void nfit_test1_setup(struct nfit_test *t) · 91 unmodified lines
17502138 set_bit(ND_CMD_ARS_START, &acpi_desc->bus_cmd_force_en);
17512139 set_bit(ND_CMD_ARS_STATUS, &acpi_desc->bus_cmd_force_en);
17522140 set_bit(ND_CMD_CLEAR_ERROR, &acpi_desc->bus_cmd_force_en);
2141+ set_bit(ND_INTEL_ENABLE_LSS_STATUS, &acpi_desc->dimm_cmd_force_en);
17532142 }
17542143
17552144 static int nfit_test_blk_do_io(struct nd_blk_region *ndbr, resource_size_t dpa,
@@ -2054,10 +2443,18 @@ static int nfit_test_probe(struct platform_device *pdev) · 298 unmodified lines
20542443 sizeof(struct nfit_test_dcr *), GFP_KERNEL);
20552444 nfit_test->dcr_dma = devm_kcalloc(dev, num,
20562445 sizeof(dma_addr_t), GFP_KERNEL);
2446+ nfit_test->smart = devm_kcalloc(dev, num,
2447+ sizeof(struct nd_intel_smart), GFP_KERNEL);
2448+ nfit_test->smart_threshold = devm_kcalloc(dev, num,
2449+ sizeof(struct nd_intel_smart_threshold),
2450+ GFP_KERNEL);
2451+ nfit_test->fw = devm_kcalloc(dev, num,
2452+ sizeof(struct nfit_test_fw), GFP_KERNEL);
20572453 if (nfit_test->dimm && nfit_test->dimm_dma && nfit_test->label
20582454 && nfit_test->label_dma && nfit_test->dcr
20592455 && nfit_test->dcr_dma && nfit_test->flush
2060− && nfit_test->flush_dma)
2456+ && nfit_test->flush_dma
2457+ && nfit_test->fw)
20612458 /* pass */;
20622459 else
20632460 return -ENOMEM;
@@ -2159,6 +2556,11 @@ static __init int nfit_test_init(void) · 95 unmodified lines
21592556 {
21602557 int rc, i;
21612558
2559+ pmem_test();
2560+ libnvdimm_test();
2561+ acpi_nfit_test();
2562+ device_dax_test();
2563+
21622564 nfit_test_setup(nfit_test_lookup, nfit_test_evaluate_dsm);
21632565
21642566 nfit_wq = create_singlethread_workqueue("nfit");
tools/testing/nvdimm/test/nfit_test.h+134−0
@@ -84,6 +84,140 @@ struct nd_cmd_ars_err_inj_stat { · 83 unmodified lines
8484 } __packed record[0];
8585 } __packed;
8686
87+#define ND_INTEL_SMART 1
88+#define ND_INTEL_SMART_THRESHOLD 2
89+#define ND_INTEL_ENABLE_LSS_STATUS 10
90+#define ND_INTEL_FW_GET_INFO 12
91+#define ND_INTEL_FW_START_UPDATE 13
92+#define ND_INTEL_FW_SEND_DATA 14
93+#define ND_INTEL_FW_FINISH_UPDATE 15
94+#define ND_INTEL_FW_FINISH_QUERY 16
95+#define ND_INTEL_SMART_SET_THRESHOLD 17
96+
97+#define ND_INTEL_SMART_HEALTH_VALID (1 << 0)
98+#define ND_INTEL_SMART_SPARES_VALID (1 << 1)
99+#define ND_INTEL_SMART_USED_VALID (1 << 2)
100+#define ND_INTEL_SMART_MTEMP_VALID (1 << 3)
101+#define ND_INTEL_SMART_CTEMP_VALID (1 << 4)
102+#define ND_INTEL_SMART_SHUTDOWN_COUNT_VALID (1 << 5)
103+#define ND_INTEL_SMART_AIT_STATUS_VALID (1 << 6)
104+#define ND_INTEL_SMART_PTEMP_VALID (1 << 7)
105+#define ND_INTEL_SMART_ALARM_VALID (1 << 9)
106+#define ND_INTEL_SMART_SHUTDOWN_VALID (1 << 10)
107+#define ND_INTEL_SMART_VENDOR_VALID (1 << 11)
108+#define ND_INTEL_SMART_SPARE_TRIP (1 << 0)
109+#define ND_INTEL_SMART_TEMP_TRIP (1 << 1)
110+#define ND_INTEL_SMART_CTEMP_TRIP (1 << 2)
111+#define ND_INTEL_SMART_NON_CRITICAL_HEALTH (1 << 0)
112+#define ND_INTEL_SMART_CRITICAL_HEALTH (1 << 1)
113+#define ND_INTEL_SMART_FATAL_HEALTH (1 << 2)
114+
115+struct nd_intel_smart {
116+ __u32 status;
117+ union {
118+ struct {
119+ __u32 flags;
120+ __u8 reserved0[4];
121+ __u8 health;
122+ __u8 spares;
123+ __u8 life_used;
124+ __u8 alarm_flags;
125+ __u16 media_temperature;
126+ __u16 ctrl_temperature;
127+ __u32 shutdown_count;
128+ __u8 ait_status;
129+ __u16 pmic_temperature;
130+ __u8 reserved1[8];
131+ __u8 shutdown_state;
132+ __u32 vendor_size;
133+ __u8 vendor_data[92];
134+ } __packed;
135+ __u8 data[128];
136+ };
137+} __packed;
138+
139+struct nd_intel_smart_threshold {
140+ __u32 status;
141+ union {
142+ struct {
143+ __u16 alarm_control;
144+ __u8 spares;
145+ __u16 media_temperature;
146+ __u16 ctrl_temperature;
147+ __u8 reserved[1];
148+ } __packed;
149+ __u8 data[8];
150+ };
151+} __packed;
152+
153+struct nd_intel_smart_set_threshold {
154+ __u16 alarm_control;
155+ __u8 spares;
156+ __u16 media_temperature;
157+ __u16 ctrl_temperature;
158+ __u32 status;
159+} __packed;
160+
161+#define INTEL_FW_STORAGE_SIZE 0x100000
162+#define INTEL_FW_MAX_SEND_LEN 0xFFEC
163+#define INTEL_FW_QUERY_INTERVAL 250000
164+#define INTEL_FW_QUERY_MAX_TIME 3000000
165+#define INTEL_FW_FIS_VERSION 0x0105
166+#define INTEL_FW_FAKE_VERSION 0xffffffffabcd
167+
168+enum intel_fw_update_state {
169+ FW_STATE_NEW = 0,
170+ FW_STATE_IN_PROGRESS,
171+ FW_STATE_VERIFY,
172+ FW_STATE_UPDATED,
173+};
174+
175+struct nd_intel_fw_info {
176+ __u32 status;
177+ __u32 storage_size;
178+ __u32 max_send_len;
179+ __u32 query_interval;
180+ __u32 max_query_time;
181+ __u8 update_cap;
182+ __u8 reserved[3];
183+ __u32 fis_version;
184+ __u64 run_version;
185+ __u64 updated_version;
186+} __packed;
187+
188+struct nd_intel_fw_start {
189+ __u32 status;
190+ __u32 context;
191+} __packed;
192+
193+/* this one has the output first because the variable input data size */
194+struct nd_intel_fw_send_data {
195+ __u32 context;
196+ __u32 offset;
197+ __u32 length;
198+ __u8 data[0];
199+/* this field is not declared due ot variable data from input */
200+/* __u32 status; */
201+} __packed;
202+
203+struct nd_intel_fw_finish_update {
204+ __u8 ctrl_flags;
205+ __u8 reserved[3];
206+ __u32 context;
207+ __u32 status;
208+} __packed;
209+
210+struct nd_intel_fw_finish_query {
211+ __u32 context;
212+ __u32 status;
213+ __u64 updated_fw_rev;
214+} __packed;
215+
216+struct nd_intel_lss {
217+ __u8 enable;
218+ __u32 status;
219+} __packed;
220+
87221 union acpi_object;
88222 typedef void *acpi_handle;
89223
tools/testing/nvdimm/watermark.h+21−0
@@ -0,0 +1,21 @@
1+// SPDX-License-Identifier: GPL-2.0
2+// Copyright(c) 2018 Intel Corporation. All rights reserved.
3+#ifndef _TEST_NVDIMM_WATERMARK_H_
4+#define _TEST_NVDIMM_WATERMARK_H_
5+int pmem_test(void);
6+int libnvdimm_test(void);
7+int acpi_nfit_test(void);
8+int device_dax_test(void);
9+
10+/*
11+ * dummy routine for nfit_test to validate it is linking to the properly
12+ * mocked module and not the standard one from the base tree.
13+ */
14+#define nfit_test_watermark(x) \
15+int x##_test(void) \
16+{ \
17+ pr_debug("%s for nfit_test\n", KBUILD_MODNAME); \
18+ return 0; \
19+} \
20+EXPORT_SYMBOL(x##_test)
21+#endif /* _TEST_NVDIMM_WATERMARK_H_ */

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t