xen: Allow NUMA node to be specific to alloc_domheap_pages() via a new

MEMF_node() sub-flag type.

Signed-off-by: Andre Przywara <andre.przywara@amd.com>
Signed-off-by: Keir Fraser <keir.fraser@citrix.com>

diff --git a/xen/arch/ia64/xen/mm.c b/xen/arch/ia64/xen/mm.c
index d51912fc213bc0e7bcb079d53fca695e06de7394..15057ba2ebce74dc553ff8c416c041f31a24320b 100644 (file)
--- a/xen/arch/ia64/xen/mm.c
+++ b/xen/arch/ia64/xen/mm.c
@@ -820,7 +820,7 @@ __assign_new_domain_page(struct domain *d, unsigned long mpaddr,
 
     BUG_ON(!pte_none(*pte));
 
-    p = alloc_domheap_page(d);
+    p = alloc_domheap_page(d, 0);
     if (unlikely(!p)) {
         printk("assign_new_domain_page: Can't alloc!!!! Aaaargh!\n");
         return(p);
@@ -2315,7 +2315,7 @@ steal_page(struct domain *d, struct page_info *page, unsigned int memflags)
         unsigned long new_mfn;
         int ret;
 
-        new = alloc_domheap_page(d);
+        new = alloc_domheap_page(d, 0);
         if (new == NULL) {
             gdprintk(XENLOG_INFO, "alloc_domheap_page() failed\n");
             return -1;
@@ -2602,7 +2602,7 @@ void *pgtable_quicklist_alloc(void)
 
     BUG_ON(dom_p2m == NULL);
     if (!opt_p2m_xenheap) {
-        struct page_info *page = alloc_domheap_page(dom_p2m);
+        struct page_info *page = alloc_domheap_page(dom_p2m, 0);
         if (page == NULL)
             return NULL;
         p = page_to_virt(page);

diff --git a/xen/arch/ia64/xen/tlb_track.c b/xen/arch/ia64/xen/tlb_track.c
index 50ef0848180320f03173288760855b43251629af..d9e30a2db561b62cedd5b63c5feaaa84c0fbd5c4 100644 (file)
--- a/xen/arch/ia64/xen/tlb_track.c
+++ b/xen/arch/ia64/xen/tlb_track.c
@@ -48,7 +48,7 @@ tlb_track_allocate_entries(struct tlb_track* tlb_track)
                 __func__, tlb_track->num_entries, tlb_track->limit);
         return -ENOMEM;
     }
-    entry_page = alloc_domheap_page(NULL);
+    entry_page = alloc_domheap_page(NULL, 0);
     if (entry_page == NULL) {
         dprintk(XENLOG_WARNING,
                 "%s: domheap page failed. num_entries %d limit %d\n",
@@ -84,7 +84,7 @@ tlb_track_create(struct domain* d)
     if (tlb_track == NULL)
         goto out;
 
-    hash_page = alloc_domheap_page(NULL);
+    hash_page = alloc_domheap_page(NULL, 0);
     if (hash_page == NULL)
         goto out;
 

diff --git a/xen/arch/x86/domain.c b/xen/arch/x86/domain.c
index c56db37b37f8351144d2dc535b95a235433288a8..4dd58809a84d2067bfa1be38b710a5375fca705f 100644 (file)
--- a/xen/arch/x86/domain.c
+++ b/xen/arch/x86/domain.c
@@ -46,6 +46,7 @@
 #include <asm/debugreg.h>
 #include <asm/msr.h>
 #include <asm/nmi.h>
+#include <xen/numa.h>
 #include <xen/iommu.h>
 #ifdef CONFIG_COMPAT
 #include <compat/vcpu.h>
@@ -171,7 +172,7 @@ int setup_arg_xlat_area(struct vcpu *v, l4_pgentry_t *l4tab)
 
     if ( !d->arch.mm_arg_xlat_l3 )
     {
-        pg = alloc_domheap_page(NULL);
+        pg = alloc_domheap_page(NULL, 0);
         if ( !pg )
             return -ENOMEM;
         d->arch.mm_arg_xlat_l3 = page_to_virt(pg);
@@ -189,7 +190,7 @@ int setup_arg_xlat_area(struct vcpu *v, l4_pgentry_t *l4tab)
 
         if ( !l3e_get_intpte(d->arch.mm_arg_xlat_l3[l3_table_offset(va)]) )
         {
-            pg = alloc_domheap_page(NULL);
+            pg = alloc_domheap_page(NULL, 0);
             if ( !pg )
                 return -ENOMEM;
             clear_page(page_to_virt(pg));
@@ -198,7 +199,7 @@ int setup_arg_xlat_area(struct vcpu *v, l4_pgentry_t *l4tab)
         l2tab = l3e_to_l2e(d->arch.mm_arg_xlat_l3[l3_table_offset(va)]);
         if ( !l2e_get_intpte(l2tab[l2_table_offset(va)]) )
         {
-            pg = alloc_domheap_page(NULL);
+            pg = alloc_domheap_page(NULL, 0);
             if ( !pg )
                 return -ENOMEM;
             clear_page(page_to_virt(pg));
@@ -206,7 +207,7 @@ int setup_arg_xlat_area(struct vcpu *v, l4_pgentry_t *l4tab)
         }
         l1tab = l2e_to_l1e(l2tab[l2_table_offset(va)]);
         BUG_ON(l1e_get_intpte(l1tab[l1_table_offset(va)]));
-        pg = alloc_domheap_page(NULL);
+        pg = alloc_domheap_page(NULL, 0);
         if ( !pg )
             return -ENOMEM;
         l1tab[l1_table_offset(va)] = l1e_from_page(pg, PAGE_HYPERVISOR);
@@ -252,7 +253,7 @@ static void release_arg_xlat_area(struct domain *d)
 
 static int setup_compat_l4(struct vcpu *v)
 {
-    struct page_info *pg = alloc_domheap_page(NULL);
+    struct page_info *pg = alloc_domheap_page(NULL, 0);
     l4_pgentry_t *l4tab;
     int rc;
 
@@ -477,7 +478,8 @@ int arch_domain_create(struct domain *d, unsigned int domcr_flags)
 
 #else /* __x86_64__ */
 
-    if ( (pg = alloc_domheap_page(NULL)) == NULL )
+    pg = alloc_domheap_page(NULL, MEMF_node(domain_to_node(d)));
+    if ( pg == NULL )
         goto fail;
     d->arch.mm_perdomain_l2 = page_to_virt(pg);
     clear_page(d->arch.mm_perdomain_l2);
@@ -486,7 +488,8 @@ int arch_domain_create(struct domain *d, unsigned int domcr_flags)
             l2e_from_page(virt_to_page(d->arch.mm_perdomain_pt)+i,
                           __PAGE_HYPERVISOR);
 
-    if ( (pg = alloc_domheap_page(NULL)) == NULL )
+    pg = alloc_domheap_page(NULL, MEMF_node(domain_to_node(d)));
+    if ( pg == NULL )
         goto fail;
     d->arch.mm_perdomain_l3 = page_to_virt(pg);
     clear_page(d->arch.mm_perdomain_l3);

diff --git a/xen/arch/x86/domain_build.c b/xen/arch/x86/domain_build.c
index dc8ee52f075f39dff8b71f93e70305b3e09c8920..f37146bb4621d61dacf63848d0a23d396412eb21 100644 (file)
--- a/xen/arch/x86/domain_build.c
+++ b/xen/arch/x86/domain_build.c
@@ -630,7 +630,7 @@ int __init construct_dom0(
     }
     else
     {
-        page = alloc_domheap_page(NULL);
+        page = alloc_domheap_page(NULL, 0);
         if ( !page )
             panic("Not enough RAM for domain 0 PML4.\n");
         l4start = l4tab = page_to_virt(page);

diff --git a/xen/arch/x86/hvm/stdvga.c b/xen/arch/x86/hvm/stdvga.c
index 56260c5c771f904bc25531d9b02b91ffa6d833bd..514444cc34279fe7cbe1a8139c318428d7fda4de 100644 (file)
--- a/xen/arch/x86/hvm/stdvga.c
+++ b/xen/arch/x86/hvm/stdvga.c
@@ -32,6 +32,7 @@
 #include <xen/sched.h>
 #include <xen/domain_page.h>
 #include <asm/hvm/support.h>
+#include <xen/numa.h>
 
 #define PAT(x) (x)
 static const uint32_t mask16[16] = {
@@ -513,7 +514,8 @@ void stdvga_init(struct domain *d)
     
     for ( i = 0; i != ARRAY_SIZE(s->vram_page); i++ )
     {
-        if ( (pg = alloc_domheap_page(NULL)) == NULL )
+        pg = alloc_domheap_page(NULL, MEMF_node(domain_to_node(d)));
+        if ( pg == NULL )
             break;
         s->vram_page[i] = pg;
         p = map_domain_page(page_to_mfn(pg));

diff --git a/xen/arch/x86/hvm/vlapic.c b/xen/arch/x86/hvm/vlapic.c
index bf53ba7a1ac6f17467901b9027cc94bfe1301ac4..0867fb74044380f537bf7c11d441cfbfd8fecd77 100644 (file)
--- a/xen/arch/x86/hvm/vlapic.c
+++ b/xen/arch/x86/hvm/vlapic.c
@@ -33,6 +33,7 @@
 #include <xen/sched.h>
 #include <asm/current.h>
 #include <asm/hvm/vmx/vmx.h>
+#include <xen/numa.h>
 #include <public/hvm/ioreq.h>
 #include <public/hvm/params.h>
 
@@ -916,7 +917,7 @@ HVM_REGISTER_SAVE_RESTORE(LAPIC_REGS, lapic_save_regs, lapic_load_regs,
 int vlapic_init(struct vcpu *v)
 {
     struct vlapic *vlapic = vcpu_vlapic(v);
-    unsigned int memflags = 0;
+    unsigned int memflags = MEMF_node(vcpu_to_node(v));
 
     HVM_DBG_LOG(DBG_LEVEL_VLAPIC, "%d", v->vcpu_id);
 
@@ -925,10 +926,10 @@ int vlapic_init(struct vcpu *v)
 #ifdef __i386__
     /* 32-bit VMX may be limited to 32-bit physical addresses. */
     if ( boot_cpu_data.x86_vendor == X86_VENDOR_INTEL )
-        memflags = MEMF_bits(32);
+        memflags |= MEMF_bits(32);
 #endif
 
-    vlapic->regs_page = alloc_domheap_pages(NULL, 0, memflags);
+    vlapic->regs_page = alloc_domheap_page(NULL, memflags);
     if ( vlapic->regs_page == NULL )
     {
         dprintk(XENLOG_ERR, "alloc vlapic regs error: %d/%d\n",
@@ -941,7 +942,7 @@ int vlapic_init(struct vcpu *v)
     {
         dprintk(XENLOG_ERR, "map vlapic regs error: %d/%d\n",
                 v->domain->domain_id, v->vcpu_id);
-       return -ENOMEM;
+        return -ENOMEM;
     }
 
     clear_page(vlapic->regs);

diff --git a/xen/arch/x86/mm/hap/hap.c b/xen/arch/x86/mm/hap/hap.c
index 15cdc23c960c99b62e4aaeb8ec4b18b653a841ab..b8e608f3a9c2e2f0f4c06788380447cb9c90a527 100644 (file)
--- a/xen/arch/x86/mm/hap/hap.c
+++ b/xen/arch/x86/mm/hap/hap.c
@@ -38,6 +38,7 @@
 #include <asm/hap.h>
 #include <asm/paging.h>
 #include <asm/domain.h>
+#include <xen/numa.h>
 
 #include "private.h"
 
@@ -135,7 +136,8 @@ static struct page_info *hap_alloc_p2m_page(struct domain *d)
          && mfn_x(page_to_mfn(pg)) >= (1UL << (32 - PAGE_SHIFT)) )
     {
         free_domheap_page(pg);
-        pg = alloc_domheap_pages(NULL, 0, MEMF_bits(32));
+        pg = alloc_domheap_page(
+            NULL, MEMF_bits(32) | MEMF_node(domain_to_node(d)));
         if ( likely(pg != NULL) )
         {
             void *p = hap_map_domain_page(page_to_mfn(pg));
@@ -199,7 +201,7 @@ hap_set_allocation(struct domain *d, unsigned int pages, int *preempted)
         if ( d->arch.paging.hap.total_pages < pages )
         {
             /* Need to allocate more memory from domheap */
-            pg = alloc_domheap_page(NULL);
+            pg = alloc_domheap_page(NULL, MEMF_node(domain_to_node(d)));
             if ( pg == NULL )
             {
                 HAP_PRINTK("failed to allocate hap pages.\n");

diff --git a/xen/arch/x86/mm/paging.c b/xen/arch/x86/mm/paging.c
index e6c3cbb9e6ac7f77914464930ff8b0cd60835b78..f310c0facdd78ebd8d2e133f6ef3ea05d24a31dc 100644 (file)
--- a/xen/arch/x86/mm/paging.c
+++ b/xen/arch/x86/mm/paging.c
@@ -26,6 +26,7 @@
 #include <asm/p2m.h>
 #include <asm/hap.h>
 #include <asm/guest_access.h>
+#include <xen/numa.h>
 #include <xsm/xsm.h>
 
 #define hap_enabled(d) (is_hvm_domain(d) && (d)->arch.hvm_domain.hap_enabled)
@@ -99,8 +100,9 @@
 static mfn_t paging_new_log_dirty_page(struct domain *d, void **mapping_p)
 {
     mfn_t mfn;
-    struct page_info *page = alloc_domheap_page(NULL);
+    struct page_info *page;
 
+    page = alloc_domheap_page(NULL, MEMF_node(domain_to_node(d)));
     if ( unlikely(page == NULL) )
     {
         d->arch.paging.log_dirty.failed_allocs++;

diff --git a/xen/arch/x86/mm/shadow/common.c b/xen/arch/x86/mm/shadow/common.c
index e4a04bb45664d6c5b7ed66a1391b4fcde23ca0d3..1816fe397be03c5516b77d43bc35338781852d0f 100644 (file)
--- a/xen/arch/x86/mm/shadow/common.c
+++ b/xen/arch/x86/mm/shadow/common.c
@@ -36,6 +36,7 @@
 #include <asm/current.h>
 #include <asm/flushtlb.h>
 #include <asm/shadow.h>
+#include <xen/numa.h>
 #include "private.h"
 
 
@@ -1249,7 +1250,7 @@ static unsigned int sh_set_allocation(struct domain *d,
         {
             /* Need to allocate more memory from domheap */
             sp = (struct shadow_page_info *)
-                alloc_domheap_pages(NULL, order, 0);
+                alloc_domheap_pages(NULL, order, MEMF_node(domain_to_node(d)));
             if ( sp == NULL ) 
             { 
                 SHADOW_PRINTK("failed to allocate shadow pages.\n");

diff --git a/xen/arch/x86/x86_64/mm.c b/xen/arch/x86/x86_64/mm.c
index f9f33e0a88a4a1aeb668682b88bbca2bc2491886..3d796579890953249cb18e17cd09879f3c24129a 100644 (file)
--- a/xen/arch/x86/x86_64/mm.c
+++ b/xen/arch/x86/x86_64/mm.c
@@ -59,7 +59,7 @@ void *alloc_xen_pagetable(void)
 
     if ( !early_boot )
     {
-        struct page_info *pg = alloc_domheap_page(NULL);
+        struct page_info *pg = alloc_domheap_page(NULL, 0);
         BUG_ON(pg == NULL);
         return page_to_virt(pg);
     }
@@ -108,7 +108,7 @@ void __init paging_init(void)
     struct page_info *l1_pg, *l2_pg, *l3_pg;
 
     /* Create user-accessible L2 directory to map the MPT for guests. */
-    if ( (l3_pg = alloc_domheap_page(NULL)) == NULL )
+    if ( (l3_pg = alloc_domheap_page(NULL, 0)) == NULL )
         goto nomem;
     l3_ro_mpt = page_to_virt(l3_pg);
     clear_page(l3_ro_mpt);
@@ -134,7 +134,7 @@ void __init paging_init(void)
                1UL << L2_PAGETABLE_SHIFT);
         if ( !((unsigned long)l2_ro_mpt & ~PAGE_MASK) )
         {
-            if ( (l2_pg = alloc_domheap_page(NULL)) == NULL )
+            if ( (l2_pg = alloc_domheap_page(NULL, 0)) == NULL )
                 goto nomem;
             va = RO_MPT_VIRT_START + (i << L2_PAGETABLE_SHIFT);
             l2_ro_mpt = page_to_virt(l2_pg);
@@ -154,7 +154,7 @@ void __init paging_init(void)
                  l4_table_offset(HIRO_COMPAT_MPT_VIRT_START));
     l3_ro_mpt = l4e_to_l3e(idle_pg_table[l4_table_offset(
         HIRO_COMPAT_MPT_VIRT_START)]);
-    if ( (l2_pg = alloc_domheap_page(NULL)) == NULL )
+    if ( (l2_pg = alloc_domheap_page(NULL, 0)) == NULL )
         goto nomem;
     compat_idle_pg_table_l2 = l2_ro_mpt = page_to_virt(l2_pg);
     clear_page(l2_ro_mpt);

diff --git a/xen/common/grant_table.c b/xen/common/grant_table.c
index 2dbcfab8b620f861bc116b9b1b1f03b4ec769f22..d582713c7ee66ec22df4eb086fbcd2e833406e66 100644 (file)
--- a/xen/common/grant_table.c
+++ b/xen/common/grant_table.c
@@ -1102,7 +1102,7 @@ gnttab_transfer(
             struct page_info *new_page;
             void *sp, *dp;
 
-            new_page = alloc_domheap_pages(NULL, 0, MEMF_bits(max_bitsize));
+            new_page = alloc_domheap_page(NULL, MEMF_bits(max_bitsize));
             if ( new_page == NULL )
             {
                 gop.status = GNTST_address_too_big;

diff --git a/xen/common/memory.c b/xen/common/memory.c
index 70a05d5367748cf8cb28de2ed1f63651bf4685ae..3e9f7071abaf2ca2a36ce60086e8ec45a4d6d392 100644 (file)
--- a/xen/common/memory.c
+++ b/xen/common/memory.c
@@ -21,6 +21,7 @@
 #include <xen/errno.h>
 #include <asm/current.h>
 #include <asm/hardirq.h>
+#include <xen/numa.h>
 #include <public/memory.h>
 #include <xsm/xsm.h>
 
@@ -37,19 +38,13 @@ struct memop_args {
     int          preempted;  /* Was the hypercall preempted? */
 };
 
-static unsigned int select_local_cpu(struct domain *d)
-{
-    struct vcpu *v = d->vcpu[0];
-    return (v ? v->processor : 0);
-}
-
 static void increase_reservation(struct memop_args *a)
 {
     struct page_info *page;
     unsigned long i;
     xen_pfn_t mfn;
     struct domain *d = a->domain;
-    unsigned int cpu = select_local_cpu(d);
+    unsigned int node = domain_to_node(d);
 
     if ( !guest_handle_is_null(a->extent_list) &&
          !guest_handle_okay(a->extent_list, a->nr_extents) )
@@ -67,7 +62,8 @@ static void increase_reservation(struct memop_args *a)
             goto out;
         }
 
-        page = __alloc_domheap_pages(d, cpu, a->extent_order, a->memflags);
+        page = alloc_domheap_pages(
+            d, a->extent_order, a->memflags | MEMF_node(node));
         if ( unlikely(page == NULL) ) 
         {
             gdprintk(XENLOG_INFO, "Could not allocate order=%d extent: "
@@ -96,7 +92,7 @@ static void populate_physmap(struct memop_args *a)
     unsigned long i, j;
     xen_pfn_t gpfn, mfn;
     struct domain *d = a->domain;
-    unsigned int cpu = select_local_cpu(d);
+    unsigned int node = domain_to_node(d);
 
     if ( !guest_handle_okay(a->extent_list, a->nr_extents) )
         return;
@@ -116,7 +112,8 @@ static void populate_physmap(struct memop_args *a)
         if ( unlikely(__copy_from_guest_offset(&gpfn, a->extent_list, i, 1)) )
             goto out;
 
-        page = __alloc_domheap_pages(d, cpu, a->extent_order, a->memflags);
+        page = alloc_domheap_pages(
+            d, a->extent_order, a->memflags | MEMF_node(node));
         if ( unlikely(page == NULL) ) 
         {
             gdprintk(XENLOG_INFO, "Could not allocate order=%d extent: "
@@ -296,7 +293,7 @@ static long memory_exchange(XEN_GUEST_HANDLE(xen_memory_exchange_t) arg)
     unsigned long in_chunk_order, out_chunk_order;
     xen_pfn_t     gpfn, gmfn, mfn;
     unsigned long i, j, k;
-    unsigned int  memflags = 0, cpu;
+    unsigned int  memflags = 0;
     long          rc = 0;
     struct domain *d;
     struct page_info *page;
@@ -351,8 +348,7 @@ static long memory_exchange(XEN_GUEST_HANDLE(xen_memory_exchange_t) arg)
 
     memflags |= MEMF_bits(domain_clamp_alloc_bitsize(
         d, exch.out.address_bits ? : (BITS_PER_LONG+PAGE_SHIFT)));
-
-    cpu = select_local_cpu(d);
+    memflags |= MEMF_node(domain_to_node(d));
 
     for ( i = (exch.nr_exchanged >> in_chunk_order);
           i < (exch.in.nr_extents >> in_chunk_order);
@@ -401,8 +397,7 @@ static long memory_exchange(XEN_GUEST_HANDLE(xen_memory_exchange_t) arg)
         /* Allocate a chunk's worth of anonymous output pages. */
         for ( j = 0; j < (1UL << out_chunk_order); j++ )
         {
-            page = __alloc_domheap_pages(
-                NULL, cpu, exch.out.extent_order, memflags);
+            page = alloc_domheap_pages(NULL, exch.out.extent_order, memflags);
             if ( unlikely(page == NULL) )
             {
                 rc = -ENOMEM;

diff --git a/xen/common/page_alloc.c b/xen/common/page_alloc.c
index 2d5f3f6da3b931d287b0a5f59579bfdf9f516c9e..d1773c679e76afa1debee87564c5bcecc55845ed 100644 (file)
--- a/xen/common/page_alloc.c
+++ b/xen/common/page_alloc.c
@@ -36,6 +36,7 @@
 #include <xen/numa.h>
 #include <xen/nodemask.h>
 #include <asm/page.h>
+#include <asm/numa.h>
 #include <asm/flushtlb.h>
 
 /*
@@ -328,14 +329,17 @@ static void init_node_heap(int node)
 /* Allocate 2^@order contiguous pages. */
 static struct page_info *alloc_heap_pages(
     unsigned int zone_lo, unsigned int zone_hi,
-    unsigned int cpu, unsigned int order)
+    unsigned int node, unsigned int order)
 {
     unsigned int i, j, zone;
-    unsigned int node = cpu_to_node(cpu), num_nodes = num_online_nodes();
+    unsigned int num_nodes = num_online_nodes();
     unsigned long request = 1UL << order;
     cpumask_t extra_cpus_mask, mask;
     struct page_info *pg;
 
+    if ( node == NUMA_NO_NODE )
+        node = cpu_to_node(smp_processor_id());
+
     ASSERT(node >= 0);
     ASSERT(node < num_nodes);
     ASSERT(zone_lo <= zone_hi);
@@ -670,7 +674,8 @@ void *alloc_xenheap_pages(unsigned int order)
 
     ASSERT(!in_irq());
 
-    pg = alloc_heap_pages(MEMZONE_XEN, MEMZONE_XEN, smp_processor_id(), order);
+    pg = alloc_heap_pages(
+        MEMZONE_XEN, MEMZONE_XEN, cpu_to_node(smp_processor_id()), order);
     if ( unlikely(pg == NULL) )
         goto no_memory;
 
@@ -778,12 +783,12 @@ int assign_pages(
 }
 
 
-struct page_info *__alloc_domheap_pages(
-    struct domain *d, unsigned int cpu, unsigned int order, 
-    unsigned int memflags)
+struct page_info *alloc_domheap_pages(
+    struct domain *d, unsigned int order, unsigned int memflags)
 {
     struct page_info *pg = NULL;
     unsigned int bits = memflags >> _MEMF_bits, zone_hi = NR_ZONES - 1;
+    unsigned int node = (uint8_t)((memflags >> _MEMF_node) - 1);
 
     ASSERT(!in_irq());
 
@@ -797,7 +802,7 @@ struct page_info *__alloc_domheap_pages(
 
     if ( (zone_hi + PAGE_SHIFT) >= dma_bitsize )
     {
-        pg = alloc_heap_pages(dma_bitsize - PAGE_SHIFT, zone_hi, cpu, order);
+        pg = alloc_heap_pages(dma_bitsize - PAGE_SHIFT, zone_hi, node, order);
 
         /* Failure? Then check if we can fall back to the DMA pool. */
         if ( unlikely(pg == NULL) &&
@@ -811,7 +816,7 @@ struct page_info *__alloc_domheap_pages(
 
     if ( (pg == NULL) &&
          ((pg = alloc_heap_pages(MEMZONE_XEN + 1, zone_hi,
-                                 cpu, order)) == NULL) )
+                                 node, order)) == NULL) )
          return NULL;
 
     if ( (d != NULL) && assign_pages(d, pg, order, memflags) )
@@ -823,12 +828,6 @@ struct page_info *__alloc_domheap_pages(
     return pg;
 }
 
-struct page_info *alloc_domheap_pages(
-    struct domain *d, unsigned int order, unsigned int flags)
-{
-    return __alloc_domheap_pages(d, smp_processor_id(), order, flags);
-}
-
 void free_domheap_pages(struct page_info *pg, unsigned int order)
 {
     int            i, drop_dom_ref;

diff --git a/xen/drivers/passthrough/vtd/iommu.c b/xen/drivers/passthrough/vtd/iommu.c
index 41fc90d6ec47451651008e11df41f512a5fcc60b..b999b1eef2a0c3d93bc274f8403f1f8c2f7ffe42 100644 (file)
--- a/xen/drivers/passthrough/vtd/iommu.c
+++ b/xen/drivers/passthrough/vtd/iommu.c
@@ -24,6 +24,7 @@
 #include <xen/xmalloc.h>
 #include <xen/domain_page.h>
 #include <xen/iommu.h>
+#include <xen/numa.h>
 #include "iommu.h"
 #include "dmar.h"
 #include "../pci-direct.h"
@@ -269,7 +270,8 @@ static struct page_info *addr_to_dma_page(struct domain *domain, u64 addr)
 
         if ( dma_pte_addr(*pte) == 0 )
         {
-            pg = alloc_domheap_page(NULL);
+            pg = alloc_domheap_page(
+                NULL, MEMF_node(domain_to_node(domain)));
             vaddr = map_domain_page(page_to_mfn(pg));
             if ( !vaddr )
             {

diff --git a/xen/include/asm-x86/numa.h b/xen/include/asm-x86/numa.h
index 90233e07b95eb72593a4dd0fcf97334454f61ce0..cbf91e8621dd424a39242d11e1995c79b1495442 100644 (file)
--- a/xen/include/asm-x86/numa.h
+++ b/xen/include/asm-x86/numa.h
@@ -73,6 +73,5 @@ static inline __attribute__((pure)) int phys_to_nid(paddr_t addr)
 #define clear_node_cpumask(cpu) do {} while (0)
 #endif
 
-#define NUMA_NO_NODE 0xff
 
 #endif

diff --git a/xen/include/xen/mm.h b/xen/include/xen/mm.h
index 2742563fd840307be4bb1905054f506fdfc1f9f4..1341bb0fa092f850d00974c40e576348b5c200a1 100644 (file)
--- a/xen/include/xen/mm.h
+++ b/xen/include/xen/mm.h
@@ -54,14 +54,11 @@ void free_xenheap_pages(void *v, unsigned int order);
 void init_domheap_pages(paddr_t ps, paddr_t pe);
 struct page_info *alloc_domheap_pages(
     struct domain *d, unsigned int order, unsigned int memflags);
-struct page_info *__alloc_domheap_pages(
-    struct domain *d, unsigned int cpu, unsigned int order, 
-    unsigned int memflags);
 void free_domheap_pages(struct page_info *pg, unsigned int order);
 unsigned long avail_domheap_pages_region(
     unsigned int node, unsigned int min_width, unsigned int max_width);
 unsigned long avail_domheap_pages(void);
-#define alloc_domheap_page(d) (alloc_domheap_pages(d,0,0))
+#define alloc_domheap_page(d,f) (alloc_domheap_pages(d,0,f))
 #define free_domheap_page(p)  (free_domheap_pages(p,0))
 
 void scrub_heap_pages(void);
@@ -75,6 +72,8 @@ int assign_pages(
 /* memflags: */
 #define _MEMF_no_refcount 0
 #define  MEMF_no_refcount (1U<<_MEMF_no_refcount)
+#define _MEMF_node        8
+#define  MEMF_node(n)     ((((n)+1)&0xff)<<_MEMF_node)
 #define _MEMF_bits        24
 #define  MEMF_bits(n)     ((n)<<_MEMF_bits)
 

diff --git a/xen/include/xen/numa.h b/xen/include/xen/numa.h
index 9585fc9c4803419364ea037244e8fefcbd7d940a..6fe8ad9a8b758fab3b668075bc69044d44caa90b 100644 (file)
--- a/xen/include/xen/numa.h
+++ b/xen/include/xen/numa.h
@@ -8,6 +8,13 @@
 #define NODES_SHIFT     0
 #endif
 
+#define NUMA_NO_NODE    0xFF
+
 #define MAX_NUMNODES    (1 << NODES_SHIFT)
 
+#define vcpu_to_node(v) (cpu_to_node[(v)->processor])
+
+#define domain_to_node(d) \
+  (((d)->vcpu[0] != NULL) ? vcpu_to_node((d)->vcpu[0]) : NUMA_NO_NODE)
+
 #endif /* _XEN_NUMA_H */