The madvise policy for transparent huge pages is meant to avoid unwanted allocations of transparent huge pages. It allows a policy of disabling the extra memory pressure and effort to arrange for a huge page when it is not needed. DAX by definition never incurs this overhead since it is statically allocated. The policy choice makes even less sense for device-dax which tries to guarantee a given tlb-fault size. Specifically, the following setting: echo never > /sys/kernel/mm/transparent_hugepage/enabled ...violates that guarantee and silently disables all device-dax instances with a 2M or 1G alignment. So, let's avoid that non-obvious side effect by force enabling thp for dax mappings in all cases. It is worth noting that the reason this uses vma_is_dax(), and the resulting header include changes, is that previous attempts to add a VM_DAX flag were NAKd. Cc: Jan Kara <jack(a)suse.cz&gt; Cc: Christoph Hellwig <hch(a)lst.de&gt; Cc: Andrew Morton <akpm(a)linux-foundation.org&gt; Cc: Ross Zwisler <ross.zwisler(a)linux.intel.com&gt; Cc: "Kirill A. Shutemov" <kirill.shutemov(a)linux.intel.com&gt; Signed-off-by: Dan Williams <dan.j.williams(a)intel.com&gt; --- include/linux/dax.h | 5 ----- include/linux/fs.h | 6 ++++++ include/linux/huge_mm.h | 5 +++++ 3 files changed, 11 insertions(+), 5 deletions(-) diff --git a/include/linux/dax.h b/include/linux/dax.h index 1f6b6072af64..cbaf3d53d66b 100644 --- a/include/linux/dax.h +++ b/include/linux/dax.h @@ -151,11 +151,6 @@ static inline unsigned int dax_radix_order(void *entry) #endif int dax_pfn_mkwrite(struct vm_fault *vmf); -static inline bool vma_is_dax(struct vm_area_struct *vma) -{ - return vma->vm_file && IS_DAX(vma->vm_file->f_mapping->host); -} - static inline bool dax_mapping(struct address_space *mapping) { return mapping->host && IS_DAX(mapping->host); diff --git a/include/linux/fs.h b/include/linux/fs.h index 803e5a9b2654..5916ab3a12d5 100644 --- a/include/linux/fs.h +++ b/include/linux/fs.h @@ -18,6 +18,7 @@ #include <linux/bug.h> #include <linux/mutex.h> #include <linux/rwsem.h> +#include <linux/mm_types.h> #include <linux/capability.h> #include <linux/semaphore.h> #include <linux/fiemap.h> @@ -3042,6 +3043,11 @@ static inline bool io_is_direct(struct file *filp) return (filp->f_flags & O_DIRECT) || IS_DAX(filp->f_mapping->host); } +static inline bool vma_is_dax(struct vm_area_struct *vma) +{ + return vma->vm_file && IS_DAX(vma->vm_file->f_mapping->host); +} + static inline int iocb_flags(struct file *file) { int res = 0; diff --git a/include/linux/huge_mm.h b/include/linux/huge_mm.h index c4706e2c3358..901ed3767d1b 100644 --- a/include/linux/huge_mm.h +++ b/include/linux/huge_mm.h @@ -1,6 +1,8 @@ #ifndef _LINUX_HUGE_MM_H #define _LINUX_HUGE_MM_H +#include <linux/fs.h> + extern int do_huge_pmd_anonymous_page(struct vm_fault *vmf); extern int copy_huge_pmd(struct mm_struct *dst_mm, struct mm_struct *src_mm, pmd_t *dst_pmd, pmd_t *src_pmd, unsigned long addr, @@ -92,6 +94,9 @@ static inline bool transparent_hugepage_enabled(struct vm_area_struct *vma) if (transparent_hugepage_flags & (1 << TRANSPARENT_HUGEPAGE_FLAG)) return true; + if (vma_is_dax(vma)) + return true; + if (transparent_hugepage_flags & (1 << TRANSPARENT_HUGEPAGE_REQ_MADV_FLAG)) /* check vma flags */;

On Sat, Jun 10, 2017 at 02:49:31PM -0700, Dan Williams wrote: I don't think that these are equivalent. Here is the logic from the macro, with whitespace added so things are more readable: #define transparent_hugepage_enabled(__vma) ( ( transparent_hugepage_flags & (1<<TRANSPARENT_HUGEPAGE_FLAG) || ( transparent_hugepage_flags & (1<<TRANSPARENT_HUGEPAGE_REQ_MADV_FLAG) && ((__vma)->vm_flags & VM_HUGEPAGE) ) ) && !((__vma)->vm_flags & VM_NOHUGEPAGE) && !is_vma_temporary_stack(__vma) ) So, if the VM_NOHUGEPAGE flag is set or if the vma is for a temporary stack, we always bail. Also, we only care about the VM_HUGEPAGE flag in the presence of TRANSPARENT_HUGEPAGE_REQ_MADV_FLAG. I think this static inline is logically equivalent (untested): static inline bool transparent_hugepage_enabled(struct vm_area_struct *vma) { if ((vma->vm_flags & VM_NOHUGEPAGE) || is_vma_temporary_stack(vma)) return false; if (transparent_hugepage_flags & (1 << TRANSPARENT_HUGEPAGE_FLAG)) return true; if ((transparent_hugepage_flags & (1 << TRANSPARENT_HUGEPAGE_REQ_MADV_FLAG)) && vma->vm_flags & VM_HUGEPAGE) return true; return false; } The ordering of the checks is different, but we're not using && or || to short-circuit checks with side effects, so I think it is more readable and should be fine.