Simplify 'dma heap' logic.

1. Only useful for NUMA systems, so turn it off on non-NUMA systems by
   default.
2. On NUMA systems, by default relate the DMA heap size to NUMA node 0
   memory size (so that not all of node 0's memory ends up being 'DMA
   heap').
3. Remove the 'dma emergency pool'. It's less useful now that running
   out of low memory isn;t as fatal as it used to be (e.g., when we
   needed to be able to allocate low-memory PAE page directories).

Based on patches by Andre Przywara and Xiaowei Yang.

Signed-off-by: Keir Fraser <keir.fraser@citrix.com>

diff --git a/docs/src/user.tex b/docs/src/user.tex
index 33d4a213be8ffa3bad680f57b7165dce610d4d59..59f5a8a9e4cee14175d56621e11d72160a585ad8 100644 (file)
--- a/docs/src/user.tex
+++ b/docs/src/user.tex
@@ -4204,11 +4204,9 @@ writing to the VGA console after domain 0 starts booting (e.g., `vga=text-80x50,
   enabled by the BIOS.
 \item [ apic=bigsmp,default,es7000,summit ] Specify NUMA platform.
   This can usually be probed automatically.
-\item [ dma\_bits=xxx ] Specify width of DMA
-  addresses in bits. Default is 30 bits (addresses up to 1GB are DMAable).
-\item [ dma\_emergency\_pool=xxx ] Specify lower bound on size of DMA
-  pool below which ordinary allocations will fail rather than fall
-  back to allocating from the DMA pool.
+\item [ dma\_bits=xxx ] Specify width of DMA addresses in bits. This
+  is used in NUMA systems to prevent this special DMA memory from
+  being exhausted in one node when remote nodes have available memory.
 \end{description}
 
 In addition, the following options may be specified on the Xen command

diff --git a/xen/common/page_alloc.c b/xen/common/page_alloc.c
index 0c6bff28743b6a1da9c2475a10d7596159e49989..9ebdb20092e2aca2a1dcc239ffd6a77cbe3022f3 100644 (file)
--- a/xen/common/page_alloc.c
+++ b/xen/common/page_alloc.c
@@ -53,34 +53,11 @@ static int opt_bootscrub __initdata = 1;
 boolean_param("bootscrub", opt_bootscrub);
 
 /*
- * Bit width of the DMA heap.
+ * Bit width of the DMA heap -- used to override NUMA-node-first.
+ * allocation strategy, which can otherwise exhaust low memory.
  */
-static unsigned int dma_bitsize = 30;
-static void __init parse_dma_bits(char *s)
-{
-    unsigned int v = simple_strtol(s, NULL, 0);
-    if ( v >= (BITS_PER_LONG + PAGE_SHIFT) )
-        dma_bitsize = BITS_PER_LONG + PAGE_SHIFT;
-    else if ( v > PAGE_SHIFT + 1 )
-        dma_bitsize = v;
-    else
-        printk("Invalid dma_bits value of %u ignored.\n", v);
-}
-custom_param("dma_bits", parse_dma_bits);
-
-/*
- * Amount of memory to reserve in a low-memory (<4GB) pool for specific
- * allocation requests. Ordinary requests will not fall back to the
- * lowmem emergency pool.
- */
-static unsigned long dma_emergency_pool_pages;
-static void __init parse_dma_emergency_pool(char *s)
-{
-    unsigned long long bytes;
-    bytes = parse_size_and_unit(s, NULL);
-    dma_emergency_pool_pages = bytes >> PAGE_SHIFT;
-}
-custom_param("dma_emergency_pool", parse_dma_emergency_pool);
+static unsigned int dma_bitsize;
+integer_param("dma_bits", dma_bitsize);
 
 #define round_pgdown(_p)  ((_p)&PAGE_MASK)
 #define round_pgup(_p)    (((_p)+(PAGE_SIZE-1))&PAGE_MASK)
@@ -579,7 +556,16 @@ void __init end_boot_allocator(void)
             init_heap_pages(pfn_dom_zone_type(i), mfn_to_page(i), 1);
     }
 
-    printk("Domain heap initialised: DMA width %u bits\n", dma_bitsize);
+    if ( !dma_bitsize && (num_online_nodes() > 1) )
+        dma_bitsize = min_t(unsigned int,
+                            fls(NODE_DATA(0)->node_spanned_pages) - 1
+                            + PAGE_SHIFT - 2,
+                            32);
+
+    printk("Domain heap initialised");
+    if ( dma_bitsize )
+        printk(" DMA width %u bits", dma_bitsize);
+    printk("\n");
 }
 #undef avail_for_domheap
 
@@ -799,20 +785,10 @@ struct page_info *alloc_domheap_pages(
     if ( bits < zone_hi )
         zone_hi = bits;
 
-    if ( (zone_hi + PAGE_SHIFT) >= dma_bitsize )
-    {
+    if ( (dma_bitsize > PAGE_SHIFT) &&
+         ((zone_hi + PAGE_SHIFT) >= dma_bitsize) )
         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) &&
-             ((order > MAX_ORDER) ||
-              (avail_heap_pages(MEMZONE_XEN + 1,
-                                dma_bitsize - PAGE_SHIFT - 1,
-                                -1) <
-               (dma_emergency_pool_pages + (1UL << order)))) )
-            return NULL;
-    }
-
     if ( (pg == NULL) &&
          ((pg = alloc_heap_pages(MEMZONE_XEN + 1, zone_hi,
                                  node, order)) == NULL) )
@@ -913,22 +889,9 @@ unsigned long avail_domheap_pages_region(
 
 unsigned long avail_domheap_pages(void)
 {
-    unsigned long avail_nrm, avail_dma;
-    
-    avail_nrm = avail_heap_pages(dma_bitsize - PAGE_SHIFT,
-                                 NR_ZONES - 1,
-                                 -1);
-
-    avail_dma = avail_heap_pages(MEMZONE_XEN + 1,
-                                 dma_bitsize - PAGE_SHIFT - 1,
-                                 -1);
-
-    if ( avail_dma > dma_emergency_pool_pages )
-        avail_dma -= dma_emergency_pool_pages;
-    else
-        avail_dma = 0;
-
-    return avail_nrm + avail_dma;
+    return avail_heap_pages(MEMZONE_XEN + 1,
+                            NR_ZONES - 1,
+                            -1);
 }
 
 static void pagealloc_keyhandler(unsigned char key)
@@ -942,7 +905,7 @@ static void pagealloc_keyhandler(unsigned char key)
 
     while ( ++zone < NR_ZONES )
     {
-        if ( zone == (dma_bitsize - PAGE_SHIFT) )
+        if ( (zone + PAGE_SHIFT) == dma_bitsize )
         {
             printk("    DMA heap: %lukB free\n", total << (PAGE_SHIFT-10));
             total = 0;