Jan Beulich
2007-Feb-07 17:09 UTC
[Xen-devel] [PATCH 1/4] domain heap allocator changes - hide generic allocator routines
This patch doesn''t introduce functional changes, but simply moves code
around to make the unused (outside of the page allocator) heap alloc
functions taking an explicit zone parameter static without having to
forward-prototype them in their source file.
Signed-off-by: Jan Beulich <jbeulich@novell.com>
Index: 2007-02-07/xen/common/page_alloc.c
==================================================================---
2007-02-07.orig/xen/common/page_alloc.c 2007-01-02 09:56:11.000000000 +0100
+++ 2007-02-07/xen/common/page_alloc.c 2007-02-07 16:26:42.000000000 +0100
@@ -292,78 +292,11 @@ static unsigned long avail[NR_ZONES][MAX
static DEFINE_SPINLOCK(heap_lock);
-void end_boot_allocator(void)
-{
- unsigned long i, j, k;
- int curr_free, next_free;
-
- memset(avail, 0, sizeof(avail));
-
- for ( i = 0; i < NR_ZONES; i++ )
- for ( j = 0; j < MAX_NUMNODES; j++ )
- for ( k = 0; k <= MAX_ORDER; k++ )
- INIT_LIST_HEAD(&heap[i][j][k]);
-
- /* Pages that are free now go to the domain sub-allocator. */
- if ( (curr_free = next_free = !allocated_in_map(first_valid_mfn)) )
- map_alloc(first_valid_mfn, 1);
- for ( i = first_valid_mfn; i < max_page; i++ )
- {
- curr_free = next_free;
- next_free = !allocated_in_map(i+1);
- if ( next_free )
- map_alloc(i+1, 1); /* prevent merging in free_heap_pages() */
- if ( curr_free )
- init_heap_pages(pfn_dom_zone_type(i), mfn_to_page(i), 1);
- }
-
- printk("Domain heap initialised: DMA width %u bits\n",
dma_bitsize);
-}
-
-/*
- * Hand the specified arbitrary page range to the specified heap zone
- * checking the node_id of the previous page. If they differ and the
- * latter is not on a MAX_ORDER boundary, then we reserve the page by
- * not freeing it to the buddy allocator.
- */
-#define MAX_ORDER_ALIGNED (1UL << (MAX_ORDER))
-void init_heap_pages(
- unsigned int zone, struct page_info *pg, unsigned long nr_pages)
-{
- unsigned int nid_curr, nid_prev;
- unsigned long i;
-
- ASSERT(zone < NR_ZONES);
-
- if ( likely(page_to_mfn(pg) != 0) )
- nid_prev = phys_to_nid(page_to_maddr(pg-1));
- else
- nid_prev = phys_to_nid(page_to_maddr(pg));
-
- for ( i = 0; i < nr_pages; i++ )
- {
- nid_curr = phys_to_nid(page_to_maddr(pg+i));
-
- /*
- * free pages of the same node, or if they differ, but are on a
- * MAX_ORDER alignement boundary (which already get reserved)
- */
- if ( (nid_curr == nid_prev) || (page_to_maddr(pg+i) &
- MAX_ORDER_ALIGNED) )
- free_heap_pages(zone, pg+i, 0);
- else
- printk("Reserving non-aligned node boundary @ mfn
%lu\n",
- page_to_mfn(pg+i));
-
- nid_prev = nid_curr;
- }
-}
-
/* Allocate 2^@order contiguous pages. */
-struct page_info *alloc_heap_pages(unsigned int zone, unsigned int cpu,
- unsigned int order)
+static struct page_info *alloc_heap_pages(
+ unsigned int zone, unsigned int cpu, unsigned int order)
{
- unsigned int i,j, node = cpu_to_node(cpu), num_nodes = num_online_nodes();
+ unsigned int i, j, node = cpu_to_node(cpu), num_nodes = num_online_nodes();
unsigned int request = (1UL << order);
struct page_info *pg;
@@ -422,13 +355,12 @@ struct page_info *alloc_heap_pages(unsig
return pg;
}
-
/* Free 2^@order set of pages. */
-void free_heap_pages(
+static void free_heap_pages(
unsigned int zone, struct page_info *pg, unsigned int order)
{
unsigned long mask;
- int node = phys_to_nid(page_to_maddr(pg));
+ unsigned int node = phys_to_nid(page_to_maddr(pg));
ASSERT(zone < NR_ZONES);
ASSERT(order <= MAX_ORDER);
@@ -475,6 +407,87 @@ void free_heap_pages(
spin_unlock(&heap_lock);
}
+/*
+ * Hand the specified arbitrary page range to the specified heap zone
+ * checking the node_id of the previous page. If they differ and the
+ * latter is not on a MAX_ORDER boundary, then we reserve the page by
+ * not freeing it to the buddy allocator.
+ */
+#define MAX_ORDER_ALIGNED (1UL << (MAX_ORDER))
+void init_heap_pages(
+ unsigned int zone, struct page_info *pg, unsigned long nr_pages)
+{
+ unsigned int nid_curr, nid_prev;
+ unsigned long i;
+
+ ASSERT(zone < NR_ZONES);
+
+ if ( likely(page_to_mfn(pg) != 0) )
+ nid_prev = phys_to_nid(page_to_maddr(pg-1));
+ else
+ nid_prev = phys_to_nid(page_to_maddr(pg));
+
+ for ( i = 0; i < nr_pages; i++ )
+ {
+ nid_curr = phys_to_nid(page_to_maddr(pg+i));
+
+ /*
+ * free pages of the same node, or if they differ, but are on a
+ * MAX_ORDER alignement boundary (which already get reserved)
+ */
+ if ( (nid_curr == nid_prev) || (page_to_maddr(pg+i) &
+ MAX_ORDER_ALIGNED) )
+ free_heap_pages(zone, pg+i, 0);
+ else
+ printk("Reserving non-aligned node boundary @ mfn
%lu\n",
+ page_to_mfn(pg+i));
+
+ nid_prev = nid_curr;
+ }
+}
+
+static unsigned long avail_heap_pages(
+ int zone, int node)
+{
+ unsigned int i, j, num_nodes = num_online_nodes();
+ unsigned long free_pages = 0;
+
+ for (i=0; i<NR_ZONES; i++)
+ if ( (zone == -1) || (zone == i) )
+ for (j=0; j < num_nodes; j++)
+ if ( (node == -1) || (node == j) )
+ free_pages += avail[i][j];
+
+ return free_pages;
+}
+
+void end_boot_allocator(void)
+{
+ unsigned long i, j, k;
+ int curr_free, next_free;
+
+ memset(avail, 0, sizeof(avail));
+
+ for ( i = 0; i < NR_ZONES; i++ )
+ for ( j = 0; j < MAX_NUMNODES; j++ )
+ for ( k = 0; k <= MAX_ORDER; k++ )
+ INIT_LIST_HEAD(&heap[i][j][k]);
+
+ /* Pages that are free now go to the domain sub-allocator. */
+ if ( (curr_free = next_free = !allocated_in_map(first_valid_mfn)) )
+ map_alloc(first_valid_mfn, 1);
+ for ( i = first_valid_mfn; i < max_page; i++ )
+ {
+ curr_free = next_free;
+ next_free = !allocated_in_map(i+1);
+ if ( next_free )
+ map_alloc(i+1, 1); /* prevent merging in free_heap_pages() */
+ if ( curr_free )
+ init_heap_pages(pfn_dom_zone_type(i), mfn_to_page(i), 1);
+ }
+
+ printk("Domain heap initialised: DMA width %u bits\n",
dma_bitsize);
+}
/*
* Scrub all unallocated pages in all heap zones. This function is more
@@ -818,20 +831,6 @@ void free_domheap_pages(struct page_info
}
-unsigned long avail_heap_pages(int zone, int node)
-{
- int i,j, num_nodes = num_online_nodes();
- unsigned long free_pages = 0;
-
- for (i=0; i<NR_ZONES; i++)
- if ( (zone == -1) || (zone == i) )
- for (j=0; j < num_nodes; j++)
- if ( (node == -1) || (node == j) )
- free_pages += avail[i][j];
-
- return free_pages;
-}
-
unsigned long avail_domheap_pages(void)
{
unsigned long avail_nrm, avail_dma;
Index: 2007-02-07/xen/include/xen/mm.h
==================================================================---
2007-02-07.orig/xen/include/xen/mm.h 2006-12-01 10:44:36.000000000 +0100
+++ 2007-02-07/xen/include/xen/mm.h 2007-02-07 16:25:40.000000000 +0100
@@ -43,15 +43,6 @@ unsigned long alloc_boot_pages(unsigned
unsigned long alloc_boot_pages_at(unsigned long nr_pfns, unsigned long pfn_at);
void end_boot_allocator(void);
-/* Generic allocator. These functions are *not* interrupt-safe. */
-void init_heap_pages(
- unsigned int zone, struct page_info *pg, unsigned long nr_pages);
-struct page_info *alloc_heap_pages(
- unsigned int zone, unsigned int cpu, unsigned int order);
-void free_heap_pages(
- unsigned int zone, struct page_info *pg, unsigned int order);
-void scrub_heap_pages(void);
-
/* Xen suballocator. These functions are interrupt-safe. */
void init_xenheap_pages(paddr_t ps, paddr_t pe);
void *alloc_xenheap_pages(unsigned int order);
@@ -68,10 +59,11 @@ struct page_info *__alloc_domheap_pages(
unsigned int memflags);
void free_domheap_pages(struct page_info *pg, unsigned int order);
unsigned long avail_domheap_pages(void);
-unsigned long avail_heap_pages(int zone, int node);
#define alloc_domheap_page(d) (alloc_domheap_pages(d,0,0))
#define free_domheap_page(p) (free_domheap_pages(p,0))
+void scrub_heap_pages(void);
+
int assign_pages(
struct domain *d,
struct page_info *pg,
_______________________________________________
Xen-devel mailing list
Xen-devel@lists.xensource.com
http://lists.xensource.com/xen-devel