December 2015 - Linux-nvdimm

[PATCH v2 00/25] replace ioremap_{cache|wt} with memremap

by Dan Williams

Changes since v1 [1]: 1/ Drop the attempt at unifying ioremap() prototypes, just focus on converting ioremap_cache and ioremap_wt over to memremap (Christoph) 2/ Drop the unrelated cleanups to use %pa in __ioremap_caller (Thomas) 3/ Add support for memremap() attempts on "System RAM" to simply return the kernel virtual address for that range. ARM depends on this functionality in ioremap_cache() and ACPI was open coding a similar solution. (Mark) 4/ Split the conversions of ioremap_{cache|wt} into separate patches per driver / arch. 5/ Fix bisection breakage and other reports from 0day-kbuild --- While developing the pmem driver we noticed that the __iomem annotation on the return value from ioremap_cache() was being mishandled by several callers. We also observed that all of the call sites expected to be able to treat the return value from ioremap_cache() as normal (non-__iomem) pointer to memory. This patchset takes the opportunity to clean up the above confusion as well as a few issues with the ioremap_{cache|wt} interface, including: 1/ Eliminating the possibility of function prototypes differing between architectures by defining a central memremap() prototype that takes flags to determine the mapping type. 2/ Returning NULL rather than falling back silently to a different mapping-type. This allows drivers to be stricter about the mapping-type fallbacks that are permissible. [1]: http://marc.info/?l=linux-arm-kernel&m=143735199029255&w=2 --- Dan Williams (22): mm: enhance region_is_ram() to distinguish 'unknown' vs 'mixed' arch, drivers: don't include <asm/io.h> directly, use <linux/io.h> instead cleanup IORESOURCE_CACHEABLE vs ioremap() intel_iommu: fix leaked ioremap mapping arch: introduce memremap() arm: switch from ioremap_cache to memremap x86: switch from ioremap_cache to memremap gma500: switch from acpi_os_ioremap to ioremap i915: switch from acpi_os_ioremap to ioremap acpi: switch from ioremap_cache to memremap toshiba laptop: replace ioremap_cache with ioremap memconsole: fix __iomem mishandling, switch to memremap visorbus: switch from ioremap_cache to memremap intel-iommu: switch from ioremap_cache to memremap libnvdimm, pmem: switch from ioremap_cache to memremap pxa2xx-flash: switch from ioremap_cache to memremap sfi: switch from ioremap_cache to memremap fbdev: switch from ioremap_wt to memremap pmem: switch from ioremap_wt to memremap arch: remove ioremap_cache, replace with arch_memremap arch: remove ioremap_wt, replace with arch_memremap pmem: convert to generic memremap Toshi Kani (3): mm, x86: Fix warning in ioremap RAM check mm, x86: Remove region_is_ram() call from ioremap mm: Fix bugs in region_is_ram() arch/arc/include/asm/io.h | 1 arch/arm/Kconfig | 1 arch/arm/include/asm/io.h | 13 +++- arch/arm/include/asm/xen/page.h | 4 + arch/arm/mach-clps711x/board-cdb89712.c | 2 - arch/arm/mach-shmobile/pm-rcar.c | 2 - arch/arm/mm/ioremap.c | 12 +++- arch/arm/mm/nommu.c | 11 ++- arch/arm64/Kconfig | 1 arch/arm64/include/asm/acpi.h | 10 +-- arch/arm64/include/asm/dmi.h | 8 +-- arch/arm64/include/asm/io.h | 8 ++- arch/arm64/kernel/efi.c | 9 ++- arch/arm64/kernel/smp_spin_table.c | 19 +++--- arch/arm64/mm/ioremap.c | 20 ++---- arch/avr32/include/asm/io.h | 1 arch/frv/Kconfig | 1 arch/frv/include/asm/io.h | 17 ++--- arch/frv/mm/kmap.c | 6 ++ arch/ia64/Kconfig | 1 arch/ia64/include/asm/io.h | 11 +++ arch/ia64/kernel/cyclone.c | 2 - arch/m32r/include/asm/io.h | 1 arch/m68k/Kconfig | 1 arch/m68k/include/asm/io_mm.h | 14 +--- arch/m68k/include/asm/io_no.h | 12 ++-- arch/m68k/include/asm/raw_io.h | 4 + arch/m68k/mm/kmap.c | 17 +++++ arch/m68k/mm/sun3kmap.c | 6 ++ arch/metag/include/asm/io.h | 3 - arch/microblaze/include/asm/io.h | 1 arch/mn10300/include/asm/io.h | 1 arch/nios2/include/asm/io.h | 1 arch/powerpc/kernel/pci_of_scan.c | 2 - arch/s390/include/asm/io.h | 1 arch/sh/Kconfig | 1 arch/sh/include/asm/io.h | 20 ++++-- arch/sh/mm/ioremap.c | 10 +++ arch/sparc/include/asm/io_32.h | 1 arch/sparc/include/asm/io_64.h | 1 arch/sparc/kernel/pci.c | 3 - arch/tile/include/asm/io.h | 1 arch/x86/Kconfig | 1 arch/x86/include/asm/efi.h | 3 + arch/x86/include/asm/io.h | 17 +++-- arch/x86/kernel/crash_dump_64.c | 6 +- arch/x86/kernel/kdebugfs.c | 8 +-- arch/x86/kernel/ksysfs.c | 28 ++++----- arch/x86/mm/ioremap.c | 76 ++++++++++-------------- arch/xtensa/Kconfig | 1 arch/xtensa/include/asm/io.h | 9 ++- drivers/acpi/apei/einj.c | 9 ++- drivers/acpi/apei/erst.c | 6 +- drivers/acpi/nvs.c | 6 +- drivers/acpi/osl.c | 70 ++++++---------------- drivers/char/toshiba.c | 2 - drivers/firmware/google/memconsole.c | 7 +- drivers/gpu/drm/gma500/opregion.c | 2 - drivers/gpu/drm/i915/intel_opregion.c | 2 - drivers/iommu/intel-iommu.c | 10 ++- drivers/iommu/intel_irq_remapping.c | 4 + drivers/isdn/icn/icn.h | 2 - drivers/mtd/devices/slram.c | 2 - drivers/mtd/maps/pxa2xx-flash.c | 4 + drivers/mtd/nand/diskonchip.c | 2 - drivers/mtd/onenand/generic.c | 2 - drivers/nvdimm/Kconfig | 2 - drivers/pci/probe.c | 3 - drivers/pnp/manager.c | 2 - drivers/scsi/aic94xx/aic94xx_init.c | 7 -- drivers/scsi/arcmsr/arcmsr_hba.c | 5 -- drivers/scsi/mvsas/mv_init.c | 15 +---- drivers/scsi/sun3x_esp.c | 2 - drivers/sfi/sfi_core.c | 4 + drivers/staging/comedi/drivers/ii_pci20kc.c | 1 drivers/staging/unisys/visorbus/visorchannel.c | 16 +++-- drivers/staging/unisys/visorbus/visorchipset.c | 17 +++-- drivers/tty/serial/8250/8250_core.c | 2 - drivers/video/fbdev/Kconfig | 2 - drivers/video/fbdev/amifb.c | 5 +- drivers/video/fbdev/atafb.c | 5 +- drivers/video/fbdev/hpfb.c | 6 +- drivers/video/fbdev/ocfb.c | 1 drivers/video/fbdev/s1d13xxxfb.c | 3 - drivers/video/fbdev/stifb.c | 1 include/acpi/acpi_io.h | 6 +- include/asm-generic/io.h | 8 --- include/asm-generic/iomap.h | 4 - include/linux/io-mapping.h | 2 - include/linux/io.h | 9 +++ include/linux/mtd/map.h | 2 - include/linux/pmem.h | 26 +++++--- include/video/vga.h | 2 - kernel/Makefile | 2 + kernel/memremap.c | 74 +++++++++++++++++++++++ kernel/resource.c | 43 +++++++------- lib/Kconfig | 5 +- lib/devres.c | 13 +--- lib/pci_iomap.c | 7 +- tools/testing/nvdimm/Kbuild | 4 + tools/testing/nvdimm/test/iomap.c | 34 ++++++++--- 101 files changed, 482 insertions(+), 398 deletions(-) create mode 100644 kernel/memremap.c

4 years, 1 month

10
66
0 / 0

[PATCH v2 0/2] Expose known poison in SPA ranges to the block layer

by Vishal Verma

v2: - Move poison list walking from pmem to core (Dan) - If the pmem namespace starts at an offset, account for that (Dan) - Fix a bug in extended status checking for ars_status - Remove a duplicate include in pmem.c (only introduced in v1) - When doing an ars_status, don't error out if an ARS has not yet been performed. - When checking if ARS is supported, also check the extended status and make sure ARS for persistent memory is supported (as opposed to just volatile memory) - Print a dev_err message if find_poison fails - Collapse patches 2 and 3 into a single patch This series does a few things: - Retrieve all known poison in the system physical address (SPA) space using ARS (Address Range Scrub) commands to firmware - Store this poison in a new 'nd_poison' structure - In pmem, consume the poison list and expose the ranges as bad sectors This depends on the badblocks series sent out previously. A tree with the latest revisions of both the badblocks patchset and this can be found at: https://git.kernel.org/cgit/linux/kernel/git/vishal/nvdimm.git/log/?h=err... Vishal Verma (2): nfit_test: Enable DSMs for all test NFITs libnvdimm: Add a poison list and export badblocks drivers/acpi/nfit.c | 203 +++++++++++++++++++++++++++++++++++++++ drivers/nvdimm/core.c | 187 ++++++++++++++++++++++++++++++++++++ drivers/nvdimm/nd-core.h | 3 + drivers/nvdimm/nd.h | 6 ++ drivers/nvdimm/pmem.c | 6 ++ include/linux/libnvdimm.h | 1 + tools/testing/nvdimm/test/nfit.c | 9 ++ 7 files changed, 415 insertions(+) -- 2.5.0

4 years, 3 months

4
8
0 / 0

[PATCH v6 0/7] DAX fsync/msync support

by Ross Zwisler

Changes since v5 [1]: 1) Merged with Dan's changes to fs/dax.c that were staged in -mm and -next. 2) Store sectors in the address_space radix tree for DAX entries instead of addresses. This allows us to get the addresses from the block driver via dax_map_atomic() during fsync/msync so that we can protect against races with block device removal. (Dan) 3) Reordered things a bit in dax_writeback_one() so we clear the PAGECACHE_TAG_TOWRITE tag even if the radix tree entry is corrupt. This prevents us from getting into an infinite loop where we don't proceed far enough in dax_writeback_one() to clear that flag, but dax_writeback_mapping_range() will keep finding that entry via find_get_entries_tag(). 4) Changed the ordering of the radix tree insertion so that it happens before the page insertion into the page tables. This ensures that we don't end up in a case where the page table insertion succeeds and the radix tree insertion fails which could give us a writeable PTE that has no corresponding radix tree entry. 5) Got rid of the 'nrdax' variable in struct address_space and renamed 'nrshadows' to 'nrexceptional' so that it can be used for both DAX and shadow exceptional entries. We explicitly prevent shadow entries from being added to radix trees for DAX mappings, so the single counter can safely be reused for both purposes. (Jan) 6) Updated all my WARN_ON() calls so I use the return value to know whether I've hit an erorr. (Andrew) This series applies cleanly and was tested against next-20151223. A working tree can be found here: https://git.kernel.org/cgit/linux/kernel/git/zwisler/linux.git/log/?h=fsy... [1]: https://lists.01.org/pipermail/linux-nvdimm/2015-December/003588.html Ross Zwisler (7): pmem: add wb_cache_pmem() to the PMEM API dax: support dirty DAX entries in radix tree mm: add find_get_entries_tag() dax: add support for fsync/msync ext2: call dax_pfn_mkwrite() for DAX fsync/msync ext4: call dax_pfn_mkwrite() for DAX fsync/msync xfs: call dax_pfn_mkwrite() for DAX fsync/msync arch/x86/include/asm/pmem.h | 11 +-- fs/block_dev.c | 2 +- fs/dax.c | 196 ++++++++++++++++++++++++++++++++++++++++++-- fs/ext2/file.c | 4 +- fs/ext4/file.c | 4 +- fs/inode.c | 2 +- fs/xfs/xfs_file.c | 7 +- include/linux/dax.h | 7 ++ include/linux/fs.h | 3 +- include/linux/pagemap.h | 3 + include/linux/pmem.h | 22 ++++- include/linux/radix-tree.h | 9 ++ mm/filemap.c | 91 ++++++++++++++++++-- mm/truncate.c | 69 +++++++++------- mm/vmscan.c | 9 +- mm/workingset.c | 4 +- 16 files changed, 384 insertions(+), 59 deletions(-) -- 2.6.3

4 years, 4 months

6
25
0 / 0

arm64/efi handling of persistent memory

by Elliott, Robert (Persistent Memory)

Similar to the questions about the arm64 efi boot stub handing persistent memory, some of the arm64 kernel code looks fishy. In arch/arm64/kernel/efi.c: static int __init is_normal_ram(efi_memory_desc_t *md) { if (md->attribute & EFI_MEMORY_WB) return 1; return 0; } static __init int is_reserve_region(efi_memory_desc_t *md) { switch (md->type) { case EFI_LOADER_CODE: case EFI_LOADER_DATA: case EFI_BOOT_SERVICES_CODE: case EFI_BOOT_SERVICES_DATA: case EFI_CONVENTIONAL_MEMORY: case EFI_PERSISTENT_MEMORY: return 0; default: break; } return is_normal_ram(md); } static __init void reserve_regions(void) { ... if (is_normal_ram(md)) early_init_dt_add_memory_arch(paddr, size); if (is_reserve_region(md)) { memblock_reserve(paddr, size); ... static bool __init efi_virtmap_init(void) { ... if (!is_normal_ram(md)) prot = __pgprot(PROT_DEVICE_nGnRE); else if (md->type == EFI_RUNTIME_SERVICES_CODE || !PAGE_ALIGNED(md->phys_addr)) prot = PAGE_KERNEL_EXEC; else prot = PAGE_KERNEL; Concerns include: 1. is_normal_ram() will see the WB bit and return 1 regardless of the type. That seems similar to the arm EFI boot stub issue. The three callers are shown above. 2. is_reserve_region() treating EFI_PERSISTENT_MEMORY the same as EFI_CONVENTIONAL_MEMORY looks wrong. 3. We're contemplating working around the grub problem by reporting EFI_RESERVED_MEMORY plus the NV attribute rather than EFI_PERSISTENT_MEMORY. If this is done, then is_reserve_region() will fall through to is_normal_ram(), which will see the WB bit and return 1. That seems backwards... but seems correct for persistent memory, reporting it as a reserved region. That might avoid the the EFI_PERSISTENT_MEMORY handling problem (if the preceding call to is_normal_ram() didn't already cause problems). --- Robert Elliott, HPE Persistent Memory

4 years, 4 months

5
7
0 / 0

[PATCH v3 00/15] block, dax updates for 4.4

by Dan Williams

Changes since v2: [1] 1/ Include a fix to revoke dax-mappings at device teardown time 2/ Include a blkdev_issue_flush implementation for pmem 3/ New block device ioctls to set/query dax mode, make dax opt-in 4/ Collect reviewed-by's [1]: https://lists.01.org/pipermail/linux-nvdimm/2015-October/002538.html --- There were several topics developed during this cycle, some are ready and some are not. The items needing more review and testing are the pmem+dax updates with mm, ext4, and xfs dependencies. Topics like the dax locking reworks, dax get_user_pages, and write-protecting dax ptes after fsync/msync. Instead, this more conservative set represents the fs and mm independent updates to dax and pmem: 1/ Enable dax mappings for raw block devices 2/ Use blk_queue_{enter|exit} and the availability of 'struct page' to fix lifetime issues and races with unloading the pmem driver. 3/ Enable blkdev_issue_flush to fix legacy apps that may dirty pmem via dax mmap I/O. Although legacy environments should consider disabling dax for apps that don't expect it. These depend on the latest 'libnvdimm-for-next' branch from nvdimm.git and the 'for-4.4/integrity' branch from Jens' tree. All but the last three have been out for review previously, and I am looking to submit them towards the back half of the merge window. --- Dan Williams (15): pmem, dax: clean up clear_pmem() dax: increase granularity of dax_clear_blocks() operations block, dax: fix lifetime of in-kernel dax mappings with dax_map_atomic() libnvdimm, pmem: move request_queue allocation earlier in probe libnvdimm, pmem: fix size trim in pmem_direct_access() um: kill pfn_t kvm: rename pfn_t to kvm_pfn_t mm, dax, pmem: introduce pfn_t block: notify queue death confirmation dax, pmem: introduce zone_device_revoke() and devm_memunmap_pages() block: introduce bdev_file_inode() block: enable dax for raw block devices block, dax: make dax mappings opt-in by default dax: dirty extent notification pmem: blkdev_issue_flush support arch/arm/include/asm/kvm_mmu.h | 5 - arch/arm/kvm/mmu.c | 10 + arch/arm64/include/asm/kvm_mmu.h | 3 arch/mips/include/asm/kvm_host.h | 6 - arch/mips/kvm/emulate.c | 2 arch/mips/kvm/tlb.c | 14 +- arch/powerpc/include/asm/kvm_book3s.h | 4 - arch/powerpc/include/asm/kvm_ppc.h | 2 arch/powerpc/kvm/book3s.c | 6 - arch/powerpc/kvm/book3s_32_mmu_host.c | 2 arch/powerpc/kvm/book3s_64_mmu_host.c | 2 arch/powerpc/kvm/e500.h | 2 arch/powerpc/kvm/e500_mmu_host.c | 8 + arch/powerpc/kvm/trace_pr.h | 2 arch/powerpc/sysdev/axonram.c | 11 + arch/um/include/asm/page.h | 6 - arch/um/include/asm/pgtable-3level.h | 4 - arch/um/include/asm/pgtable.h | 2 arch/x86/include/asm/cacheflush.h | 4 + arch/x86/include/asm/pmem.h | 7 - arch/x86/kvm/iommu.c | 11 + arch/x86/kvm/mmu.c | 37 +++-- arch/x86/kvm/mmu_audit.c | 2 arch/x86/kvm/paging_tmpl.h | 6 - arch/x86/kvm/vmx.c | 2 arch/x86/kvm/x86.c | 2 block/blk-core.c | 13 +- block/blk-mq.c | 19 ++- block/blk.h | 13 -- block/ioctl.c | 42 ++++++ drivers/block/brd.c | 10 + drivers/nvdimm/pmem.c | 247 ++++++++++++++++++++++++++++----- drivers/s390/block/dcssblk.c | 13 +- fs/block_dev.c | 159 ++++++++++++++++++--- fs/dax.c | 242 ++++++++++++++++++++++---------- include/linux/blkdev.h | 41 +++++ include/linux/fs.h | 11 + include/linux/io.h | 17 -- include/linux/kvm_host.h | 37 +++-- include/linux/kvm_types.h | 2 include/linux/mm.h | 90 ++++++++++++ include/linux/pfn.h | 9 + include/uapi/linux/fs.h | 2 kernel/memremap.c | 98 +++++++++++++ virt/kvm/kvm_main.c | 47 +++--- 45 files changed, 949 insertions(+), 325 deletions(-)

4 years, 4 months

5
45
0 / 0

[PATCH] BTT: Change nd_btt_arena_is_valid() to verify UUID

by Toshi Kani

When user unbinds a BTT disk and binds again with a different sector size without wiping out the disk, a BTT disk is created with a wrong size. This is because the bind operation keeps the previous metadata, which leads nd_btt->lbasize inconsistent with internal_lbasize and external_lbasize in the arena. A reboot also reattaches the BTT from the previous metadata. Change nd_btt_arena_is_valid() to check if nd_btt->uuid matches with super->uuid when a new UUID is set for binding. This assures the bind operation writes the metadata with the values specified by user. Cc: Vishal Verma <vishal.l.verma(a)intel.com> Cc: Dan Williams <dan.j.williams(a)intel.com> Reported-by: Micah Parrish <micah.parrish(a)hpe.com> Signed-off-by: Toshi Kani <toshi.kani(a)hpe.com> --- drivers/nvdimm/btt_devs.c | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/drivers/nvdimm/btt_devs.c b/drivers/nvdimm/btt_devs.c index cb47751..176ea25 100644 --- a/drivers/nvdimm/btt_devs.c +++ b/drivers/nvdimm/btt_devs.c @@ -218,6 +218,8 @@ static bool uuid_is_null(u8 *uuid) * Check consistency of the btt info block with itself by validating * the checksum, and with the parent namespace by verifying the * parent_uuid contained in the info block with the one supplied in. + * When nd_btt->uuid is set for binding, verify if the metadata is + * stale. * * Returns: * false for an invalid info block, true for a valid one @@ -234,6 +236,10 @@ bool nd_btt_arena_is_valid(struct nd_btt *nd_btt, struct btt_sb *super) if (memcmp(super->parent_uuid, parent_uuid, 16) != 0) return false; + if (nd_btt->uuid) + if (memcmp(super->uuid, nd_btt->uuid, 16) != 0) + return false; + checksum = le64_to_cpu(super->checksum); super->checksum = 0; if (checksum != nd_sb_checksum((struct nd_gen_sb *) super))

4 years, 4 months

4
9
0 / 0

A blocksize problem about dax and ext4

by Cholerae Hu

Hi all, Recently I was doing experiment about persistent memory, so I followed the quick setup guide on https://nvdimm.wiki.kernel.org to config dax. But when I mounted /dev/pmem0 I got an error. The prompting message is: [root@localhost cholerae]# mount -o dax /dev/pmem0 /mnt/mem mount: wrong fs type, bad option, bad superblock on /dev/pmem0, missing codepage or helper program, or other error In some cases useful info is found in syslog - try dmesg | tail or so. [root@localhost cholerae]# dmesg | tail [ 27.357100] cfg80211: DFS Master region: FCC [ 27.357101] cfg80211: (start_freq - end_freq @ bandwidth), (max_antenna_gain, max_eirp), (dfs_cac_time) [ 27.357104] cfg80211: (2402000 KHz - 2482000 KHz @ 40000 KHz), (N/A, 2000 mBm), (N/A) [ 27.357107] cfg80211: (5170000 KHz - 5250000 KHz @ 80000 KHz, 160000 KHz AUTO), (N/A, 2300 mBm), (N/A) [ 27.357110] cfg80211: (5250000 KHz - 5330000 KHz @ 80000 KHz, 160000 KHz AUTO), (N/A, 2300 mBm), (0 s) [ 27.357112] cfg80211: (5735000 KHz - 5835000 KHz @ 80000 KHz), (N/A, 3000 mBm), (N/A) [ 27.357114] cfg80211: (57240000 KHz - 59400000 KHz @ 2160000 KHz), (N/A, 2800 mBm), (N/A) [ 27.357116] cfg80211: (59400000 KHz - 63720000 KHz @ 2160000 KHz), (N/A, 4400 mBm), (N/A) [ 27.357118] cfg80211: (63720000 KHz - 65880000 KHz @ 2160000 KHz), (N/A, 2800 mBm), (N/A) [ 81.779582] EXT4-fs (pmem0): error: unsupported blocksize for dax My kernel version is 4.2.8, distribution is fedora23. I can't find out the reason, can anyone give me a hand? Thanks.

4 years, 5 months

6
11
0 / 0

[PATCH v2 14/16] x86, nvdimm, kexec: Use walk_iomem_res_desc() for iomem search

by Toshi Kani

Change to call walk_iomem_res_desc() for searching resource entries with the following names: "ACPI Tables" "ACPI Non-volatile Storage" "Persistent Memory (legacy)" "Crash kernel" Note, the caller of walk_iomem_res() with "GART" is left unchanged because this entry may be initialized by out-of-tree drivers, which do not have 'desc' set to IORES_DESC_GART. Cc: Borislav Petkov <bp(a)alien8.de> Cc: Dan Williams <dan.j.williams(a)intel.com> Cc: Dave Young <dyoung(a)redhat.com> Cc: x86(a)kernel.org Cc: linux-nvdimm(a)lists.01.org Signed-off-by: Toshi Kani <toshi.kani(a)hpe.com> --- arch/x86/kernel/crash.c | 4 ++-- arch/x86/kernel/pmem.c | 4 ++-- drivers/nvdimm/e820.c | 2 +- kernel/kexec_file.c | 8 ++++---- 4 files changed, 9 insertions(+), 9 deletions(-) diff --git a/arch/x86/kernel/crash.c b/arch/x86/kernel/crash.c index 2c1910f..082373b 100644 --- a/arch/x86/kernel/crash.c +++ b/arch/x86/kernel/crash.c @@ -588,12 +588,12 @@ int crash_setup_memmap_entries(struct kimage *image, struct boot_params *params) /* Add ACPI tables */ cmd.type = E820_ACPI; flags = IORESOURCE_MEM | IORESOURCE_BUSY; - walk_iomem_res("ACPI Tables", flags, 0, -1, &cmd, + walk_iomem_res_desc(IORES_DESC_ACPI_TABLES, flags, 0, -1, &cmd, memmap_entry_callback); /* Add ACPI Non-volatile Storage */ cmd.type = E820_NVS; - walk_iomem_res("ACPI Non-volatile Storage", flags, 0, -1, &cmd, + walk_iomem_res_desc(IORES_DESC_ACPI_NV_STORAGE, flags, 0, -1, &cmd, memmap_entry_callback); /* Add crashk_low_res region */ diff --git a/arch/x86/kernel/pmem.c b/arch/x86/kernel/pmem.c index 14415af..92f7014 100644 --- a/arch/x86/kernel/pmem.c +++ b/arch/x86/kernel/pmem.c @@ -13,11 +13,11 @@ static int found(u64 start, u64 end, void *data) static __init int register_e820_pmem(void) { - char *pmem = "Persistent Memory (legacy)"; struct platform_device *pdev; int rc; - rc = walk_iomem_res(pmem, IORESOURCE_MEM, 0, -1, NULL, found); + rc = walk_iomem_res_desc(IORES_DESC_PERSISTENT_MEMORY_LEGACY, + IORESOURCE_MEM, 0, -1, NULL, found); if (rc <= 0) return 0; diff --git a/drivers/nvdimm/e820.c b/drivers/nvdimm/e820.c index b0045a5..95825b3 100644 --- a/drivers/nvdimm/e820.c +++ b/drivers/nvdimm/e820.c @@ -55,7 +55,7 @@ static int e820_pmem_probe(struct platform_device *pdev) for (p = iomem_resource.child; p ; p = p->sibling) { struct nd_region_desc ndr_desc; - if (strncmp(p->name, "Persistent Memory (legacy)", 26) != 0) + if (p->desc != IORES_DESC_PERSISTENT_MEMORY_LEGACY) continue; memset(&ndr_desc, 0, sizeof(ndr_desc)); diff --git a/kernel/kexec_file.c b/kernel/kexec_file.c index c245085..e2bd737 100644 --- a/kernel/kexec_file.c +++ b/kernel/kexec_file.c @@ -522,10 +522,10 @@ int kexec_add_buffer(struct kimage *image, char *buffer, unsigned long bufsz, /* Walk the RAM ranges and allocate a suitable range for the buffer */ if (image->type == KEXEC_TYPE_CRASH) - ret = walk_iomem_res("Crash kernel", - IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY, - crashk_res.start, crashk_res.end, kbuf, - locate_mem_hole_callback); + ret = walk_iomem_res_desc(IORES_DESC_CRASH_KERNEL, + IORESOURCE_SYSTEM_RAM | IORESOURCE_BUSY, + crashk_res.start, crashk_res.end, kbuf, + locate_mem_hole_callback); else ret = walk_system_ram_res(0, -1, kbuf, locate_mem_hole_callback);

4 years, 5 months

4
14
0 / 0

[PATCH 0/8] Support for transparent PUD pages

by Matthew Wilcox

From: Matthew Wilcox <willy(a)linux.intel.com> We have customer demand to use 1GB pages to map DAX files. Unlike the 2MB page support, the Linux MM does not currently support PUD pages, so I have attempted to add support for the necessary pieces for DAX huge PUD pages. Filesystem support is a bit sticky. I have not been able to persuade ext4 to give me more than 16MB of contiguous space, although it is aligned. XFS will give me 80MB short of 1GB, but it's not aligned. I'm in no hurry to get patches 7 & 8 merged until the block allocation problem is solved in those filesystems. This patch set is against something approximately current -mm. At this point, I would be most grateful for MM developers to give feedback on the first three patches. Review from X86 maintainers on patch 4 would also be welcome. I'd like to thank Ross Zwisler for his helpful review during development. I've done some light testing using a program to mmap a block device with DAX enabled, calling mincore() and examining /proc/smaps and /proc/pagemap. Matthew Wilcox (8): mm: Add optional support for PUD-sized transparent hugepages mincore: Add support for PUDs procfs: Add support for PUDs to smaps, clear_refs and pagemap x86: Add support for PUD-sized transparent hugepages dax: Support for transparent PUD pages block_dev: Support PUD DAX mappings xfs: Support for transparent PUD pages ext4: Transparent support for PUD-sized transparent huge pages arch/Kconfig | 3 + arch/x86/Kconfig | 1 + arch/x86/include/asm/paravirt.h | 11 ++ arch/x86/include/asm/paravirt_types.h | 2 + arch/x86/include/asm/pgtable.h | 95 ++++++++++++++ arch/x86/include/asm/pgtable_64.h | 13 ++ arch/x86/kernel/paravirt.c | 1 + arch/x86/mm/pgtable.c | 31 +++++ fs/block_dev.c | 7 + fs/dax.c | 239 +++++++++++++++++++++++++++++++--- fs/ext4/file.c | 37 ++++++ fs/proc/task_mmu.c | 109 ++++++++++++++++ fs/xfs/xfs_file.c | 33 +++++ fs/xfs/xfs_trace.h | 1 + include/asm-generic/pgtable.h | 62 ++++++++- include/asm-generic/tlb.h | 14 ++ include/linux/dax.h | 21 +++ include/linux/huge_mm.h | 52 +++++++- include/linux/mm.h | 30 +++++ include/linux/mmu_notifier.h | 13 ++ mm/huge_memory.c | 151 +++++++++++++++++++++ mm/memory.c | 67 ++++++++++ mm/mincore.c | 13 ++ mm/pagewalk.c | 19 ++- mm/pgtable-generic.c | 14 ++ 25 files changed, 1016 insertions(+), 23 deletions(-) -- 2.6.2

4 years, 5 months

4
17
0 / 0

[PATCH] ext2, ext4: include filesystem block size in error messages

by Robert Elliott

Print the problematic value in messages about the filesystem block size. Normalize all of the blocksize messages that use "blocksize" to use "filesystem block size". This helps distinguish this block size from the underlying block device's logical block size (i.e., sector size) and physical block size. Example old messages: EXT2-fs (pmem0): unable to set blocksize EXT4-fs (pmem0): error: unsupported blocksize for dax EXT4-fs (pmem0): unsupported blocksize for fs encryption EXT2-fs (pmem0): bad blocksize %d Example new message: EXT4-fs (pmem0): error: unsupported filesystem block size 2048 for dax Signed-off-by: Robert Elliott <elliott(a)hpe.com> --- fs/ext2/super.c | 17 +++++++++++------ fs/ext4/super.c | 33 ++++++++++++++++++++------------- 2 files changed, 31 insertions(+), 19 deletions(-) diff --git a/fs/ext2/super.c b/fs/ext2/super.c index 748d35a..1186a5b 100644 --- a/fs/ext2/super.c +++ b/fs/ext2/super.c @@ -31,6 +31,7 @@ #include <linux/mount.h> #include <linux/log2.h> #include <linux/quotaops.h> +#include <linux/stringify.h> #include <asm/uaccess.h> #include "ext2.h" #include "xattr.h" @@ -822,7 +823,9 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent) */ blocksize = sb_min_blocksize(sb, BLOCK_SIZE); if (!blocksize) { - ext2_msg(sb, KERN_ERR, "error: unable to set blocksize"); + ext2_msg(sb, KERN_ERR, + "error: unable to set filesystem block size " + __stringify(BLOCK_SIZE)); goto failed_sbi; } @@ -921,7 +924,8 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent) if (sbi->s_mount_opt & EXT2_MOUNT_DAX) { if (blocksize != PAGE_SIZE) { ext2_msg(sb, KERN_ERR, - "error: unsupported blocksize for dax"); + "error: unsupported filesystem block size %d for dax", + blocksize); goto failed_mount; } if (!sb->s_bdev->bd_disk->fops->direct_access) { @@ -937,7 +941,7 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent) if (!sb_set_blocksize(sb, blocksize)) { ext2_msg(sb, KERN_ERR, - "error: bad blocksize %d", blocksize); + "error: bad filesystem block size %d", blocksize); goto failed_sbi; } @@ -1007,14 +1011,15 @@ static int ext2_fill_super(struct super_block *sb, void *data, int silent) if (sb->s_blocksize != bh->b_size) { if (!silent) - ext2_msg(sb, KERN_ERR, "error: unsupported blocksize"); + ext2_msg(sb, KERN_ERR, + "error: unsupported filesystem block size %lu", + sb->s_blocksize); goto failed_mount; } if (sb->s_blocksize != sbi->s_frag_size) { ext2_msg(sb, KERN_ERR, - "error: fragsize %lu != blocksize %lu" - "(not supported yet)", + "error: fragsize %lu != filesystem block size %lu (not supported yet)", sbi->s_frag_size, sb->s_blocksize); goto failed_mount; } diff --git a/fs/ext4/super.c b/fs/ext4/super.c index c9ab67d..9e1c049 100644 --- a/fs/ext4/super.c +++ b/fs/ext4/super.c @@ -42,6 +42,7 @@ #include <linux/kthread.h> #include <linux/freezer.h> +#include <linux/stringify.h> #include "ext4.h" #include "ext4_extents.h" /* Needed for trace points definition */ @@ -1750,8 +1751,9 @@ static int parse_options(char *options, struct super_block *sb, BLOCK_SIZE << le32_to_cpu(sbi->s_es->s_log_block_size); if (blocksize < PAGE_CACHE_SIZE) { - ext4_msg(sb, KERN_ERR, "can't mount with " - "dioread_nolock if block size != PAGE_SIZE"); + ext4_msg(sb, KERN_ERR, + "can't mount with dioread_nolock if filesystem block size %d != PAGE_SIZE", + blocksize); return 0; } } @@ -3147,7 +3149,9 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) ret = -EINVAL; blocksize = sb_min_blocksize(sb, EXT4_MIN_BLOCK_SIZE); if (!blocksize) { - ext4_msg(sb, KERN_ERR, "unable to set blocksize"); + ext4_msg(sb, KERN_ERR, + "unable to set filesystem block size " + __stringify(EXT4_MIN_BLOCK_SIZE)); goto out_fail; } @@ -3367,14 +3371,15 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) if (blocksize < EXT4_MIN_BLOCK_SIZE || blocksize > EXT4_MAX_BLOCK_SIZE) { ext4_msg(sb, KERN_ERR, - "Unsupported filesystem blocksize %d", blocksize); + "Unsupported filesystem block size %d", blocksize); goto failed_mount; } if (sbi->s_mount_opt & EXT4_MOUNT_DAX) { if (blocksize != PAGE_SIZE) { ext4_msg(sb, KERN_ERR, - "error: unsupported blocksize for dax"); + "error: unsupported filesystem block size %d for dax", + blocksize); goto failed_mount; } if (!sb->s_bdev->bd_disk->fops->direct_access) { @@ -3393,7 +3398,7 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) if (sb->s_blocksize != blocksize) { /* Validate the filesystem blocksize */ if (!sb_set_blocksize(sb, blocksize)) { - ext4_msg(sb, KERN_ERR, "bad block size %d", + ext4_msg(sb, KERN_ERR, "bad filesystem block size %d", blocksize); goto failed_mount; } @@ -3495,8 +3500,8 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) if (has_bigalloc) { if (clustersize < blocksize) { ext4_msg(sb, KERN_ERR, - "cluster size (%d) smaller than " - "block size (%d)", clustersize, blocksize); + "cluster size (%d) smaller than filesystem block size (%d)", + clustersize, blocksize); goto failed_mount; } sbi->s_cluster_bits = le32_to_cpu(es->s_log_cluster_size) - @@ -3519,9 +3524,9 @@ static int ext4_fill_super(struct super_block *sb, void *data, int silent) } } else { if (clustersize != blocksize) { - ext4_warning(sb, "fragment/cluster size (%d) != " - "block size (%d)", clustersize, - blocksize); + ext4_warning(sb, + "fragment/cluster size (%d) != filesystem block size (%d)", + clustersize, blocksize); clustersize = blocksize; } if (sbi->s_blocks_per_group > blocksize * 8) { @@ -3769,7 +3774,8 @@ no_journal: if ((DUMMY_ENCRYPTION_ENABLED(sbi) || ext4_has_feature_encrypt(sb)) && (blocksize != PAGE_CACHE_SIZE)) { ext4_msg(sb, KERN_ERR, - "Unsupported blocksize for fs encryption"); + "Unsupported filesystem block size %d for fs encryption", + blocksize); goto failed_mount_wq; } @@ -4112,7 +4118,8 @@ static journal_t *ext4_get_dev_journal(struct super_block *sb, hblock = bdev_logical_block_size(bdev); if (blocksize < hblock) { ext4_msg(sb, KERN_ERR, - "blocksize too small for journal device"); + "filesystem block size %d too small for journal device", + blocksize); goto out_bdev; } -- 2.4.3

4 years, 5 months

2
1
0 / 0

2020

2019

2018

2017

2016

2015

2014

Linux-nvdimm December 2015