[Qemu-devel] [PATCH qemu 0/2] exec, spapr_pci: Advertise huge IOMMU pages

[Qemu-devel] [PATCH qemu 0/2] exec, spapr_pci: Advertise huge IOMMU pages

[Alexey Kardashevskiy]

These are to enable 16mb pages for IOMMU which should reduce
the amount of memory used for TCE tables in 256 times (compared
to 64k pages case). Please comment. Thanks!

Alexey Kardashevskiy (2):
  exec, kvm, target-ppc: Move getrampagesize() to common code
  spapr_pci: Advertise 16M IOMMU pages when available

 include/exec/ram_addr.h   |   1 +
 include/qemu/mmap-alloc.h |   2 +
 exec.c                    |  82 ++++++++++++++++++++++++++++++++++++
 hw/ppc/spapr_pci.c        |   3 ++
 target-ppc/kvm.c          | 105 ++--------------------------------------------
 util/mmap-alloc.c         |  25 +++++++++++
 6 files changed, 116 insertions(+), 102 deletions(-)

-- 
2.11.0

[Qemu-devel] [PATCH qemu 1/2] exec, kvm, target-ppc: Move getrampagesize() to common code

[Alexey Kardashevskiy]

getrampagesize() returns the largest supported page size and mainly
used to know if huge pages are enabled.

However is implemented in target-ppc/kvm.c and not available
in TCG or other architectures.

This renames and moves gethugepagesize() to mmap-alloc.c where
fd-based analog of it is already implemented. This renames and moves
getrampagesize() to exec.c as it seems to be the common place for
helpers like this.

This first user for it is going to be a spapr-pci-host-bridge which
needs to know the largest RAM page size so the guest could try
using bigger IOMMU pages to save memory.

Signed-off-by: Alexey Kardashevskiy <aik@ozlabs.ru>
---
 include/exec/ram_addr.h   |   1 +
 include/qemu/mmap-alloc.h |   2 +
 exec.c                    |  82 ++++++++++++++++++++++++++++++++++++
 target-ppc/kvm.c          | 105 ++--------------------------------------------
 util/mmap-alloc.c         |  25 +++++++++++
 5 files changed, 113 insertions(+), 102 deletions(-)

diff --git a/include/exec/ram_addr.h b/include/exec/ram_addr.h
index 54d7108a9e..3935cbcfcd 100644
--- a/include/exec/ram_addr.h
+++ b/include/exec/ram_addr.h
@@ -91,6 +91,7 @@ typedef struct RAMList {
 } RAMList;
 extern RAMList ram_list;
 
+long qemu_getrampagesize(void);
 ram_addr_t last_ram_offset(void);
 void qemu_mutex_lock_ramlist(void);
 void qemu_mutex_unlock_ramlist(void);
diff --git a/include/qemu/mmap-alloc.h b/include/qemu/mmap-alloc.h
index 933c024ac5..50385e3f81 100644
--- a/include/qemu/mmap-alloc.h
+++ b/include/qemu/mmap-alloc.h
@@ -5,6 +5,8 @@
 
 size_t qemu_fd_getpagesize(int fd);
 
+size_t qemu_mempath_getpagesize(const char *mem_path);
+
 void *qemu_ram_mmap(int fd, size_t size, size_t align, bool shared);
 
 void qemu_ram_munmap(void *ptr, size_t size);
diff --git a/exec.c b/exec.c
index 08c558eecf..d73b477a70 100644
--- a/exec.c
+++ b/exec.c
@@ -32,6 +32,7 @@
 #endif
 #include "sysemu/kvm.h"
 #include "sysemu/sysemu.h"
+#include "sysemu/numa.h"
 #include "qemu/timer.h"
 #include "qemu/config-file.h"
 #include "qemu/error-report.h"
@@ -1218,6 +1219,87 @@ void qemu_mutex_unlock_ramlist(void)
 }
 
 #ifdef __linux__
+/*
+ * FIXME TOCTTOU: this iterates over memory backends' mem-path, which
+ * may or may not name the same files / on the same filesystem now as
+ * when we actually open and map them.  Iterate over the file
+ * descriptors instead, and use qemu_fd_getpagesize().
+ */
+static int find_max_supported_pagesize(Object *obj, void *opaque)
+{
+    char *mem_path;
+    long *hpsize_min = opaque;
+
+    if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) {
+        mem_path = object_property_get_str(obj, "mem-path", NULL);
+        if (mem_path) {
+            long hpsize = qemu_mempath_getpagesize(mem_path);
+            if (hpsize < *hpsize_min) {
+                *hpsize_min = hpsize;
+            }
+        } else {
+            *hpsize_min = getpagesize();
+        }
+    }
+
+    return 0;
+}
+
+long qemu_getrampagesize(void)
+{
+    long hpsize = LONG_MAX;
+    long mainrampagesize;
+    Object *memdev_root;
+
+    if (mem_path) {
+        mainrampagesize = qemu_mempath_getpagesize(mem_path);
+    } else {
+        mainrampagesize = getpagesize();
+    }
+
+    /* it's possible we have memory-backend objects with
+     * hugepage-backed RAM. these may get mapped into system
+     * address space via -numa parameters or memory hotplug
+     * hooks. we want to take these into account, but we
+     * also want to make sure these supported hugepage
+     * sizes are applicable across the entire range of memory
+     * we may boot from, so we take the min across all
+     * backends, and assume normal pages in cases where a
+     * backend isn't backed by hugepages.
+     */
+    memdev_root = object_resolve_path("/objects", NULL);
+    if (memdev_root) {
+        object_child_foreach(memdev_root, find_max_supported_pagesize, &hpsize);
+    }
+    if (hpsize == LONG_MAX) {
+        /* No additional memory regions found ==> Report main RAM page size */
+        return mainrampagesize;
+    }
+
+    /* If NUMA is disabled or the NUMA nodes are not backed with a
+     * memory-backend, then there is at least one node using "normal" RAM,
+     * so if its page size is smaller we have got to report that size instead.
+     */
+    if (hpsize > mainrampagesize &&
+        (nb_numa_nodes == 0 || numa_info[0].node_memdev == NULL)) {
+        static bool warned;
+        if (!warned) {
+            error_report("Huge page support disabled (n/a for main memory).");
+            warned = true;
+        }
+        return mainrampagesize;
+    }
+
+    return hpsize;
+}
+#else
+long qemu_getrampagesize(void)
+{
+    return getpagesize();
+}
+#endif
+
+#ifdef __linux__
 static int64_t get_file_size(int fd)
 {
     int64_t size = lseek(fd, 0, SEEK_END);
diff --git a/target-ppc/kvm.c b/target-ppc/kvm.c
index 6e91a4d8bb..e0abffa8ad 100644
--- a/target-ppc/kvm.c
+++ b/target-ppc/kvm.c
@@ -42,6 +42,7 @@
 #include "trace.h"
 #include "exec/gdbstub.h"
 #include "exec/memattrs.h"
+#include "exec/ram_addr.h"
 #include "sysemu/hostmem.h"
 #include "qemu/cutils.h"
 #if defined(TARGET_PPC64)
@@ -325,106 +326,6 @@ static void kvm_get_smmu_info(PowerPCCPU *cpu, struct kvm_ppc_smmu_info *info)
     kvm_get_fallback_smmu_info(cpu, info);
 }
 
-static long gethugepagesize(const char *mem_path)
-{
-    struct statfs fs;
-    int ret;
-
-    do {
-        ret = statfs(mem_path, &fs);
-    } while (ret != 0 && errno == EINTR);
-
-    if (ret != 0) {
-        fprintf(stderr, "Couldn't statfs() memory path: %s\n",
-                strerror(errno));
-        exit(1);
-    }
-
-#define HUGETLBFS_MAGIC       0x958458f6
-
-    if (fs.f_type != HUGETLBFS_MAGIC) {
-        /* Explicit mempath, but it's ordinary pages */
-        return getpagesize();
-    }
-
-    /* It's hugepage, return the huge page size */
-    return fs.f_bsize;
-}
-
-/*
- * FIXME TOCTTOU: this iterates over memory backends' mem-path, which
- * may or may not name the same files / on the same filesystem now as
- * when we actually open and map them.  Iterate over the file
- * descriptors instead, and use qemu_fd_getpagesize().
- */
-static int find_max_supported_pagesize(Object *obj, void *opaque)
-{
-    char *mem_path;
-    long *hpsize_min = opaque;
-
-    if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) {
-        mem_path = object_property_get_str(obj, "mem-path", NULL);
-        if (mem_path) {
-            long hpsize = gethugepagesize(mem_path);
-            if (hpsize < *hpsize_min) {
-                *hpsize_min = hpsize;
-            }
-        } else {
-            *hpsize_min = getpagesize();
-        }
-    }
-
-    return 0;
-}
-
-static long getrampagesize(void)
-{
-    long hpsize = LONG_MAX;
-    long mainrampagesize;
-    Object *memdev_root;
-
-    if (mem_path) {
-        mainrampagesize = gethugepagesize(mem_path);
-    } else {
-        mainrampagesize = getpagesize();
-    }
-
-    /* it's possible we have memory-backend objects with
-     * hugepage-backed RAM. these may get mapped into system
-     * address space via -numa parameters or memory hotplug
-     * hooks. we want to take these into account, but we
-     * also want to make sure these supported hugepage
-     * sizes are applicable across the entire range of memory
-     * we may boot from, so we take the min across all
-     * backends, and assume normal pages in cases where a
-     * backend isn't backed by hugepages.
-     */
-    memdev_root = object_resolve_path("/objects", NULL);
-    if (memdev_root) {
-        object_child_foreach(memdev_root, find_max_supported_pagesize, &hpsize);
-    }
-    if (hpsize == LONG_MAX) {
-        /* No additional memory regions found ==> Report main RAM page size */
-        return mainrampagesize;
-    }
-
-    /* If NUMA is disabled or the NUMA nodes are not backed with a
-     * memory-backend, then there is at least one node using "normal" RAM,
-     * so if its page size is smaller we have got to report that size instead.
-     */
-    if (hpsize > mainrampagesize &&
-        (nb_numa_nodes == 0 || numa_info[0].node_memdev == NULL)) {
-        static bool warned;
-        if (!warned) {
-            error_report("Huge page support disabled (n/a for main memory).");
-            warned = true;
-        }
-        return mainrampagesize;
-    }
-
-    return hpsize;
-}
-
 static bool kvm_valid_page_size(uint32_t flags, long rampgsize, uint32_t shift)
 {
     if (!(flags & KVM_PPC_PAGE_SIZES_REAL)) {
@@ -454,7 +355,7 @@ static void kvm_fixup_page_sizes(PowerPCCPU *cpu)
         has_smmu_info = true;
     }
 
-    rampagesize = getrampagesize();
+    rampagesize = qemu_getrampagesize();
 
     /* Convert to QEMU form */
     memset(&env->sps, 0, sizeof(env->sps));
@@ -2177,7 +2078,7 @@ uint64_t kvmppc_rma_size(uint64_t current_size, unsigned int hash_shift)
     /* Find the largest hardware supported page size that's less than
      * or equal to the (logical) backing page size of guest RAM */
     kvm_get_smmu_info(POWERPC_CPU(first_cpu), &info);
-    rampagesize = getrampagesize();
+    rampagesize = qemu_getrampagesize();
     best_page_shift = 0;
 
     for (i = 0; i < KVM_PPC_PAGE_SIZES_MAX_SZ; i++) {
diff --git a/util/mmap-alloc.c b/util/mmap-alloc.c
index 5a85aa3c89..564c79109c 100644
--- a/util/mmap-alloc.c
+++ b/util/mmap-alloc.c
@@ -39,6 +39,31 @@ size_t qemu_fd_getpagesize(int fd)
     return getpagesize();
 }
 
+size_t qemu_mempath_getpagesize(const char *mem_path)
+{
+#ifdef CONFIG_LINUX
+    struct statfs fs;
+    int ret;
+
+    do {
+        ret = statfs(mem_path, &fs);
+    } while (ret != 0 && errno == EINTR);
+
+    if (ret != 0) {
+        fprintf(stderr, "Couldn't statfs() memory path: %s\n",
+                strerror(errno));
+        exit(1);
+    }
+
+    if (fs.f_type == HUGETLBFS_MAGIC) {
+        /* It's hugepage, return the huge page size */
+        return fs.f_bsize;
+    }
+#endif
+
+    return getpagesize();
+}
+
 void *qemu_ram_mmap(int fd, size_t size, size_t align, bool shared)
 {
     /*
-- 
2.11.0

Re: [Qemu-devel] [PATCH qemu 1/2] exec, kvm, target-ppc: Move getrampagesize() to common code

[David Gibson]

[-- Attachment #1: Type: text/plain, Size: 11484 bytes --]

On Thu, Dec 22, 2016 at 04:22:11PM +1100, Alexey Kardashevskiy wrote:
> getrampagesize() returns the largest supported page size and mainly
> used to know if huge pages are enabled.
> 
> However is implemented in target-ppc/kvm.c and not available
> in TCG or other architectures.
> 
> This renames and moves gethugepagesize() to mmap-alloc.c where
> fd-based analog of it is already implemented. This renames and moves
> getrampagesize() to exec.c as it seems to be the common place for
> helpers like this.
> 
> This first user for it is going to be a spapr-pci-host-bridge which
> needs to know the largest RAM page size so the guest could try
> using bigger IOMMU pages to save memory.
> 
> Signed-off-by: Alexey Kardashevskiy <aik@ozlabs.ru>

Reviewed-by: David Gibson <david@gibson.dropbear.id.au>

Seems sensible to me, but I'm not comfortable merging this via my tree
since it touches such core code.  Probably should go via Paolo.

> ---
>  include/exec/ram_addr.h   |   1 +
>  include/qemu/mmap-alloc.h |   2 +
>  exec.c                    |  82 ++++++++++++++++++++++++++++++++++++
>  target-ppc/kvm.c          | 105 ++--------------------------------------------
>  util/mmap-alloc.c         |  25 +++++++++++
>  5 files changed, 113 insertions(+), 102 deletions(-)
> 
> diff --git a/include/exec/ram_addr.h b/include/exec/ram_addr.h
> index 54d7108a9e..3935cbcfcd 100644
> --- a/include/exec/ram_addr.h
> +++ b/include/exec/ram_addr.h
> @@ -91,6 +91,7 @@ typedef struct RAMList {
>  } RAMList;
>  extern RAMList ram_list;
>  
> +long qemu_getrampagesize(void);
>  ram_addr_t last_ram_offset(void);
>  void qemu_mutex_lock_ramlist(void);
>  void qemu_mutex_unlock_ramlist(void);
> diff --git a/include/qemu/mmap-alloc.h b/include/qemu/mmap-alloc.h
> index 933c024ac5..50385e3f81 100644
> --- a/include/qemu/mmap-alloc.h
> +++ b/include/qemu/mmap-alloc.h
> @@ -5,6 +5,8 @@
>  
>  size_t qemu_fd_getpagesize(int fd);
>  
> +size_t qemu_mempath_getpagesize(const char *mem_path);
> +
>  void *qemu_ram_mmap(int fd, size_t size, size_t align, bool shared);
>  
>  void qemu_ram_munmap(void *ptr, size_t size);
> diff --git a/exec.c b/exec.c
> index 08c558eecf..d73b477a70 100644
> --- a/exec.c
> +++ b/exec.c
> @@ -32,6 +32,7 @@
>  #endif
>  #include "sysemu/kvm.h"
>  #include "sysemu/sysemu.h"
> +#include "sysemu/numa.h"
>  #include "qemu/timer.h"
>  #include "qemu/config-file.h"
>  #include "qemu/error-report.h"
> @@ -1218,6 +1219,87 @@ void qemu_mutex_unlock_ramlist(void)
>  }
>  
>  #ifdef __linux__
> +/*
> + * FIXME TOCTTOU: this iterates over memory backends' mem-path, which
> + * may or may not name the same files / on the same filesystem now as
> + * when we actually open and map them.  Iterate over the file
> + * descriptors instead, and use qemu_fd_getpagesize().
> + */
> +static int find_max_supported_pagesize(Object *obj, void *opaque)
> +{
> +    char *mem_path;
> +    long *hpsize_min = opaque;
> +
> +    if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) {
> +        mem_path = object_property_get_str(obj, "mem-path", NULL);
> +        if (mem_path) {
> +            long hpsize = qemu_mempath_getpagesize(mem_path);
> +            if (hpsize < *hpsize_min) {
> +                *hpsize_min = hpsize;
> +            }
> +        } else {
> +            *hpsize_min = getpagesize();
> +        }
> +    }
> +
> +    return 0;
> +}
> +
> +long qemu_getrampagesize(void)
> +{
> +    long hpsize = LONG_MAX;
> +    long mainrampagesize;
> +    Object *memdev_root;
> +
> +    if (mem_path) {
> +        mainrampagesize = qemu_mempath_getpagesize(mem_path);
> +    } else {
> +        mainrampagesize = getpagesize();
> +    }
> +
> +    /* it's possible we have memory-backend objects with
> +     * hugepage-backed RAM. these may get mapped into system
> +     * address space via -numa parameters or memory hotplug
> +     * hooks. we want to take these into account, but we
> +     * also want to make sure these supported hugepage
> +     * sizes are applicable across the entire range of memory
> +     * we may boot from, so we take the min across all
> +     * backends, and assume normal pages in cases where a
> +     * backend isn't backed by hugepages.
> +     */
> +    memdev_root = object_resolve_path("/objects", NULL);
> +    if (memdev_root) {
> +        object_child_foreach(memdev_root, find_max_supported_pagesize, &hpsize);
> +    }
> +    if (hpsize == LONG_MAX) {
> +        /* No additional memory regions found ==> Report main RAM page size */
> +        return mainrampagesize;
> +    }
> +
> +    /* If NUMA is disabled or the NUMA nodes are not backed with a
> +     * memory-backend, then there is at least one node using "normal" RAM,
> +     * so if its page size is smaller we have got to report that size instead.
> +     */
> +    if (hpsize > mainrampagesize &&
> +        (nb_numa_nodes == 0 || numa_info[0].node_memdev == NULL)) {
> +        static bool warned;
> +        if (!warned) {
> +            error_report("Huge page support disabled (n/a for main memory).");
> +            warned = true;
> +        }
> +        return mainrampagesize;
> +    }
> +
> +    return hpsize;
> +}
> +#else
> +long qemu_getrampagesize(void)
> +{
> +    return getpagesize();
> +}
> +#endif
> +
> +#ifdef __linux__
>  static int64_t get_file_size(int fd)
>  {
>      int64_t size = lseek(fd, 0, SEEK_END);
> diff --git a/target-ppc/kvm.c b/target-ppc/kvm.c
> index 6e91a4d8bb..e0abffa8ad 100644
> --- a/target-ppc/kvm.c
> +++ b/target-ppc/kvm.c
> @@ -42,6 +42,7 @@
>  #include "trace.h"
>  #include "exec/gdbstub.h"
>  #include "exec/memattrs.h"
> +#include "exec/ram_addr.h"
>  #include "sysemu/hostmem.h"
>  #include "qemu/cutils.h"
>  #if defined(TARGET_PPC64)
> @@ -325,106 +326,6 @@ static void kvm_get_smmu_info(PowerPCCPU *cpu, struct kvm_ppc_smmu_info *info)
>      kvm_get_fallback_smmu_info(cpu, info);
>  }
>  
> -static long gethugepagesize(const char *mem_path)
> -{
> -    struct statfs fs;
> -    int ret;
> -
> -    do {
> -        ret = statfs(mem_path, &fs);
> -    } while (ret != 0 && errno == EINTR);
> -
> -    if (ret != 0) {
> -        fprintf(stderr, "Couldn't statfs() memory path: %s\n",
> -                strerror(errno));
> -        exit(1);
> -    }
> -
> -#define HUGETLBFS_MAGIC       0x958458f6
> -
> -    if (fs.f_type != HUGETLBFS_MAGIC) {
> -        /* Explicit mempath, but it's ordinary pages */
> -        return getpagesize();
> -    }
> -
> -    /* It's hugepage, return the huge page size */
> -    return fs.f_bsize;
> -}
> -
> -/*
> - * FIXME TOCTTOU: this iterates over memory backends' mem-path, which
> - * may or may not name the same files / on the same filesystem now as
> - * when we actually open and map them.  Iterate over the file
> - * descriptors instead, and use qemu_fd_getpagesize().
> - */
> -static int find_max_supported_pagesize(Object *obj, void *opaque)
> -{
> -    char *mem_path;
> -    long *hpsize_min = opaque;
> -
> -    if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) {
> -        mem_path = object_property_get_str(obj, "mem-path", NULL);
> -        if (mem_path) {
> -            long hpsize = gethugepagesize(mem_path);
> -            if (hpsize < *hpsize_min) {
> -                *hpsize_min = hpsize;
> -            }
> -        } else {
> -            *hpsize_min = getpagesize();
> -        }
> -    }
> -
> -    return 0;
> -}
> -
> -static long getrampagesize(void)
> -{
> -    long hpsize = LONG_MAX;
> -    long mainrampagesize;
> -    Object *memdev_root;
> -
> -    if (mem_path) {
> -        mainrampagesize = gethugepagesize(mem_path);
> -    } else {
> -        mainrampagesize = getpagesize();
> -    }
> -
> -    /* it's possible we have memory-backend objects with
> -     * hugepage-backed RAM. these may get mapped into system
> -     * address space via -numa parameters or memory hotplug
> -     * hooks. we want to take these into account, but we
> -     * also want to make sure these supported hugepage
> -     * sizes are applicable across the entire range of memory
> -     * we may boot from, so we take the min across all
> -     * backends, and assume normal pages in cases where a
> -     * backend isn't backed by hugepages.
> -     */
> -    memdev_root = object_resolve_path("/objects", NULL);
> -    if (memdev_root) {
> -        object_child_foreach(memdev_root, find_max_supported_pagesize, &hpsize);
> -    }
> -    if (hpsize == LONG_MAX) {
> -        /* No additional memory regions found ==> Report main RAM page size */
> -        return mainrampagesize;
> -    }
> -
> -    /* If NUMA is disabled or the NUMA nodes are not backed with a
> -     * memory-backend, then there is at least one node using "normal" RAM,
> -     * so if its page size is smaller we have got to report that size instead.
> -     */
> -    if (hpsize > mainrampagesize &&
> -        (nb_numa_nodes == 0 || numa_info[0].node_memdev == NULL)) {
> -        static bool warned;
> -        if (!warned) {
> -            error_report("Huge page support disabled (n/a for main memory).");
> -            warned = true;
> -        }
> -        return mainrampagesize;
> -    }
> -
> -    return hpsize;
> -}
> -
>  static bool kvm_valid_page_size(uint32_t flags, long rampgsize, uint32_t shift)
>  {
>      if (!(flags & KVM_PPC_PAGE_SIZES_REAL)) {
> @@ -454,7 +355,7 @@ static void kvm_fixup_page_sizes(PowerPCCPU *cpu)
>          has_smmu_info = true;
>      }
>  
> -    rampagesize = getrampagesize();
> +    rampagesize = qemu_getrampagesize();
>  
>      /* Convert to QEMU form */
>      memset(&env->sps, 0, sizeof(env->sps));
> @@ -2177,7 +2078,7 @@ uint64_t kvmppc_rma_size(uint64_t current_size, unsigned int hash_shift)
>      /* Find the largest hardware supported page size that's less than
>       * or equal to the (logical) backing page size of guest RAM */
>      kvm_get_smmu_info(POWERPC_CPU(first_cpu), &info);
> -    rampagesize = getrampagesize();
> +    rampagesize = qemu_getrampagesize();
>      best_page_shift = 0;
>  
>      for (i = 0; i < KVM_PPC_PAGE_SIZES_MAX_SZ; i++) {
> diff --git a/util/mmap-alloc.c b/util/mmap-alloc.c
> index 5a85aa3c89..564c79109c 100644
> --- a/util/mmap-alloc.c
> +++ b/util/mmap-alloc.c
> @@ -39,6 +39,31 @@ size_t qemu_fd_getpagesize(int fd)
>      return getpagesize();
>  }
>  
> +size_t qemu_mempath_getpagesize(const char *mem_path)
> +{
> +#ifdef CONFIG_LINUX
> +    struct statfs fs;
> +    int ret;
> +
> +    do {
> +        ret = statfs(mem_path, &fs);
> +    } while (ret != 0 && errno == EINTR);
> +
> +    if (ret != 0) {
> +        fprintf(stderr, "Couldn't statfs() memory path: %s\n",
> +                strerror(errno));
> +        exit(1);
> +    }
> +
> +    if (fs.f_type == HUGETLBFS_MAGIC) {
> +        /* It's hugepage, return the huge page size */
> +        return fs.f_bsize;
> +    }
> +#endif
> +
> +    return getpagesize();
> +}
> +
>  void *qemu_ram_mmap(int fd, size_t size, size_t align, bool shared)
>  {
>      /*

-- 
David Gibson			| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you.  NOT _the_ _other_
				| _way_ _around_!
http://www.ozlabs.org/~dgibson

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 819 bytes --]

Re: [Qemu-devel] [PATCH qemu 1/2] exec, kvm, target-ppc: Move getrampagesize() to common code

[Alexey Kardashevskiy]

[-- Attachment #1: Type: text/plain, Size: 11706 bytes --]

On 03/01/17 10:34, David Gibson wrote:
> On Thu, Dec 22, 2016 at 04:22:11PM +1100, Alexey Kardashevskiy wrote:
>> getrampagesize() returns the largest supported page size and mainly
>> used to know if huge pages are enabled.
>>
>> However is implemented in target-ppc/kvm.c and not available
>> in TCG or other architectures.
>>
>> This renames and moves gethugepagesize() to mmap-alloc.c where
>> fd-based analog of it is already implemented. This renames and moves
>> getrampagesize() to exec.c as it seems to be the common place for
>> helpers like this.
>>
>> This first user for it is going to be a spapr-pci-host-bridge which
>> needs to know the largest RAM page size so the guest could try
>> using bigger IOMMU pages to save memory.
>>
>> Signed-off-by: Alexey Kardashevskiy <aik@ozlabs.ru>
> 
> Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
> 
> Seems sensible to me, but I'm not comfortable merging this via my tree
> since it touches such core code.  Probably should go via Paolo.


Paolo, ping?



> 
>> ---
>>  include/exec/ram_addr.h   |   1 +
>>  include/qemu/mmap-alloc.h |   2 +
>>  exec.c                    |  82 ++++++++++++++++++++++++++++++++++++
>>  target-ppc/kvm.c          | 105 ++--------------------------------------------
>>  util/mmap-alloc.c         |  25 +++++++++++
>>  5 files changed, 113 insertions(+), 102 deletions(-)
>>
>> diff --git a/include/exec/ram_addr.h b/include/exec/ram_addr.h
>> index 54d7108a9e..3935cbcfcd 100644
>> --- a/include/exec/ram_addr.h
>> +++ b/include/exec/ram_addr.h
>> @@ -91,6 +91,7 @@ typedef struct RAMList {
>>  } RAMList;
>>  extern RAMList ram_list;
>>  
>> +long qemu_getrampagesize(void);
>>  ram_addr_t last_ram_offset(void);
>>  void qemu_mutex_lock_ramlist(void);
>>  void qemu_mutex_unlock_ramlist(void);
>> diff --git a/include/qemu/mmap-alloc.h b/include/qemu/mmap-alloc.h
>> index 933c024ac5..50385e3f81 100644
>> --- a/include/qemu/mmap-alloc.h
>> +++ b/include/qemu/mmap-alloc.h
>> @@ -5,6 +5,8 @@
>>  
>>  size_t qemu_fd_getpagesize(int fd);
>>  
>> +size_t qemu_mempath_getpagesize(const char *mem_path);
>> +
>>  void *qemu_ram_mmap(int fd, size_t size, size_t align, bool shared);
>>  
>>  void qemu_ram_munmap(void *ptr, size_t size);
>> diff --git a/exec.c b/exec.c
>> index 08c558eecf..d73b477a70 100644
>> --- a/exec.c
>> +++ b/exec.c
>> @@ -32,6 +32,7 @@
>>  #endif
>>  #include "sysemu/kvm.h"
>>  #include "sysemu/sysemu.h"
>> +#include "sysemu/numa.h"
>>  #include "qemu/timer.h"
>>  #include "qemu/config-file.h"
>>  #include "qemu/error-report.h"
>> @@ -1218,6 +1219,87 @@ void qemu_mutex_unlock_ramlist(void)
>>  }
>>  
>>  #ifdef __linux__
>> +/*
>> + * FIXME TOCTTOU: this iterates over memory backends' mem-path, which
>> + * may or may not name the same files / on the same filesystem now as
>> + * when we actually open and map them.  Iterate over the file
>> + * descriptors instead, and use qemu_fd_getpagesize().
>> + */
>> +static int find_max_supported_pagesize(Object *obj, void *opaque)
>> +{
>> +    char *mem_path;
>> +    long *hpsize_min = opaque;
>> +
>> +    if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) {
>> +        mem_path = object_property_get_str(obj, "mem-path", NULL);
>> +        if (mem_path) {
>> +            long hpsize = qemu_mempath_getpagesize(mem_path);
>> +            if (hpsize < *hpsize_min) {
>> +                *hpsize_min = hpsize;
>> +            }
>> +        } else {
>> +            *hpsize_min = getpagesize();
>> +        }
>> +    }
>> +
>> +    return 0;
>> +}
>> +
>> +long qemu_getrampagesize(void)
>> +{
>> +    long hpsize = LONG_MAX;
>> +    long mainrampagesize;
>> +    Object *memdev_root;
>> +
>> +    if (mem_path) {
>> +        mainrampagesize = qemu_mempath_getpagesize(mem_path);
>> +    } else {
>> +        mainrampagesize = getpagesize();
>> +    }
>> +
>> +    /* it's possible we have memory-backend objects with
>> +     * hugepage-backed RAM. these may get mapped into system
>> +     * address space via -numa parameters or memory hotplug
>> +     * hooks. we want to take these into account, but we
>> +     * also want to make sure these supported hugepage
>> +     * sizes are applicable across the entire range of memory
>> +     * we may boot from, so we take the min across all
>> +     * backends, and assume normal pages in cases where a
>> +     * backend isn't backed by hugepages.
>> +     */
>> +    memdev_root = object_resolve_path("/objects", NULL);
>> +    if (memdev_root) {
>> +        object_child_foreach(memdev_root, find_max_supported_pagesize, &hpsize);
>> +    }
>> +    if (hpsize == LONG_MAX) {
>> +        /* No additional memory regions found ==> Report main RAM page size */
>> +        return mainrampagesize;
>> +    }
>> +
>> +    /* If NUMA is disabled or the NUMA nodes are not backed with a
>> +     * memory-backend, then there is at least one node using "normal" RAM,
>> +     * so if its page size is smaller we have got to report that size instead.
>> +     */
>> +    if (hpsize > mainrampagesize &&
>> +        (nb_numa_nodes == 0 || numa_info[0].node_memdev == NULL)) {
>> +        static bool warned;
>> +        if (!warned) {
>> +            error_report("Huge page support disabled (n/a for main memory).");
>> +            warned = true;
>> +        }
>> +        return mainrampagesize;
>> +    }
>> +
>> +    return hpsize;
>> +}
>> +#else
>> +long qemu_getrampagesize(void)
>> +{
>> +    return getpagesize();
>> +}
>> +#endif
>> +
>> +#ifdef __linux__
>>  static int64_t get_file_size(int fd)
>>  {
>>      int64_t size = lseek(fd, 0, SEEK_END);
>> diff --git a/target-ppc/kvm.c b/target-ppc/kvm.c
>> index 6e91a4d8bb..e0abffa8ad 100644
>> --- a/target-ppc/kvm.c
>> +++ b/target-ppc/kvm.c
>> @@ -42,6 +42,7 @@
>>  #include "trace.h"
>>  #include "exec/gdbstub.h"
>>  #include "exec/memattrs.h"
>> +#include "exec/ram_addr.h"
>>  #include "sysemu/hostmem.h"
>>  #include "qemu/cutils.h"
>>  #if defined(TARGET_PPC64)
>> @@ -325,106 +326,6 @@ static void kvm_get_smmu_info(PowerPCCPU *cpu, struct kvm_ppc_smmu_info *info)
>>      kvm_get_fallback_smmu_info(cpu, info);
>>  }
>>  
>> -static long gethugepagesize(const char *mem_path)
>> -{
>> -    struct statfs fs;
>> -    int ret;
>> -
>> -    do {
>> -        ret = statfs(mem_path, &fs);
>> -    } while (ret != 0 && errno == EINTR);
>> -
>> -    if (ret != 0) {
>> -        fprintf(stderr, "Couldn't statfs() memory path: %s\n",
>> -                strerror(errno));
>> -        exit(1);
>> -    }
>> -
>> -#define HUGETLBFS_MAGIC       0x958458f6
>> -
>> -    if (fs.f_type != HUGETLBFS_MAGIC) {
>> -        /* Explicit mempath, but it's ordinary pages */
>> -        return getpagesize();
>> -    }
>> -
>> -    /* It's hugepage, return the huge page size */
>> -    return fs.f_bsize;
>> -}
>> -
>> -/*
>> - * FIXME TOCTTOU: this iterates over memory backends' mem-path, which
>> - * may or may not name the same files / on the same filesystem now as
>> - * when we actually open and map them.  Iterate over the file
>> - * descriptors instead, and use qemu_fd_getpagesize().
>> - */
>> -static int find_max_supported_pagesize(Object *obj, void *opaque)
>> -{
>> -    char *mem_path;
>> -    long *hpsize_min = opaque;
>> -
>> -    if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) {
>> -        mem_path = object_property_get_str(obj, "mem-path", NULL);
>> -        if (mem_path) {
>> -            long hpsize = gethugepagesize(mem_path);
>> -            if (hpsize < *hpsize_min) {
>> -                *hpsize_min = hpsize;
>> -            }
>> -        } else {
>> -            *hpsize_min = getpagesize();
>> -        }
>> -    }
>> -
>> -    return 0;
>> -}
>> -
>> -static long getrampagesize(void)
>> -{
>> -    long hpsize = LONG_MAX;
>> -    long mainrampagesize;
>> -    Object *memdev_root;
>> -
>> -    if (mem_path) {
>> -        mainrampagesize = gethugepagesize(mem_path);
>> -    } else {
>> -        mainrampagesize = getpagesize();
>> -    }
>> -
>> -    /* it's possible we have memory-backend objects with
>> -     * hugepage-backed RAM. these may get mapped into system
>> -     * address space via -numa parameters or memory hotplug
>> -     * hooks. we want to take these into account, but we
>> -     * also want to make sure these supported hugepage
>> -     * sizes are applicable across the entire range of memory
>> -     * we may boot from, so we take the min across all
>> -     * backends, and assume normal pages in cases where a
>> -     * backend isn't backed by hugepages.
>> -     */
>> -    memdev_root = object_resolve_path("/objects", NULL);
>> -    if (memdev_root) {
>> -        object_child_foreach(memdev_root, find_max_supported_pagesize, &hpsize);
>> -    }
>> -    if (hpsize == LONG_MAX) {
>> -        /* No additional memory regions found ==> Report main RAM page size */
>> -        return mainrampagesize;
>> -    }
>> -
>> -    /* If NUMA is disabled or the NUMA nodes are not backed with a
>> -     * memory-backend, then there is at least one node using "normal" RAM,
>> -     * so if its page size is smaller we have got to report that size instead.
>> -     */
>> -    if (hpsize > mainrampagesize &&
>> -        (nb_numa_nodes == 0 || numa_info[0].node_memdev == NULL)) {
>> -        static bool warned;
>> -        if (!warned) {
>> -            error_report("Huge page support disabled (n/a for main memory).");
>> -            warned = true;
>> -        }
>> -        return mainrampagesize;
>> -    }
>> -
>> -    return hpsize;
>> -}
>> -
>>  static bool kvm_valid_page_size(uint32_t flags, long rampgsize, uint32_t shift)
>>  {
>>      if (!(flags & KVM_PPC_PAGE_SIZES_REAL)) {
>> @@ -454,7 +355,7 @@ static void kvm_fixup_page_sizes(PowerPCCPU *cpu)
>>          has_smmu_info = true;
>>      }
>>  
>> -    rampagesize = getrampagesize();
>> +    rampagesize = qemu_getrampagesize();
>>  
>>      /* Convert to QEMU form */
>>      memset(&env->sps, 0, sizeof(env->sps));
>> @@ -2177,7 +2078,7 @@ uint64_t kvmppc_rma_size(uint64_t current_size, unsigned int hash_shift)
>>      /* Find the largest hardware supported page size that's less than
>>       * or equal to the (logical) backing page size of guest RAM */
>>      kvm_get_smmu_info(POWERPC_CPU(first_cpu), &info);
>> -    rampagesize = getrampagesize();
>> +    rampagesize = qemu_getrampagesize();
>>      best_page_shift = 0;
>>  
>>      for (i = 0; i < KVM_PPC_PAGE_SIZES_MAX_SZ; i++) {
>> diff --git a/util/mmap-alloc.c b/util/mmap-alloc.c
>> index 5a85aa3c89..564c79109c 100644
>> --- a/util/mmap-alloc.c
>> +++ b/util/mmap-alloc.c
>> @@ -39,6 +39,31 @@ size_t qemu_fd_getpagesize(int fd)
>>      return getpagesize();
>>  }
>>  
>> +size_t qemu_mempath_getpagesize(const char *mem_path)
>> +{
>> +#ifdef CONFIG_LINUX
>> +    struct statfs fs;
>> +    int ret;
>> +
>> +    do {
>> +        ret = statfs(mem_path, &fs);
>> +    } while (ret != 0 && errno == EINTR);
>> +
>> +    if (ret != 0) {
>> +        fprintf(stderr, "Couldn't statfs() memory path: %s\n",
>> +                strerror(errno));
>> +        exit(1);
>> +    }
>> +
>> +    if (fs.f_type == HUGETLBFS_MAGIC) {
>> +        /* It's hugepage, return the huge page size */
>> +        return fs.f_bsize;
>> +    }
>> +#endif
>> +
>> +    return getpagesize();
>> +}
>> +
>>  void *qemu_ram_mmap(int fd, size_t size, size_t align, bool shared)
>>  {
>>      /*
> 


-- 
Alexey


[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 839 bytes --]

Re: [Qemu-devel] [PATCH qemu 1/2] exec, kvm, target-ppc: Move getrampagesize() to common code

[Paolo Bonzini]

[-- Attachment #1: Type: text/plain, Size: 12132 bytes --]



On 09/02/2017 06:43, Alexey Kardashevskiy wrote:
> On 03/01/17 10:34, David Gibson wrote:
>> On Thu, Dec 22, 2016 at 04:22:11PM +1100, Alexey Kardashevskiy wrote:
>>> getrampagesize() returns the largest supported page size and mainly
>>> used to know if huge pages are enabled.
>>>
>>> However is implemented in target-ppc/kvm.c and not available
>>> in TCG or other architectures.
>>>
>>> This renames and moves gethugepagesize() to mmap-alloc.c where
>>> fd-based analog of it is already implemented. This renames and moves
>>> getrampagesize() to exec.c as it seems to be the common place for
>>> helpers like this.
>>>
>>> This first user for it is going to be a spapr-pci-host-bridge which
>>> needs to know the largest RAM page size so the guest could try
>>> using bigger IOMMU pages to save memory.
>>>
>>> Signed-off-by: Alexey Kardashevskiy <aik@ozlabs.ru>
>>
>> Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
>>
>> Seems sensible to me, but I'm not comfortable merging this via my tree
>> since it touches such core code.  Probably should go via Paolo.
> 
> Paolo, ping?

It's just code movement, go ahead.

Paolo

> 
> 
>>
>>> ---
>>>  include/exec/ram_addr.h   |   1 +
>>>  include/qemu/mmap-alloc.h |   2 +
>>>  exec.c                    |  82 ++++++++++++++++++++++++++++++++++++
>>>  target-ppc/kvm.c          | 105 ++--------------------------------------------
>>>  util/mmap-alloc.c         |  25 +++++++++++
>>>  5 files changed, 113 insertions(+), 102 deletions(-)
>>>
>>> diff --git a/include/exec/ram_addr.h b/include/exec/ram_addr.h
>>> index 54d7108a9e..3935cbcfcd 100644
>>> --- a/include/exec/ram_addr.h
>>> +++ b/include/exec/ram_addr.h
>>> @@ -91,6 +91,7 @@ typedef struct RAMList {
>>>  } RAMList;
>>>  extern RAMList ram_list;
>>>  
>>> +long qemu_getrampagesize(void);
>>>  ram_addr_t last_ram_offset(void);
>>>  void qemu_mutex_lock_ramlist(void);
>>>  void qemu_mutex_unlock_ramlist(void);
>>> diff --git a/include/qemu/mmap-alloc.h b/include/qemu/mmap-alloc.h
>>> index 933c024ac5..50385e3f81 100644
>>> --- a/include/qemu/mmap-alloc.h
>>> +++ b/include/qemu/mmap-alloc.h
>>> @@ -5,6 +5,8 @@
>>>  
>>>  size_t qemu_fd_getpagesize(int fd);
>>>  
>>> +size_t qemu_mempath_getpagesize(const char *mem_path);
>>> +
>>>  void *qemu_ram_mmap(int fd, size_t size, size_t align, bool shared);
>>>  
>>>  void qemu_ram_munmap(void *ptr, size_t size);
>>> diff --git a/exec.c b/exec.c
>>> index 08c558eecf..d73b477a70 100644
>>> --- a/exec.c
>>> +++ b/exec.c
>>> @@ -32,6 +32,7 @@
>>>  #endif
>>>  #include "sysemu/kvm.h"
>>>  #include "sysemu/sysemu.h"
>>> +#include "sysemu/numa.h"
>>>  #include "qemu/timer.h"
>>>  #include "qemu/config-file.h"
>>>  #include "qemu/error-report.h"
>>> @@ -1218,6 +1219,87 @@ void qemu_mutex_unlock_ramlist(void)
>>>  }
>>>  
>>>  #ifdef __linux__
>>> +/*
>>> + * FIXME TOCTTOU: this iterates over memory backends' mem-path, which
>>> + * may or may not name the same files / on the same filesystem now as
>>> + * when we actually open and map them.  Iterate over the file
>>> + * descriptors instead, and use qemu_fd_getpagesize().
>>> + */
>>> +static int find_max_supported_pagesize(Object *obj, void *opaque)
>>> +{
>>> +    char *mem_path;
>>> +    long *hpsize_min = opaque;
>>> +
>>> +    if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) {
>>> +        mem_path = object_property_get_str(obj, "mem-path", NULL);
>>> +        if (mem_path) {
>>> +            long hpsize = qemu_mempath_getpagesize(mem_path);
>>> +            if (hpsize < *hpsize_min) {
>>> +                *hpsize_min = hpsize;
>>> +            }
>>> +        } else {
>>> +            *hpsize_min = getpagesize();
>>> +        }
>>> +    }
>>> +
>>> +    return 0;
>>> +}
>>> +
>>> +long qemu_getrampagesize(void)
>>> +{
>>> +    long hpsize = LONG_MAX;
>>> +    long mainrampagesize;
>>> +    Object *memdev_root;
>>> +
>>> +    if (mem_path) {
>>> +        mainrampagesize = qemu_mempath_getpagesize(mem_path);
>>> +    } else {
>>> +        mainrampagesize = getpagesize();
>>> +    }
>>> +
>>> +    /* it's possible we have memory-backend objects with
>>> +     * hugepage-backed RAM. these may get mapped into system
>>> +     * address space via -numa parameters or memory hotplug
>>> +     * hooks. we want to take these into account, but we
>>> +     * also want to make sure these supported hugepage
>>> +     * sizes are applicable across the entire range of memory
>>> +     * we may boot from, so we take the min across all
>>> +     * backends, and assume normal pages in cases where a
>>> +     * backend isn't backed by hugepages.
>>> +     */
>>> +    memdev_root = object_resolve_path("/objects", NULL);
>>> +    if (memdev_root) {
>>> +        object_child_foreach(memdev_root, find_max_supported_pagesize, &hpsize);
>>> +    }
>>> +    if (hpsize == LONG_MAX) {
>>> +        /* No additional memory regions found ==> Report main RAM page size */
>>> +        return mainrampagesize;
>>> +    }
>>> +
>>> +    /* If NUMA is disabled or the NUMA nodes are not backed with a
>>> +     * memory-backend, then there is at least one node using "normal" RAM,
>>> +     * so if its page size is smaller we have got to report that size instead.
>>> +     */
>>> +    if (hpsize > mainrampagesize &&
>>> +        (nb_numa_nodes == 0 || numa_info[0].node_memdev == NULL)) {
>>> +        static bool warned;
>>> +        if (!warned) {
>>> +            error_report("Huge page support disabled (n/a for main memory).");
>>> +            warned = true;
>>> +        }
>>> +        return mainrampagesize;
>>> +    }
>>> +
>>> +    return hpsize;
>>> +}
>>> +#else
>>> +long qemu_getrampagesize(void)
>>> +{
>>> +    return getpagesize();
>>> +}
>>> +#endif
>>> +
>>> +#ifdef __linux__
>>>  static int64_t get_file_size(int fd)
>>>  {
>>>      int64_t size = lseek(fd, 0, SEEK_END);
>>> diff --git a/target-ppc/kvm.c b/target-ppc/kvm.c
>>> index 6e91a4d8bb..e0abffa8ad 100644
>>> --- a/target-ppc/kvm.c
>>> +++ b/target-ppc/kvm.c
>>> @@ -42,6 +42,7 @@
>>>  #include "trace.h"
>>>  #include "exec/gdbstub.h"
>>>  #include "exec/memattrs.h"
>>> +#include "exec/ram_addr.h"
>>>  #include "sysemu/hostmem.h"
>>>  #include "qemu/cutils.h"
>>>  #if defined(TARGET_PPC64)
>>> @@ -325,106 +326,6 @@ static void kvm_get_smmu_info(PowerPCCPU *cpu, struct kvm_ppc_smmu_info *info)
>>>      kvm_get_fallback_smmu_info(cpu, info);
>>>  }
>>>  
>>> -static long gethugepagesize(const char *mem_path)
>>> -{
>>> -    struct statfs fs;
>>> -    int ret;
>>> -
>>> -    do {
>>> -        ret = statfs(mem_path, &fs);
>>> -    } while (ret != 0 && errno == EINTR);
>>> -
>>> -    if (ret != 0) {
>>> -        fprintf(stderr, "Couldn't statfs() memory path: %s\n",
>>> -                strerror(errno));
>>> -        exit(1);
>>> -    }
>>> -
>>> -#define HUGETLBFS_MAGIC       0x958458f6
>>> -
>>> -    if (fs.f_type != HUGETLBFS_MAGIC) {
>>> -        /* Explicit mempath, but it's ordinary pages */
>>> -        return getpagesize();
>>> -    }
>>> -
>>> -    /* It's hugepage, return the huge page size */
>>> -    return fs.f_bsize;
>>> -}
>>> -
>>> -/*
>>> - * FIXME TOCTTOU: this iterates over memory backends' mem-path, which
>>> - * may or may not name the same files / on the same filesystem now as
>>> - * when we actually open and map them.  Iterate over the file
>>> - * descriptors instead, and use qemu_fd_getpagesize().
>>> - */
>>> -static int find_max_supported_pagesize(Object *obj, void *opaque)
>>> -{
>>> -    char *mem_path;
>>> -    long *hpsize_min = opaque;
>>> -
>>> -    if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) {
>>> -        mem_path = object_property_get_str(obj, "mem-path", NULL);
>>> -        if (mem_path) {
>>> -            long hpsize = gethugepagesize(mem_path);
>>> -            if (hpsize < *hpsize_min) {
>>> -                *hpsize_min = hpsize;
>>> -            }
>>> -        } else {
>>> -            *hpsize_min = getpagesize();
>>> -        }
>>> -    }
>>> -
>>> -    return 0;
>>> -}
>>> -
>>> -static long getrampagesize(void)
>>> -{
>>> -    long hpsize = LONG_MAX;
>>> -    long mainrampagesize;
>>> -    Object *memdev_root;
>>> -
>>> -    if (mem_path) {
>>> -        mainrampagesize = gethugepagesize(mem_path);
>>> -    } else {
>>> -        mainrampagesize = getpagesize();
>>> -    }
>>> -
>>> -    /* it's possible we have memory-backend objects with
>>> -     * hugepage-backed RAM. these may get mapped into system
>>> -     * address space via -numa parameters or memory hotplug
>>> -     * hooks. we want to take these into account, but we
>>> -     * also want to make sure these supported hugepage
>>> -     * sizes are applicable across the entire range of memory
>>> -     * we may boot from, so we take the min across all
>>> -     * backends, and assume normal pages in cases where a
>>> -     * backend isn't backed by hugepages.
>>> -     */
>>> -    memdev_root = object_resolve_path("/objects", NULL);
>>> -    if (memdev_root) {
>>> -        object_child_foreach(memdev_root, find_max_supported_pagesize, &hpsize);
>>> -    }
>>> -    if (hpsize == LONG_MAX) {
>>> -        /* No additional memory regions found ==> Report main RAM page size */
>>> -        return mainrampagesize;
>>> -    }
>>> -
>>> -    /* If NUMA is disabled or the NUMA nodes are not backed with a
>>> -     * memory-backend, then there is at least one node using "normal" RAM,
>>> -     * so if its page size is smaller we have got to report that size instead.
>>> -     */
>>> -    if (hpsize > mainrampagesize &&
>>> -        (nb_numa_nodes == 0 || numa_info[0].node_memdev == NULL)) {
>>> -        static bool warned;
>>> -        if (!warned) {
>>> -            error_report("Huge page support disabled (n/a for main memory).");
>>> -            warned = true;
>>> -        }
>>> -        return mainrampagesize;
>>> -    }
>>> -
>>> -    return hpsize;
>>> -}
>>> -
>>>  static bool kvm_valid_page_size(uint32_t flags, long rampgsize, uint32_t shift)
>>>  {
>>>      if (!(flags & KVM_PPC_PAGE_SIZES_REAL)) {
>>> @@ -454,7 +355,7 @@ static void kvm_fixup_page_sizes(PowerPCCPU *cpu)
>>>          has_smmu_info = true;
>>>      }
>>>  
>>> -    rampagesize = getrampagesize();
>>> +    rampagesize = qemu_getrampagesize();
>>>  
>>>      /* Convert to QEMU form */
>>>      memset(&env->sps, 0, sizeof(env->sps));
>>> @@ -2177,7 +2078,7 @@ uint64_t kvmppc_rma_size(uint64_t current_size, unsigned int hash_shift)
>>>      /* Find the largest hardware supported page size that's less than
>>>       * or equal to the (logical) backing page size of guest RAM */
>>>      kvm_get_smmu_info(POWERPC_CPU(first_cpu), &info);
>>> -    rampagesize = getrampagesize();
>>> +    rampagesize = qemu_getrampagesize();
>>>      best_page_shift = 0;
>>>  
>>>      for (i = 0; i < KVM_PPC_PAGE_SIZES_MAX_SZ; i++) {
>>> diff --git a/util/mmap-alloc.c b/util/mmap-alloc.c
>>> index 5a85aa3c89..564c79109c 100644
>>> --- a/util/mmap-alloc.c
>>> +++ b/util/mmap-alloc.c
>>> @@ -39,6 +39,31 @@ size_t qemu_fd_getpagesize(int fd)
>>>      return getpagesize();
>>>  }
>>>  
>>> +size_t qemu_mempath_getpagesize(const char *mem_path)
>>> +{
>>> +#ifdef CONFIG_LINUX
>>> +    struct statfs fs;
>>> +    int ret;
>>> +
>>> +    do {
>>> +        ret = statfs(mem_path, &fs);
>>> +    } while (ret != 0 && errno == EINTR);
>>> +
>>> +    if (ret != 0) {
>>> +        fprintf(stderr, "Couldn't statfs() memory path: %s\n",
>>> +                strerror(errno));
>>> +        exit(1);
>>> +    }
>>> +
>>> +    if (fs.f_type == HUGETLBFS_MAGIC) {
>>> +        /* It's hugepage, return the huge page size */
>>> +        return fs.f_bsize;
>>> +    }
>>> +#endif
>>> +
>>> +    return getpagesize();
>>> +}
>>> +
>>>  void *qemu_ram_mmap(int fd, size_t size, size_t align, bool shared)
>>>  {
>>>      /*
>>
> 
> 


[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 473 bytes --]

Re: [Qemu-devel] [PATCH qemu 1/2] exec, kvm, target-ppc: Move getrampagesize() to common code

[David Gibson]

[-- Attachment #1: Type: text/plain, Size: 13130 bytes --]

On Thu, Feb 09, 2017 at 12:48:19PM +0100, Paolo Bonzini wrote:
> 
> 
> On 09/02/2017 06:43, Alexey Kardashevskiy wrote:
> > On 03/01/17 10:34, David Gibson wrote:
> >> On Thu, Dec 22, 2016 at 04:22:11PM +1100, Alexey Kardashevskiy wrote:
> >>> getrampagesize() returns the largest supported page size and mainly
> >>> used to know if huge pages are enabled.
> >>>
> >>> However is implemented in target-ppc/kvm.c and not available
> >>> in TCG or other architectures.
> >>>
> >>> This renames and moves gethugepagesize() to mmap-alloc.c where
> >>> fd-based analog of it is already implemented. This renames and moves
> >>> getrampagesize() to exec.c as it seems to be the common place for
> >>> helpers like this.
> >>>
> >>> This first user for it is going to be a spapr-pci-host-bridge which
> >>> needs to know the largest RAM page size so the guest could try
> >>> using bigger IOMMU pages to save memory.
> >>>
> >>> Signed-off-by: Alexey Kardashevskiy <aik@ozlabs.ru>
> >>
> >> Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
> >>
> >> Seems sensible to me, but I'm not comfortable merging this via my tree
> >> since it touches such core code.  Probably should go via Paolo.
> > 
> > Paolo, ping?
> 
> It's just code movement, go ahead.

Ok, I've merged this in my tree.


> 
> Paolo
> 
> > 
> > 
> >>
> >>> ---
> >>>  include/exec/ram_addr.h   |   1 +
> >>>  include/qemu/mmap-alloc.h |   2 +
> >>>  exec.c                    |  82 ++++++++++++++++++++++++++++++++++++
> >>>  target-ppc/kvm.c          | 105 ++--------------------------------------------
> >>>  util/mmap-alloc.c         |  25 +++++++++++
> >>>  5 files changed, 113 insertions(+), 102 deletions(-)
> >>>
> >>> diff --git a/include/exec/ram_addr.h b/include/exec/ram_addr.h
> >>> index 54d7108a9e..3935cbcfcd 100644
> >>> --- a/include/exec/ram_addr.h
> >>> +++ b/include/exec/ram_addr.h
> >>> @@ -91,6 +91,7 @@ typedef struct RAMList {
> >>>  } RAMList;
> >>>  extern RAMList ram_list;
> >>>  
> >>> +long qemu_getrampagesize(void);
> >>>  ram_addr_t last_ram_offset(void);
> >>>  void qemu_mutex_lock_ramlist(void);
> >>>  void qemu_mutex_unlock_ramlist(void);
> >>> diff --git a/include/qemu/mmap-alloc.h b/include/qemu/mmap-alloc.h
> >>> index 933c024ac5..50385e3f81 100644
> >>> --- a/include/qemu/mmap-alloc.h
> >>> +++ b/include/qemu/mmap-alloc.h
> >>> @@ -5,6 +5,8 @@
> >>>  
> >>>  size_t qemu_fd_getpagesize(int fd);
> >>>  
> >>> +size_t qemu_mempath_getpagesize(const char *mem_path);
> >>> +
> >>>  void *qemu_ram_mmap(int fd, size_t size, size_t align, bool shared);
> >>>  
> >>>  void qemu_ram_munmap(void *ptr, size_t size);
> >>> diff --git a/exec.c b/exec.c
> >>> index 08c558eecf..d73b477a70 100644
> >>> --- a/exec.c
> >>> +++ b/exec.c
> >>> @@ -32,6 +32,7 @@
> >>>  #endif
> >>>  #include "sysemu/kvm.h"
> >>>  #include "sysemu/sysemu.h"
> >>> +#include "sysemu/numa.h"
> >>>  #include "qemu/timer.h"
> >>>  #include "qemu/config-file.h"
> >>>  #include "qemu/error-report.h"
> >>> @@ -1218,6 +1219,87 @@ void qemu_mutex_unlock_ramlist(void)
> >>>  }
> >>>  
> >>>  #ifdef __linux__
> >>> +/*
> >>> + * FIXME TOCTTOU: this iterates over memory backends' mem-path, which
> >>> + * may or may not name the same files / on the same filesystem now as
> >>> + * when we actually open and map them.  Iterate over the file
> >>> + * descriptors instead, and use qemu_fd_getpagesize().
> >>> + */
> >>> +static int find_max_supported_pagesize(Object *obj, void *opaque)
> >>> +{
> >>> +    char *mem_path;
> >>> +    long *hpsize_min = opaque;
> >>> +
> >>> +    if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) {
> >>> +        mem_path = object_property_get_str(obj, "mem-path", NULL);
> >>> +        if (mem_path) {
> >>> +            long hpsize = qemu_mempath_getpagesize(mem_path);
> >>> +            if (hpsize < *hpsize_min) {
> >>> +                *hpsize_min = hpsize;
> >>> +            }
> >>> +        } else {
> >>> +            *hpsize_min = getpagesize();
> >>> +        }
> >>> +    }
> >>> +
> >>> +    return 0;
> >>> +}
> >>> +
> >>> +long qemu_getrampagesize(void)
> >>> +{
> >>> +    long hpsize = LONG_MAX;
> >>> +    long mainrampagesize;
> >>> +    Object *memdev_root;
> >>> +
> >>> +    if (mem_path) {
> >>> +        mainrampagesize = qemu_mempath_getpagesize(mem_path);
> >>> +    } else {
> >>> +        mainrampagesize = getpagesize();
> >>> +    }
> >>> +
> >>> +    /* it's possible we have memory-backend objects with
> >>> +     * hugepage-backed RAM. these may get mapped into system
> >>> +     * address space via -numa parameters or memory hotplug
> >>> +     * hooks. we want to take these into account, but we
> >>> +     * also want to make sure these supported hugepage
> >>> +     * sizes are applicable across the entire range of memory
> >>> +     * we may boot from, so we take the min across all
> >>> +     * backends, and assume normal pages in cases where a
> >>> +     * backend isn't backed by hugepages.
> >>> +     */
> >>> +    memdev_root = object_resolve_path("/objects", NULL);
> >>> +    if (memdev_root) {
> >>> +        object_child_foreach(memdev_root, find_max_supported_pagesize, &hpsize);
> >>> +    }
> >>> +    if (hpsize == LONG_MAX) {
> >>> +        /* No additional memory regions found ==> Report main RAM page size */
> >>> +        return mainrampagesize;
> >>> +    }
> >>> +
> >>> +    /* If NUMA is disabled or the NUMA nodes are not backed with a
> >>> +     * memory-backend, then there is at least one node using "normal" RAM,
> >>> +     * so if its page size is smaller we have got to report that size instead.
> >>> +     */
> >>> +    if (hpsize > mainrampagesize &&
> >>> +        (nb_numa_nodes == 0 || numa_info[0].node_memdev == NULL)) {
> >>> +        static bool warned;
> >>> +        if (!warned) {
> >>> +            error_report("Huge page support disabled (n/a for main memory).");
> >>> +            warned = true;
> >>> +        }
> >>> +        return mainrampagesize;
> >>> +    }
> >>> +
> >>> +    return hpsize;
> >>> +}
> >>> +#else
> >>> +long qemu_getrampagesize(void)
> >>> +{
> >>> +    return getpagesize();
> >>> +}
> >>> +#endif
> >>> +
> >>> +#ifdef __linux__
> >>>  static int64_t get_file_size(int fd)
> >>>  {
> >>>      int64_t size = lseek(fd, 0, SEEK_END);
> >>> diff --git a/target-ppc/kvm.c b/target-ppc/kvm.c
> >>> index 6e91a4d8bb..e0abffa8ad 100644
> >>> --- a/target-ppc/kvm.c
> >>> +++ b/target-ppc/kvm.c
> >>> @@ -42,6 +42,7 @@
> >>>  #include "trace.h"
> >>>  #include "exec/gdbstub.h"
> >>>  #include "exec/memattrs.h"
> >>> +#include "exec/ram_addr.h"
> >>>  #include "sysemu/hostmem.h"
> >>>  #include "qemu/cutils.h"
> >>>  #if defined(TARGET_PPC64)
> >>> @@ -325,106 +326,6 @@ static void kvm_get_smmu_info(PowerPCCPU *cpu, struct kvm_ppc_smmu_info *info)
> >>>      kvm_get_fallback_smmu_info(cpu, info);
> >>>  }
> >>>  
> >>> -static long gethugepagesize(const char *mem_path)
> >>> -{
> >>> -    struct statfs fs;
> >>> -    int ret;
> >>> -
> >>> -    do {
> >>> -        ret = statfs(mem_path, &fs);
> >>> -    } while (ret != 0 && errno == EINTR);
> >>> -
> >>> -    if (ret != 0) {
> >>> -        fprintf(stderr, "Couldn't statfs() memory path: %s\n",
> >>> -                strerror(errno));
> >>> -        exit(1);
> >>> -    }
> >>> -
> >>> -#define HUGETLBFS_MAGIC       0x958458f6
> >>> -
> >>> -    if (fs.f_type != HUGETLBFS_MAGIC) {
> >>> -        /* Explicit mempath, but it's ordinary pages */
> >>> -        return getpagesize();
> >>> -    }
> >>> -
> >>> -    /* It's hugepage, return the huge page size */
> >>> -    return fs.f_bsize;
> >>> -}
> >>> -
> >>> -/*
> >>> - * FIXME TOCTTOU: this iterates over memory backends' mem-path, which
> >>> - * may or may not name the same files / on the same filesystem now as
> >>> - * when we actually open and map them.  Iterate over the file
> >>> - * descriptors instead, and use qemu_fd_getpagesize().
> >>> - */
> >>> -static int find_max_supported_pagesize(Object *obj, void *opaque)
> >>> -{
> >>> -    char *mem_path;
> >>> -    long *hpsize_min = opaque;
> >>> -
> >>> -    if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) {
> >>> -        mem_path = object_property_get_str(obj, "mem-path", NULL);
> >>> -        if (mem_path) {
> >>> -            long hpsize = gethugepagesize(mem_path);
> >>> -            if (hpsize < *hpsize_min) {
> >>> -                *hpsize_min = hpsize;
> >>> -            }
> >>> -        } else {
> >>> -            *hpsize_min = getpagesize();
> >>> -        }
> >>> -    }
> >>> -
> >>> -    return 0;
> >>> -}
> >>> -
> >>> -static long getrampagesize(void)
> >>> -{
> >>> -    long hpsize = LONG_MAX;
> >>> -    long mainrampagesize;
> >>> -    Object *memdev_root;
> >>> -
> >>> -    if (mem_path) {
> >>> -        mainrampagesize = gethugepagesize(mem_path);
> >>> -    } else {
> >>> -        mainrampagesize = getpagesize();
> >>> -    }
> >>> -
> >>> -    /* it's possible we have memory-backend objects with
> >>> -     * hugepage-backed RAM. these may get mapped into system
> >>> -     * address space via -numa parameters or memory hotplug
> >>> -     * hooks. we want to take these into account, but we
> >>> -     * also want to make sure these supported hugepage
> >>> -     * sizes are applicable across the entire range of memory
> >>> -     * we may boot from, so we take the min across all
> >>> -     * backends, and assume normal pages in cases where a
> >>> -     * backend isn't backed by hugepages.
> >>> -     */
> >>> -    memdev_root = object_resolve_path("/objects", NULL);
> >>> -    if (memdev_root) {
> >>> -        object_child_foreach(memdev_root, find_max_supported_pagesize, &hpsize);
> >>> -    }
> >>> -    if (hpsize == LONG_MAX) {
> >>> -        /* No additional memory regions found ==> Report main RAM page size */
> >>> -        return mainrampagesize;
> >>> -    }
> >>> -
> >>> -    /* If NUMA is disabled or the NUMA nodes are not backed with a
> >>> -     * memory-backend, then there is at least one node using "normal" RAM,
> >>> -     * so if its page size is smaller we have got to report that size instead.
> >>> -     */
> >>> -    if (hpsize > mainrampagesize &&
> >>> -        (nb_numa_nodes == 0 || numa_info[0].node_memdev == NULL)) {
> >>> -        static bool warned;
> >>> -        if (!warned) {
> >>> -            error_report("Huge page support disabled (n/a for main memory).");
> >>> -            warned = true;
> >>> -        }
> >>> -        return mainrampagesize;
> >>> -    }
> >>> -
> >>> -    return hpsize;
> >>> -}
> >>> -
> >>>  static bool kvm_valid_page_size(uint32_t flags, long rampgsize, uint32_t shift)
> >>>  {
> >>>      if (!(flags & KVM_PPC_PAGE_SIZES_REAL)) {
> >>> @@ -454,7 +355,7 @@ static void kvm_fixup_page_sizes(PowerPCCPU *cpu)
> >>>          has_smmu_info = true;
> >>>      }
> >>>  
> >>> -    rampagesize = getrampagesize();
> >>> +    rampagesize = qemu_getrampagesize();
> >>>  
> >>>      /* Convert to QEMU form */
> >>>      memset(&env->sps, 0, sizeof(env->sps));
> >>> @@ -2177,7 +2078,7 @@ uint64_t kvmppc_rma_size(uint64_t current_size, unsigned int hash_shift)
> >>>      /* Find the largest hardware supported page size that's less than
> >>>       * or equal to the (logical) backing page size of guest RAM */
> >>>      kvm_get_smmu_info(POWERPC_CPU(first_cpu), &info);
> >>> -    rampagesize = getrampagesize();
> >>> +    rampagesize = qemu_getrampagesize();
> >>>      best_page_shift = 0;
> >>>  
> >>>      for (i = 0; i < KVM_PPC_PAGE_SIZES_MAX_SZ; i++) {
> >>> diff --git a/util/mmap-alloc.c b/util/mmap-alloc.c
> >>> index 5a85aa3c89..564c79109c 100644
> >>> --- a/util/mmap-alloc.c
> >>> +++ b/util/mmap-alloc.c
> >>> @@ -39,6 +39,31 @@ size_t qemu_fd_getpagesize(int fd)
> >>>      return getpagesize();
> >>>  }
> >>>  
> >>> +size_t qemu_mempath_getpagesize(const char *mem_path)
> >>> +{
> >>> +#ifdef CONFIG_LINUX
> >>> +    struct statfs fs;
> >>> +    int ret;
> >>> +
> >>> +    do {
> >>> +        ret = statfs(mem_path, &fs);
> >>> +    } while (ret != 0 && errno == EINTR);
> >>> +
> >>> +    if (ret != 0) {
> >>> +        fprintf(stderr, "Couldn't statfs() memory path: %s\n",
> >>> +                strerror(errno));
> >>> +        exit(1);
> >>> +    }
> >>> +
> >>> +    if (fs.f_type == HUGETLBFS_MAGIC) {
> >>> +        /* It's hugepage, return the huge page size */
> >>> +        return fs.f_bsize;
> >>> +    }
> >>> +#endif
> >>> +
> >>> +    return getpagesize();
> >>> +}
> >>> +
> >>>  void *qemu_ram_mmap(int fd, size_t size, size_t align, bool shared)
> >>>  {
> >>>      /*
> >>
> > 
> > 
> 




-- 
David Gibson			| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you.  NOT _the_ _other_
				| _way_ _around_!
http://www.ozlabs.org/~dgibson

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 819 bytes --]

Re: [Qemu-devel] [PATCH qemu 1/2] exec, kvm, target-ppc: Move getrampagesize() to common code

[Alexey Kardashevskiy]

[-- Attachment #1: Type: text/plain, Size: 13076 bytes --]

On 10/02/17 11:41, David Gibson wrote:
> On Thu, Feb 09, 2017 at 12:48:19PM +0100, Paolo Bonzini wrote:
>>
>>
>> On 09/02/2017 06:43, Alexey Kardashevskiy wrote:
>>> On 03/01/17 10:34, David Gibson wrote:
>>>> On Thu, Dec 22, 2016 at 04:22:11PM +1100, Alexey Kardashevskiy wrote:
>>>>> getrampagesize() returns the largest supported page size and mainly
>>>>> used to know if huge pages are enabled.
>>>>>
>>>>> However is implemented in target-ppc/kvm.c and not available
>>>>> in TCG or other architectures.
>>>>>
>>>>> This renames and moves gethugepagesize() to mmap-alloc.c where
>>>>> fd-based analog of it is already implemented. This renames and moves
>>>>> getrampagesize() to exec.c as it seems to be the common place for
>>>>> helpers like this.
>>>>>
>>>>> This first user for it is going to be a spapr-pci-host-bridge which
>>>>> needs to know the largest RAM page size so the guest could try
>>>>> using bigger IOMMU pages to save memory.
>>>>>
>>>>> Signed-off-by: Alexey Kardashevskiy <aik@ozlabs.ru>
>>>>
>>>> Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
>>>>
>>>> Seems sensible to me, but I'm not comfortable merging this via my tree
>>>> since it touches such core code.  Probably should go via Paolo.
>>>
>>> Paolo, ping?
>>
>> It's just code movement, go ahead.
> 
> Ok, I've merged this in my tree.


I cannot find it in any public tree, where did it go?



> 
> 
>>
>> Paolo
>>
>>>
>>>
>>>>
>>>>> ---
>>>>>  include/exec/ram_addr.h   |   1 +
>>>>>  include/qemu/mmap-alloc.h |   2 +
>>>>>  exec.c                    |  82 ++++++++++++++++++++++++++++++++++++
>>>>>  target-ppc/kvm.c          | 105 ++--------------------------------------------
>>>>>  util/mmap-alloc.c         |  25 +++++++++++
>>>>>  5 files changed, 113 insertions(+), 102 deletions(-)
>>>>>
>>>>> diff --git a/include/exec/ram_addr.h b/include/exec/ram_addr.h
>>>>> index 54d7108a9e..3935cbcfcd 100644
>>>>> --- a/include/exec/ram_addr.h
>>>>> +++ b/include/exec/ram_addr.h
>>>>> @@ -91,6 +91,7 @@ typedef struct RAMList {
>>>>>  } RAMList;
>>>>>  extern RAMList ram_list;
>>>>>  
>>>>> +long qemu_getrampagesize(void);
>>>>>  ram_addr_t last_ram_offset(void);
>>>>>  void qemu_mutex_lock_ramlist(void);
>>>>>  void qemu_mutex_unlock_ramlist(void);
>>>>> diff --git a/include/qemu/mmap-alloc.h b/include/qemu/mmap-alloc.h
>>>>> index 933c024ac5..50385e3f81 100644
>>>>> --- a/include/qemu/mmap-alloc.h
>>>>> +++ b/include/qemu/mmap-alloc.h
>>>>> @@ -5,6 +5,8 @@
>>>>>  
>>>>>  size_t qemu_fd_getpagesize(int fd);
>>>>>  
>>>>> +size_t qemu_mempath_getpagesize(const char *mem_path);
>>>>> +
>>>>>  void *qemu_ram_mmap(int fd, size_t size, size_t align, bool shared);
>>>>>  
>>>>>  void qemu_ram_munmap(void *ptr, size_t size);
>>>>> diff --git a/exec.c b/exec.c
>>>>> index 08c558eecf..d73b477a70 100644
>>>>> --- a/exec.c
>>>>> +++ b/exec.c
>>>>> @@ -32,6 +32,7 @@
>>>>>  #endif
>>>>>  #include "sysemu/kvm.h"
>>>>>  #include "sysemu/sysemu.h"
>>>>> +#include "sysemu/numa.h"
>>>>>  #include "qemu/timer.h"
>>>>>  #include "qemu/config-file.h"
>>>>>  #include "qemu/error-report.h"
>>>>> @@ -1218,6 +1219,87 @@ void qemu_mutex_unlock_ramlist(void)
>>>>>  }
>>>>>  
>>>>>  #ifdef __linux__
>>>>> +/*
>>>>> + * FIXME TOCTTOU: this iterates over memory backends' mem-path, which
>>>>> + * may or may not name the same files / on the same filesystem now as
>>>>> + * when we actually open and map them.  Iterate over the file
>>>>> + * descriptors instead, and use qemu_fd_getpagesize().
>>>>> + */
>>>>> +static int find_max_supported_pagesize(Object *obj, void *opaque)
>>>>> +{
>>>>> +    char *mem_path;
>>>>> +    long *hpsize_min = opaque;
>>>>> +
>>>>> +    if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) {
>>>>> +        mem_path = object_property_get_str(obj, "mem-path", NULL);
>>>>> +        if (mem_path) {
>>>>> +            long hpsize = qemu_mempath_getpagesize(mem_path);
>>>>> +            if (hpsize < *hpsize_min) {
>>>>> +                *hpsize_min = hpsize;
>>>>> +            }
>>>>> +        } else {
>>>>> +            *hpsize_min = getpagesize();
>>>>> +        }
>>>>> +    }
>>>>> +
>>>>> +    return 0;
>>>>> +}
>>>>> +
>>>>> +long qemu_getrampagesize(void)
>>>>> +{
>>>>> +    long hpsize = LONG_MAX;
>>>>> +    long mainrampagesize;
>>>>> +    Object *memdev_root;
>>>>> +
>>>>> +    if (mem_path) {
>>>>> +        mainrampagesize = qemu_mempath_getpagesize(mem_path);
>>>>> +    } else {
>>>>> +        mainrampagesize = getpagesize();
>>>>> +    }
>>>>> +
>>>>> +    /* it's possible we have memory-backend objects with
>>>>> +     * hugepage-backed RAM. these may get mapped into system
>>>>> +     * address space via -numa parameters or memory hotplug
>>>>> +     * hooks. we want to take these into account, but we
>>>>> +     * also want to make sure these supported hugepage
>>>>> +     * sizes are applicable across the entire range of memory
>>>>> +     * we may boot from, so we take the min across all
>>>>> +     * backends, and assume normal pages in cases where a
>>>>> +     * backend isn't backed by hugepages.
>>>>> +     */
>>>>> +    memdev_root = object_resolve_path("/objects", NULL);
>>>>> +    if (memdev_root) {
>>>>> +        object_child_foreach(memdev_root, find_max_supported_pagesize, &hpsize);
>>>>> +    }
>>>>> +    if (hpsize == LONG_MAX) {
>>>>> +        /* No additional memory regions found ==> Report main RAM page size */
>>>>> +        return mainrampagesize;
>>>>> +    }
>>>>> +
>>>>> +    /* If NUMA is disabled or the NUMA nodes are not backed with a
>>>>> +     * memory-backend, then there is at least one node using "normal" RAM,
>>>>> +     * so if its page size is smaller we have got to report that size instead.
>>>>> +     */
>>>>> +    if (hpsize > mainrampagesize &&
>>>>> +        (nb_numa_nodes == 0 || numa_info[0].node_memdev == NULL)) {
>>>>> +        static bool warned;
>>>>> +        if (!warned) {
>>>>> +            error_report("Huge page support disabled (n/a for main memory).");
>>>>> +            warned = true;
>>>>> +        }
>>>>> +        return mainrampagesize;
>>>>> +    }
>>>>> +
>>>>> +    return hpsize;
>>>>> +}
>>>>> +#else
>>>>> +long qemu_getrampagesize(void)
>>>>> +{
>>>>> +    return getpagesize();
>>>>> +}
>>>>> +#endif
>>>>> +
>>>>> +#ifdef __linux__
>>>>>  static int64_t get_file_size(int fd)
>>>>>  {
>>>>>      int64_t size = lseek(fd, 0, SEEK_END);
>>>>> diff --git a/target-ppc/kvm.c b/target-ppc/kvm.c
>>>>> index 6e91a4d8bb..e0abffa8ad 100644
>>>>> --- a/target-ppc/kvm.c
>>>>> +++ b/target-ppc/kvm.c
>>>>> @@ -42,6 +42,7 @@
>>>>>  #include "trace.h"
>>>>>  #include "exec/gdbstub.h"
>>>>>  #include "exec/memattrs.h"
>>>>> +#include "exec/ram_addr.h"
>>>>>  #include "sysemu/hostmem.h"
>>>>>  #include "qemu/cutils.h"
>>>>>  #if defined(TARGET_PPC64)
>>>>> @@ -325,106 +326,6 @@ static void kvm_get_smmu_info(PowerPCCPU *cpu, struct kvm_ppc_smmu_info *info)
>>>>>      kvm_get_fallback_smmu_info(cpu, info);
>>>>>  }
>>>>>  
>>>>> -static long gethugepagesize(const char *mem_path)
>>>>> -{
>>>>> -    struct statfs fs;
>>>>> -    int ret;
>>>>> -
>>>>> -    do {
>>>>> -        ret = statfs(mem_path, &fs);
>>>>> -    } while (ret != 0 && errno == EINTR);
>>>>> -
>>>>> -    if (ret != 0) {
>>>>> -        fprintf(stderr, "Couldn't statfs() memory path: %s\n",
>>>>> -                strerror(errno));
>>>>> -        exit(1);
>>>>> -    }
>>>>> -
>>>>> -#define HUGETLBFS_MAGIC       0x958458f6
>>>>> -
>>>>> -    if (fs.f_type != HUGETLBFS_MAGIC) {
>>>>> -        /* Explicit mempath, but it's ordinary pages */
>>>>> -        return getpagesize();
>>>>> -    }
>>>>> -
>>>>> -    /* It's hugepage, return the huge page size */
>>>>> -    return fs.f_bsize;
>>>>> -}
>>>>> -
>>>>> -/*
>>>>> - * FIXME TOCTTOU: this iterates over memory backends' mem-path, which
>>>>> - * may or may not name the same files / on the same filesystem now as
>>>>> - * when we actually open and map them.  Iterate over the file
>>>>> - * descriptors instead, and use qemu_fd_getpagesize().
>>>>> - */
>>>>> -static int find_max_supported_pagesize(Object *obj, void *opaque)
>>>>> -{
>>>>> -    char *mem_path;
>>>>> -    long *hpsize_min = opaque;
>>>>> -
>>>>> -    if (object_dynamic_cast(obj, TYPE_MEMORY_BACKEND)) {
>>>>> -        mem_path = object_property_get_str(obj, "mem-path", NULL);
>>>>> -        if (mem_path) {
>>>>> -            long hpsize = gethugepagesize(mem_path);
>>>>> -            if (hpsize < *hpsize_min) {
>>>>> -                *hpsize_min = hpsize;
>>>>> -            }
>>>>> -        } else {
>>>>> -            *hpsize_min = getpagesize();
>>>>> -        }
>>>>> -    }
>>>>> -
>>>>> -    return 0;
>>>>> -}
>>>>> -
>>>>> -static long getrampagesize(void)
>>>>> -{
>>>>> -    long hpsize = LONG_MAX;
>>>>> -    long mainrampagesize;
>>>>> -    Object *memdev_root;
>>>>> -
>>>>> -    if (mem_path) {
>>>>> -        mainrampagesize = gethugepagesize(mem_path);
>>>>> -    } else {
>>>>> -        mainrampagesize = getpagesize();
>>>>> -    }
>>>>> -
>>>>> -    /* it's possible we have memory-backend objects with
>>>>> -     * hugepage-backed RAM. these may get mapped into system
>>>>> -     * address space via -numa parameters or memory hotplug
>>>>> -     * hooks. we want to take these into account, but we
>>>>> -     * also want to make sure these supported hugepage
>>>>> -     * sizes are applicable across the entire range of memory
>>>>> -     * we may boot from, so we take the min across all
>>>>> -     * backends, and assume normal pages in cases where a
>>>>> -     * backend isn't backed by hugepages.
>>>>> -     */
>>>>> -    memdev_root = object_resolve_path("/objects", NULL);
>>>>> -    if (memdev_root) {
>>>>> -        object_child_foreach(memdev_root, find_max_supported_pagesize, &hpsize);
>>>>> -    }
>>>>> -    if (hpsize == LONG_MAX) {
>>>>> -        /* No additional memory regions found ==> Report main RAM page size */
>>>>> -        return mainrampagesize;
>>>>> -    }
>>>>> -
>>>>> -    /* If NUMA is disabled or the NUMA nodes are not backed with a
>>>>> -     * memory-backend, then there is at least one node using "normal" RAM,
>>>>> -     * so if its page size is smaller we have got to report that size instead.
>>>>> -     */
>>>>> -    if (hpsize > mainrampagesize &&
>>>>> -        (nb_numa_nodes == 0 || numa_info[0].node_memdev == NULL)) {
>>>>> -        static bool warned;
>>>>> -        if (!warned) {
>>>>> -            error_report("Huge page support disabled (n/a for main memory).");
>>>>> -            warned = true;
>>>>> -        }
>>>>> -        return mainrampagesize;
>>>>> -    }
>>>>> -
>>>>> -    return hpsize;
>>>>> -}
>>>>> -
>>>>>  static bool kvm_valid_page_size(uint32_t flags, long rampgsize, uint32_t shift)
>>>>>  {
>>>>>      if (!(flags & KVM_PPC_PAGE_SIZES_REAL)) {
>>>>> @@ -454,7 +355,7 @@ static void kvm_fixup_page_sizes(PowerPCCPU *cpu)
>>>>>          has_smmu_info = true;
>>>>>      }
>>>>>  
>>>>> -    rampagesize = getrampagesize();
>>>>> +    rampagesize = qemu_getrampagesize();
>>>>>  
>>>>>      /* Convert to QEMU form */
>>>>>      memset(&env->sps, 0, sizeof(env->sps));
>>>>> @@ -2177,7 +2078,7 @@ uint64_t kvmppc_rma_size(uint64_t current_size, unsigned int hash_shift)
>>>>>      /* Find the largest hardware supported page size that's less than
>>>>>       * or equal to the (logical) backing page size of guest RAM */
>>>>>      kvm_get_smmu_info(POWERPC_CPU(first_cpu), &info);
>>>>> -    rampagesize = getrampagesize();
>>>>> +    rampagesize = qemu_getrampagesize();
>>>>>      best_page_shift = 0;
>>>>>  
>>>>>      for (i = 0; i < KVM_PPC_PAGE_SIZES_MAX_SZ; i++) {
>>>>> diff --git a/util/mmap-alloc.c b/util/mmap-alloc.c
>>>>> index 5a85aa3c89..564c79109c 100644
>>>>> --- a/util/mmap-alloc.c
>>>>> +++ b/util/mmap-alloc.c
>>>>> @@ -39,6 +39,31 @@ size_t qemu_fd_getpagesize(int fd)
>>>>>      return getpagesize();
>>>>>  }
>>>>>  
>>>>> +size_t qemu_mempath_getpagesize(const char *mem_path)
>>>>> +{
>>>>> +#ifdef CONFIG_LINUX
>>>>> +    struct statfs fs;
>>>>> +    int ret;
>>>>> +
>>>>> +    do {
>>>>> +        ret = statfs(mem_path, &fs);
>>>>> +    } while (ret != 0 && errno == EINTR);
>>>>> +
>>>>> +    if (ret != 0) {
>>>>> +        fprintf(stderr, "Couldn't statfs() memory path: %s\n",
>>>>> +                strerror(errno));
>>>>> +        exit(1);
>>>>> +    }
>>>>> +
>>>>> +    if (fs.f_type == HUGETLBFS_MAGIC) {
>>>>> +        /* It's hugepage, return the huge page size */
>>>>> +        return fs.f_bsize;
>>>>> +    }
>>>>> +#endif
>>>>> +
>>>>> +    return getpagesize();
>>>>> +}
>>>>> +
>>>>>  void *qemu_ram_mmap(int fd, size_t size, size_t align, bool shared)
>>>>>  {
>>>>>      /*
>>>>
>>>
>>>
>>
> 
> 
> 
> 


-- 
Alexey


[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 839 bytes --]

Re: [Qemu-devel] [PATCH qemu 1/2] exec, kvm, target-ppc: Move getrampagesize() to common code

[David Gibson]

[-- Attachment #1: Type: text/plain, Size: 1869 bytes --]

On Tue, Feb 28, 2017 at 07:12:53PM +1100, Alexey Kardashevskiy wrote:
> On 10/02/17 11:41, David Gibson wrote:
> > On Thu, Feb 09, 2017 at 12:48:19PM +0100, Paolo Bonzini wrote:
> >>
> >>
> >> On 09/02/2017 06:43, Alexey Kardashevskiy wrote:
> >>> On 03/01/17 10:34, David Gibson wrote:
> >>>> On Thu, Dec 22, 2016 at 04:22:11PM +1100, Alexey Kardashevskiy wrote:
> >>>>> getrampagesize() returns the largest supported page size and mainly
> >>>>> used to know if huge pages are enabled.
> >>>>>
> >>>>> However is implemented in target-ppc/kvm.c and not available
> >>>>> in TCG or other architectures.
> >>>>>
> >>>>> This renames and moves gethugepagesize() to mmap-alloc.c where
> >>>>> fd-based analog of it is already implemented. This renames and moves
> >>>>> getrampagesize() to exec.c as it seems to be the common place for
> >>>>> helpers like this.
> >>>>>
> >>>>> This first user for it is going to be a spapr-pci-host-bridge which
> >>>>> needs to know the largest RAM page size so the guest could try
> >>>>> using bigger IOMMU pages to save memory.
> >>>>>
> >>>>> Signed-off-by: Alexey Kardashevskiy <aik@ozlabs.ru>
> >>>>
> >>>> Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
> >>>>
> >>>> Seems sensible to me, but I'm not comfortable merging this via my tree
> >>>> since it touches such core code.  Probably should go via Paolo.
> >>>
> >>> Paolo, ping?
> >>
> >> It's just code movement, go ahead.
> > 
> > Ok, I've merged this in my tree.
> 
> 
> I cannot find it in any public tree, where did it go?

Bother, I thought I'd applied it, but I seem to have mislaid it.  Can
you resend it to me please.

-- 
David Gibson			| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you.  NOT _the_ _other_
				| _way_ _around_!
http://www.ozlabs.org/~dgibson

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 819 bytes --]

Re: [Qemu-devel] [PATCH qemu 1/2] exec, kvm, target-ppc: Move getrampagesize() to common code

[David Gibson]

[-- Attachment #1: Type: text/plain, Size: 2203 bytes --]

On Wed, Mar 01, 2017 at 12:06:14PM +1100, David Gibson wrote:
> On Tue, Feb 28, 2017 at 07:12:53PM +1100, Alexey Kardashevskiy wrote:
> > On 10/02/17 11:41, David Gibson wrote:
> > > On Thu, Feb 09, 2017 at 12:48:19PM +0100, Paolo Bonzini wrote:
> > >>
> > >>
> > >> On 09/02/2017 06:43, Alexey Kardashevskiy wrote:
> > >>> On 03/01/17 10:34, David Gibson wrote:
> > >>>> On Thu, Dec 22, 2016 at 04:22:11PM +1100, Alexey Kardashevskiy wrote:
> > >>>>> getrampagesize() returns the largest supported page size and mainly
> > >>>>> used to know if huge pages are enabled.
> > >>>>>
> > >>>>> However is implemented in target-ppc/kvm.c and not available
> > >>>>> in TCG or other architectures.
> > >>>>>
> > >>>>> This renames and moves gethugepagesize() to mmap-alloc.c where
> > >>>>> fd-based analog of it is already implemented. This renames and moves
> > >>>>> getrampagesize() to exec.c as it seems to be the common place for
> > >>>>> helpers like this.
> > >>>>>
> > >>>>> This first user for it is going to be a spapr-pci-host-bridge which
> > >>>>> needs to know the largest RAM page size so the guest could try
> > >>>>> using bigger IOMMU pages to save memory.
> > >>>>>
> > >>>>> Signed-off-by: Alexey Kardashevskiy <aik@ozlabs.ru>
> > >>>>
> > >>>> Reviewed-by: David Gibson <david@gibson.dropbear.id.au>
> > >>>>
> > >>>> Seems sensible to me, but I'm not comfortable merging this via my tree
> > >>>> since it touches such core code.  Probably should go via Paolo.
> > >>>
> > >>> Paolo, ping?
> > >>
> > >> It's just code movement, go ahead.
> > > 
> > > Ok, I've merged this in my tree.
> > 
> > 
> > I cannot find it in any public tree, where did it go?
> 
> Bother, I thought I'd applied it, but I seem to have mislaid it.  Can
> you resend it to me please.

So, I manage to dig this up from my archives, but it doesn't seem to
apply properly on the current tree.  The actual merge conflicts were
easy to resolve, but then it doesn't compile.

-- 
David Gibson			| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you.  NOT _the_ _other_
				| _way_ _around_!
http://www.ozlabs.org/~dgibson

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 819 bytes --]

[Qemu-devel] [PATCH qemu 2/2] spapr_pci: Advertise 16M IOMMU pages when available

[Alexey Kardashevskiy]

On sPAPR, IOMMU page size varies and if QEMU is running with RAM
backed with hugepages, we can advertise this to the guest so does
this patch.

Signed-off-by: Alexey Kardashevskiy <aik@ozlabs.ru>
---
 hw/ppc/spapr_pci.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/hw/ppc/spapr_pci.c b/hw/ppc/spapr_pci.c
index fd6fc1d953..09244056fc 100644
--- a/hw/ppc/spapr_pci.c
+++ b/hw/ppc/spapr_pci.c
@@ -1505,6 +1505,9 @@ static void spapr_phb_realize(DeviceState *dev, Error **errp)
     }
 
     /* DMA setup */
+    /* This allows huge pages for IOMMU when guest is backed with huge pages */
+    sphb->page_size_mask |= qemu_getrampagesize();
+
     for (i = 0; i < windows_supported; ++i) {
         tcet = spapr_tce_new_table(DEVICE(sphb), sphb->dma_liobn[i]);
         if (!tcet) {
-- 
2.11.0

Re: [Qemu-devel] [PATCH qemu 2/2] spapr_pci: Advertise 16M IOMMU pages when available

[David Gibson]

[-- Attachment #1: Type: text/plain, Size: 1833 bytes --]

On Thu, Dec 22, 2016 at 04:22:12PM +1100, Alexey Kardashevskiy wrote:
> On sPAPR, IOMMU page size varies and if QEMU is running with RAM
> backed with hugepages, we can advertise this to the guest so does
> this patch.
> 
> Signed-off-by: Alexey Kardashevskiy <aik@ozlabs.ru>
> ---
>  hw/ppc/spapr_pci.c | 3 +++
>  1 file changed, 3 insertions(+)
> 
> diff --git a/hw/ppc/spapr_pci.c b/hw/ppc/spapr_pci.c
> index fd6fc1d953..09244056fc 100644
> --- a/hw/ppc/spapr_pci.c
> +++ b/hw/ppc/spapr_pci.c
> @@ -1505,6 +1505,9 @@ static void spapr_phb_realize(DeviceState *dev, Error **errp)
>      }
>  
>      /* DMA setup */
> +    /* This allows huge pages for IOMMU when guest is backed with huge pages */
> +    sphb->page_size_mask |= qemu_getrampagesize();

This doesn't look right - you're unconditionally enabling the host ram
page size, regardless of anything else.  Instead the backing page size
should be used to filter out those sizes which are possible from the
list of those supported by the guest hardware.  This patch will give
particularly odd results if you ran it on x86 with hugepages for
example: it would advertise a 2M IOMMU page size, which could never
exist on native POWER.

Except... come to think of it, why is the backing RAM page size
relevant at all?  Or rather.. I think VFIO should be able to cope with
any guest IOMMU page size which is larger than the host ram page size
(although if it's much larger it could get expensive in the host
tables).  This case would already be routine for ppc64 on x86, where
the guest IOMMU page size is 64kiB, but the host page size is 4 kiB.

-- 
David Gibson			| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you.  NOT _the_ _other_
				| _way_ _around_!
http://www.ozlabs.org/~dgibson

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 819 bytes --]

Re: [Qemu-devel] [PATCH qemu 2/2] spapr_pci: Advertise 16M IOMMU pages when available

[Alexey Kardashevskiy]

[-- Attachment #1: Type: text/plain, Size: 2391 bytes --]

On 03/01/17 10:41, David Gibson wrote:
> On Thu, Dec 22, 2016 at 04:22:12PM +1100, Alexey Kardashevskiy wrote:
>> On sPAPR, IOMMU page size varies and if QEMU is running with RAM
>> backed with hugepages, we can advertise this to the guest so does
>> this patch.
>>
>> Signed-off-by: Alexey Kardashevskiy <aik@ozlabs.ru>
>> ---
>>  hw/ppc/spapr_pci.c | 3 +++
>>  1 file changed, 3 insertions(+)
>>
>> diff --git a/hw/ppc/spapr_pci.c b/hw/ppc/spapr_pci.c
>> index fd6fc1d953..09244056fc 100644
>> --- a/hw/ppc/spapr_pci.c
>> +++ b/hw/ppc/spapr_pci.c
>> @@ -1505,6 +1505,9 @@ static void spapr_phb_realize(DeviceState *dev, Error **errp)
>>      }
>>  
>>      /* DMA setup */
>> +    /* This allows huge pages for IOMMU when guest is backed with huge pages */
>> +    sphb->page_size_mask |= qemu_getrampagesize();
> 
> This doesn't look right - you're unconditionally enabling the host ram
> page size, regardless of anything else.  Instead the backing page size
> should be used to filter out those sizes which are possible from the
> list of those supported by the guest hardware.  This patch will give
> particularly odd results if you ran it on x86 with hugepages for
> example: it would advertise a 2M IOMMU page size, which could never
> exist on native POWER.

Ok, I'll filter 16M out if passed to PHB and not supported by the host.


> Except... come to think of it, why is the backing RAM page size
> relevant at all? 

Because this is just an optimization/acceleration and I'd think the user
wants to know if it is actually accelerated or not. If I always allow 16M
pages, and QEMU is not backed with hugepages, then all H_PUT_TCE will go
via slow path and consume as much memory for TCE as without hugepages, and
it will only be visible to the user if TCE-tracepoints are enabled.

> Or rather.. I think VFIO should be able to cope with
> any guest IOMMU page size which is larger than the host ram page size

It could, I just do not see much benefit in it. pseries guest can negotiate
4k, 64k, 16m pages and this seems to cover everything we want, why would we
want to emulate IOMMU page size?

> (although if it's much larger it could get expensive in the host
> tables).  This case would already be routine for ppc64 on x86, where
> the guest IOMMU page size is 64kiB, but the host page size is 4 kiB.




-- 
Alexey


[-- Attachment #2: OpenPGP digital signature --]
[-- Type: application/pgp-signature, Size: 839 bytes --]

Re: [Qemu-devel] [PATCH qemu 2/2] spapr_pci: Advertise 16M IOMMU pages when available

[David Gibson]

[-- Attachment #1: Type: text/plain, Size: 2830 bytes --]

On Mon, Jan 09, 2017 at 01:06:03PM +1100, Alexey Kardashevskiy wrote:
> On 03/01/17 10:41, David Gibson wrote:
> > On Thu, Dec 22, 2016 at 04:22:12PM +1100, Alexey Kardashevskiy wrote:
> >> On sPAPR, IOMMU page size varies and if QEMU is running with RAM
> >> backed with hugepages, we can advertise this to the guest so does
> >> this patch.
> >>
> >> Signed-off-by: Alexey Kardashevskiy <aik@ozlabs.ru>
> >> ---
> >>  hw/ppc/spapr_pci.c | 3 +++
> >>  1 file changed, 3 insertions(+)
> >>
> >> diff --git a/hw/ppc/spapr_pci.c b/hw/ppc/spapr_pci.c
> >> index fd6fc1d953..09244056fc 100644
> >> --- a/hw/ppc/spapr_pci.c
> >> +++ b/hw/ppc/spapr_pci.c
> >> @@ -1505,6 +1505,9 @@ static void spapr_phb_realize(DeviceState *dev, Error **errp)
> >>      }
> >>  
> >>      /* DMA setup */
> >> +    /* This allows huge pages for IOMMU when guest is backed with huge pages */
> >> +    sphb->page_size_mask |= qemu_getrampagesize();
> > 
> > This doesn't look right - you're unconditionally enabling the host ram
> > page size, regardless of anything else.  Instead the backing page size
> > should be used to filter out those sizes which are possible from the
> > list of those supported by the guest hardware.  This patch will give
> > particularly odd results if you ran it on x86 with hugepages for
> > example: it would advertise a 2M IOMMU page size, which could never
> > exist on native POWER.
> 
> Ok, I'll filter 16M out if passed to PHB and not supported by the host.
> 
> 
> > Except... come to think of it, why is the backing RAM page size
> > relevant at all? 
> 
> Because this is just an optimization/acceleration and I'd think the user
> wants to know if it is actually accelerated or not. If I always allow 16M
> pages, and QEMU is not backed with hugepages, then all H_PUT_TCE will go
> via slow path and consume as much memory for TCE as without hugepages, and
> it will only be visible to the user if TCE-tracepoints are enabled.

Hm, ok, fair enough.

> > Or rather.. I think VFIO should be able to cope with
> > any guest IOMMU page size which is larger than the host ram page size
> 
> It could, I just do not see much benefit in it. pseries guest can negotiate
> 4k, 64k, 16m pages and this seems to cover everything we want, why would we
> want to emulate IOMMU page size?

Just for testing or debugging, I suppose.

> 
> > (although if it's much larger it could get expensive in the host
> > tables).  This case would already be routine for ppc64 on x86, where
> > the guest IOMMU page size is 64kiB, but the host page size is 4 kiB.
> 
> 
> 
> 




-- 
David Gibson			| I'll have my music baroque, and my code
david AT gibson.dropbear.id.au	| minimalist, thank you.  NOT _the_ _other_
				| _way_ _around_!
http://www.ozlabs.org/~dgibson

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 819 bytes --]