* [PATCH v5 1/8] xen: arm: dump vcpu gic info in arch_dump_vcpu_info
2014-07-09 12:06 [PATCH v5 0/8] xen: arm: Use super pages in p2m Ian Campbell
@ 2014-07-09 12:07 ` Ian Campbell
2014-07-09 12:07 ` [PATCH v5 2/8] tools/libxc: pull min/max_t into xc_private.h Ian Campbell
` (7 subsequent siblings)
8 siblings, 0 replies; 20+ messages in thread
From: Ian Campbell @ 2014-07-09 12:07 UTC (permalink / raw)
To: xen-devel; +Cc: julien.grall, tim, Ian Campbell, stefano.stabellini
Instead of looping over vcpus in arch_dump_domain_info
Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
Acked-by: Julien Grall <julien.grall@linaro.org>
---
xen/arch/arm/domain.c | 7 +------
1 file changed, 1 insertion(+), 6 deletions(-)
diff --git a/xen/arch/arm/domain.c b/xen/arch/arm/domain.c
index 829d49f..bb5c810 100644
--- a/xen/arch/arm/domain.c
+++ b/xen/arch/arm/domain.c
@@ -747,12 +747,6 @@ int domain_relinquish_resources(struct domain *d)
void arch_dump_domain_info(struct domain *d)
{
- struct vcpu *v;
-
- for_each_vcpu ( d, v )
- {
- gic_dump_info(v);
- }
}
@@ -775,6 +769,7 @@ long arch_do_vcpu_op(int cmd, struct vcpu *v, XEN_GUEST_HANDLE_PARAM(void) arg)
void arch_dump_vcpu_info(struct vcpu *v)
{
+ gic_dump_info(v);
}
void vcpu_mark_events_pending(struct vcpu *v)
--
1.7.10.4
^ permalink raw reply related [flat|nested] 20+ messages in thread* [PATCH v5 2/8] tools/libxc: pull min/max_t into xc_private.h
2014-07-09 12:06 [PATCH v5 0/8] xen: arm: Use super pages in p2m Ian Campbell
2014-07-09 12:07 ` [PATCH v5 1/8] xen: arm: dump vcpu gic info in arch_dump_vcpu_info Ian Campbell
@ 2014-07-09 12:07 ` Ian Campbell
2014-07-10 11:01 ` Ian Jackson
2014-07-09 12:07 ` [PATCH v5 3/8] tools: arm: allocate large pages to guests Ian Campbell
` (6 subsequent siblings)
8 siblings, 1 reply; 20+ messages in thread
From: Ian Campbell @ 2014-07-09 12:07 UTC (permalink / raw)
To: xen-devel
Cc: Ian Jackson, julien.grall, tim, Ian Campbell, stefano.stabellini
There are generally useful.
Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
Acked-by: Julien Grall <julien.grall@linaro.org>
Cc: Ian Jackson <ian.jackson@eu.citrix.com>
---
v2: New patch.
---
tools/libxc/xc_dom_decompress_unsafe_xz.c | 5 -----
tools/libxc/xc_private.h | 5 +++++
2 files changed, 5 insertions(+), 5 deletions(-)
diff --git a/tools/libxc/xc_dom_decompress_unsafe_xz.c b/tools/libxc/xc_dom_decompress_unsafe_xz.c
index 2a32d40..6be1f89 100644
--- a/tools/libxc/xc_dom_decompress_unsafe_xz.c
+++ b/tools/libxc/xc_dom_decompress_unsafe_xz.c
@@ -40,11 +40,6 @@ static inline u32 le32_to_cpup(const u32 *p)
(void) (&_x == &_y); \
_x < _y ? _x : _y; })
-#define min_t(type,x,y) \
- ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })
-#define max_t(type,x,y) \
- ({ type __x = (x); type __y = (y); __x > __y ? __x: __y; })
-
#define __force
#define always_inline
diff --git a/tools/libxc/xc_private.h b/tools/libxc/xc_private.h
index 6cc0f2b..c240a7c 100644
--- a/tools/libxc/xc_private.h
+++ b/tools/libxc/xc_private.h
@@ -349,6 +349,11 @@ int xc_ffs16(uint16_t x);
int xc_ffs32(uint32_t x);
int xc_ffs64(uint64_t x);
+#define min_t(type,x,y) \
+ ({ type __x = (x); type __y = (y); __x < __y ? __x: __y; })
+#define max_t(type,x,y) \
+ ({ type __x = (x); type __y = (y); __x > __y ? __x: __y; })
+
#define DOMPRINTF(fmt, args...) xc_dom_printf(dom->xch, fmt, ## args)
#define DOMPRINTF_CALLED(xch) xc_dom_printf((xch), "%s: called", __FUNCTION__)
--
1.7.10.4
^ permalink raw reply related [flat|nested] 20+ messages in thread* Re: [PATCH v5 2/8] tools/libxc: pull min/max_t into xc_private.h
2014-07-09 12:07 ` [PATCH v5 2/8] tools/libxc: pull min/max_t into xc_private.h Ian Campbell
@ 2014-07-10 11:01 ` Ian Jackson
2014-07-10 11:08 ` Ian Campbell
0 siblings, 1 reply; 20+ messages in thread
From: Ian Jackson @ 2014-07-10 11:01 UTC (permalink / raw)
To: Ian Campbell; +Cc: stefano.stabellini, tim, julien.grall, xen-devel
Ian Campbell writes ("[PATCH v5 2/8] tools/libxc: pull min/max_t into xc_private.h"):
> There are generally useful.
Sorry for not spotting this but: names matching "*_t" are by the C
spec "reserved for the implementation". This is not a problem in the
hypervisor because that is compiled without the system headrs.
In practice what this means is that it is possible that porting the
tools to a new platform might involve renaming these macros. So we
don't need to fix it right now unless we really feel like it.
But we mustn't let the scope of these increase to include guest-side
code.
(Also "min_t" is a very funny name for a function macro like this one.
To me it implies a type.)
Ian.
^ permalink raw reply [flat|nested] 20+ messages in thread* Re: [PATCH v5 2/8] tools/libxc: pull min/max_t into xc_private.h
2014-07-10 11:01 ` Ian Jackson
@ 2014-07-10 11:08 ` Ian Campbell
0 siblings, 0 replies; 20+ messages in thread
From: Ian Campbell @ 2014-07-10 11:08 UTC (permalink / raw)
To: Ian Jackson; +Cc: stefano.stabellini, tim, julien.grall, xen-devel
On Thu, 2014-07-10 at 12:01 +0100, Ian Jackson wrote:
> Ian Campbell writes ("[PATCH v5 2/8] tools/libxc: pull min/max_t into xc_private.h"):
> > There are generally useful.
>
> Sorry for not spotting this but: names matching "*_t" are by the C
> spec "reserved for the implementation". This is not a problem in the
> hypervisor because that is compiled without the system headrs.
Oh damn, yes of course.
> In practice what this means is that it is possible that porting the
> tools to a new platform might involve renaming these macros. So we
> don't need to fix it right now unless we really feel like it.
>
> But we mustn't let the scope of these increase to include guest-side
> code.
I don't think there is any danger of that, there's no reason at all for
this to be in e.g. xen/include/public.
> (Also "min_t" is a very funny name for a function macro like this one.
> To me it implies a type.)
It's the _typed version of min I suppose, I think we've inherited this
all the way from Linux without really considering the name...
Ian.
^ permalink raw reply [flat|nested] 20+ messages in thread
* [PATCH v5 3/8] tools: arm: allocate large pages to guests.
2014-07-09 12:06 [PATCH v5 0/8] xen: arm: Use super pages in p2m Ian Campbell
2014-07-09 12:07 ` [PATCH v5 1/8] xen: arm: dump vcpu gic info in arch_dump_vcpu_info Ian Campbell
2014-07-09 12:07 ` [PATCH v5 2/8] tools/libxc: pull min/max_t into xc_private.h Ian Campbell
@ 2014-07-09 12:07 ` Ian Campbell
2014-07-09 15:19 ` Ian Jackson
2014-07-09 12:07 ` [PATCH v5 4/8] xen: arm: only put_page for p2m operations which require it Ian Campbell
` (5 subsequent siblings)
8 siblings, 1 reply; 20+ messages in thread
From: Ian Campbell @ 2014-07-09 12:07 UTC (permalink / raw)
To: xen-devel
Cc: Ian Jackson, julien.grall, tim, Ian Campbell, stefano.stabellini
Tries to allocate as many large (1G or 2M) pages as it can to the guest and tries
to align to the next larger size on each attempt so that we can attempt to
allocate even larger pages on the next iteration (this is currently only
exercised via a compile time debug option, which is left in place under a #if
0).
Since ARM page tables are consistent at each level there is a common helper
function which tries to allocate a levels worth of pages. The exception to this
consistency is level 0 which does not support table mappings (0.5TB
superpages!).
Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
Acked-by: Julien Grall <julien.grall@linaro.org>
Cc: Ian Jackson <ian.jackson@eu.citrix.com>
---
v4: fixed the code which was supposed to try and realign things to the next
superpage.
constify some values
v3: Drop outdated paragraph from commit message
v2: min_t defintion moved into earlier patch
drop debug_iters
allocate extents array explicitly instead of putting 8M on the stack.
Handle OOM, xc_populate_physmap returns 0, which needs handling for L3.
---
tools/libxc/xc_dom_arm.c | 131 +++++++++++++++++++++++++++++++++++++++++-----
1 file changed, 117 insertions(+), 14 deletions(-)
diff --git a/tools/libxc/xc_dom_arm.c b/tools/libxc/xc_dom_arm.c
index 10f6bcb..9b31b1f 100644
--- a/tools/libxc/xc_dom_arm.c
+++ b/tools/libxc/xc_dom_arm.c
@@ -30,6 +30,13 @@
#define CONSOLE_PFN_OFFSET 0
#define XENSTORE_PFN_OFFSET 1
+#define LPAE_SHIFT 9
+
+#define PFN_4K_SHIFT (0)
+#define PFN_2M_SHIFT (PFN_4K_SHIFT+LPAE_SHIFT)
+#define PFN_1G_SHIFT (PFN_2M_SHIFT+LPAE_SHIFT)
+#define PFN_512G_SHIFT (PFN_1G_SHIFT+LPAE_SHIFT)
+
/* get guest IO ABI protocol */
const char *xc_domain_get_native_protocol(xc_interface *xch,
uint32_t domid)
@@ -249,11 +256,72 @@ static int set_mode(xc_interface *xch, domid_t domid, char *guest_type)
return rc;
}
+/* >0: success, *nr_pfns set to number actually populated
+ * 0: didn't try with this pfn shift (e.g. misaligned base etc)
+ * <0: ERROR
+ */
+static int populate_one_size(struct xc_dom_image *dom, int pfn_shift,
+ xen_pfn_t base_pfn, xen_pfn_t *nr_pfns,
+ xen_pfn_t *extents)
+{
+ /* The mask for this level */
+ const uint64_t mask = ((uint64_t)1<<(pfn_shift))-1;
+ /* The shift, mask and next boundary for the level above this one */
+ const int next_shift = pfn_shift + LPAE_SHIFT;
+ const uint64_t next_mask = ((uint64_t)1<<next_shift)-1;
+ const xen_pfn_t next_boundary
+ = (base_pfn + ((uint64_t)1<<next_shift)) & ~next_mask;
+
+ int nr, i, count;
+ xen_pfn_t end_pfn = base_pfn + *nr_pfns;
+
+ /* No level zero super pages with current hardware */
+ if ( pfn_shift == PFN_512G_SHIFT )
+ return 0;
+
+ /* base is misaligned for this level */
+ if ( mask & base_pfn )
+ return 0;
+
+ /*
+ * If base is not aligned at the next level up then try and make
+ * it so for next time around.
+ */
+ if ( (base_pfn & next_mask) && end_pfn > next_boundary )
+ end_pfn = next_boundary;
+
+ count = ( end_pfn - base_pfn ) >> pfn_shift;
+
+ /* Nothing to allocate */
+ if ( !count )
+ return 0;
+
+ for ( i = 0 ; i < count ; i ++ )
+ extents[i] = base_pfn + (i<<pfn_shift);
+
+ nr = xc_domain_populate_physmap(dom->xch, dom->guest_domid, count,
+ pfn_shift, 0, extents);
+ if ( nr <= 0 ) return nr;
+ DOMPRINTF("%s: populated %#x/%#x entries with shift %d",
+ __FUNCTION__, nr, count, pfn_shift);
+
+ *nr_pfns = nr << pfn_shift;
+
+ return 1;
+}
+
static int populate_guest_memory(struct xc_dom_image *dom,
xen_pfn_t base_pfn, xen_pfn_t nr_pfns)
{
- int rc;
- xen_pfn_t allocsz, pfn;
+ int rc = 0;
+ xen_pfn_t allocsz, pfn, *extents;
+
+ extents = calloc(1024*1024,sizeof(xen_pfn_t));
+ if ( extents == NULL )
+ {
+ DOMPRINTF("%s: Unable to allocate extent array", __FUNCTION__);
+ return -1;
+ }
DOMPRINTF("%s: populating RAM @ %016"PRIx64"-%016"PRIx64" (%"PRId64"MB)",
__FUNCTION__,
@@ -261,21 +329,56 @@ static int populate_guest_memory(struct xc_dom_image *dom,
(uint64_t)(base_pfn + nr_pfns) << XC_PAGE_SHIFT,
(uint64_t)nr_pfns >> (20-XC_PAGE_SHIFT));
- for ( pfn = 0; pfn < nr_pfns; pfn++ )
- dom->p2m_host[pfn] = base_pfn + pfn;
-
- for ( pfn = rc = allocsz = 0; (pfn < nr_pfns) && !rc; pfn += allocsz )
+ for ( pfn = 0; pfn < nr_pfns; pfn += allocsz )
{
- allocsz = nr_pfns - pfn;
- if ( allocsz > 1024*1024 )
- allocsz = 1024*1024;
-
- rc = xc_domain_populate_physmap_exact(
- dom->xch, dom->guest_domid, allocsz,
- 0, 0, &dom->p2m_host[pfn]);
+ allocsz = min_t(int, 1024*1024, nr_pfns - pfn);
+#if 0 /* Enable this to exercise/debug the code which tries to realign
+ * to a superpage boundary, by misaligning at the start. */
+ if ( pfn == 0 )
+ {
+ allocsz = 1;
+ rc = populate_one_size(dom, PFN_4K_SHIFT,
+ base_pfn + pfn, &allocsz, extents);
+ if (rc < 0) break;
+ if (rc > 0) continue;
+ /* Failed to allocate a single page? */
+ break;
+ }
+#endif
+
+ rc = populate_one_size(dom, PFN_512G_SHIFT,
+ base_pfn + pfn, &allocsz, extents);
+ if ( rc < 0 ) break;
+ if ( rc > 0 ) continue;
+
+ rc = populate_one_size(dom, PFN_1G_SHIFT,
+ base_pfn + pfn, &allocsz, extents);
+ if ( rc < 0 ) break;
+ if ( rc > 0 ) continue;
+
+ rc = populate_one_size(dom, PFN_2M_SHIFT,
+ base_pfn + pfn, &allocsz, extents);
+ if ( rc < 0 ) break;
+ if ( rc > 0 ) continue;
+
+ rc = populate_one_size(dom, PFN_4K_SHIFT,
+ base_pfn + pfn, &allocsz, extents);
+ if ( rc < 0 ) break;
+ if ( rc == 0 )
+ {
+ DOMPRINTF("%s: Not enough RAM", __FUNCTION__);
+ errno = ENOMEM;
+ rc = -1;
+ goto out;
+ }
}
- return rc;
+ for ( pfn = 0; pfn < nr_pfns; pfn++ )
+ dom->p2m_host[pfn] = base_pfn + pfn;
+
+out:
+ free(extents);
+ return rc < 0 ? rc : 0;
}
int arch_setup_meminit(struct xc_dom_image *dom)
--
1.7.10.4
^ permalink raw reply related [flat|nested] 20+ messages in thread* Re: [PATCH v5 3/8] tools: arm: allocate large pages to guests.
2014-07-09 12:07 ` [PATCH v5 3/8] tools: arm: allocate large pages to guests Ian Campbell
@ 2014-07-09 15:19 ` Ian Jackson
0 siblings, 0 replies; 20+ messages in thread
From: Ian Jackson @ 2014-07-09 15:19 UTC (permalink / raw)
To: Ian Campbell; +Cc: stefano.stabellini, tim, julien.grall, xen-devel
Ian Campbell writes ("[PATCH v5 3/8] tools: arm: allocate large pages to guests."):
> Tries to allocate as many large (1G or 2M) pages as it can to the guest and tries
> to align to the next larger size on each attempt so that we can attempt to
> allocate even larger pages on the next iteration (this is currently only
> exercised via a compile time debug option, which is left in place under a #if
> 0).
>
> Since ARM page tables are consistent at each level there is a common helper
> function which tries to allocate a levels worth of pages. The exception to this
> consistency is level 0 which does not support table mappings (0.5TB
> superpages!).
>
> Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
> Acked-by: Julien Grall <julien.grall@linaro.org>
> Cc: Ian Jackson <ian.jackson@eu.citrix.com>
Acked-by: Ian Jackson <ian.jackson@eu.citrix.com>
^ permalink raw reply [flat|nested] 20+ messages in thread
* [PATCH v5 4/8] xen: arm: only put_page for p2m operations which require it.
2014-07-09 12:06 [PATCH v5 0/8] xen: arm: Use super pages in p2m Ian Campbell
` (2 preceding siblings ...)
2014-07-09 12:07 ` [PATCH v5 3/8] tools: arm: allocate large pages to guests Ian Campbell
@ 2014-07-09 12:07 ` Ian Campbell
2014-07-09 12:07 ` [PATCH v5 5/8] xen: arm: handle superpage mappings in p2m_lookup Ian Campbell
` (4 subsequent siblings)
8 siblings, 0 replies; 20+ messages in thread
From: Ian Campbell @ 2014-07-09 12:07 UTC (permalink / raw)
To: xen-devel; +Cc: julien.grall, tim, Ian Campbell, stefano.stabellini
In particular do not do it for CACHEFLUSH.
INSERT, RELINQUISH and REMOVE should all put the page (if the current pte is
valid). ALLOCATE doesn't need to since it asserts the current PTE must be
invalid.
Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
Acked-by: Julien Grall <julien.grall@linaro.org>
---
v2: actual move the put page instead of adding a second one.
---
xen/arch/arm/p2m.c | 35 +++++++++++++++++++++--------------
1 file changed, 21 insertions(+), 14 deletions(-)
diff --git a/xen/arch/arm/p2m.c b/xen/arch/arm/p2m.c
index 9960e17..ea05b6d 100644
--- a/xen/arch/arm/p2m.c
+++ b/xen/arch/arm/p2m.c
@@ -299,6 +299,23 @@ enum p2m_operation {
CACHEFLUSH,
};
+static void p2m_put_page(const lpae_t pte)
+{
+ /* TODO: Handle other p2m types
+ *
+ * It's safe to do the put_page here because page_alloc will
+ * flush the TLBs if the page is reallocated before the end of
+ * this loop.
+ */
+ if ( p2m_is_foreign(pte.p2m.type) )
+ {
+ unsigned long mfn = pte.p2m.base;
+
+ ASSERT(mfn_valid(mfn));
+ put_page(mfn_to_page(mfn));
+ }
+}
+
static int apply_p2m_changes(struct domain *d,
enum p2m_operation op,
paddr_t start_gpaddr,
@@ -400,20 +417,6 @@ static int apply_p2m_changes(struct domain *d,
flush |= pte.p2m.valid;
- /* TODO: Handle other p2m type
- *
- * It's safe to do the put_page here because page_alloc will
- * flush the TLBs if the page is reallocated before the end of
- * this loop.
- */
- if ( pte.p2m.valid && p2m_is_foreign(pte.p2m.type) )
- {
- unsigned long mfn = pte.p2m.base;
-
- ASSERT(mfn_valid(mfn));
- put_page(mfn_to_page(mfn));
- }
-
switch (op) {
case ALLOCATE:
{
@@ -436,6 +439,8 @@ static int apply_p2m_changes(struct domain *d,
break;
case INSERT:
{
+ if ( pte.p2m.valid )
+ p2m_put_page(pte);
pte = mfn_to_p2m_entry(maddr >> PAGE_SHIFT, mattr, t);
p2m_write_pte(&third[third_table_offset(addr)],
pte, flush_pt);
@@ -451,6 +456,8 @@ static int apply_p2m_changes(struct domain *d,
break;
}
+ p2m_put_page(pte);
+
count += 0x10;
memset(&pte, 0x00, sizeof(pte));
--
1.7.10.4
^ permalink raw reply related [flat|nested] 20+ messages in thread* [PATCH v5 5/8] xen: arm: handle superpage mappings in p2m_lookup
2014-07-09 12:06 [PATCH v5 0/8] xen: arm: Use super pages in p2m Ian Campbell
` (3 preceding siblings ...)
2014-07-09 12:07 ` [PATCH v5 4/8] xen: arm: only put_page for p2m operations which require it Ian Campbell
@ 2014-07-09 12:07 ` Ian Campbell
2014-07-09 12:07 ` [PATCH v5 6/8] xen: arm: add some helpers for assessing p2m pte Ian Campbell
` (3 subsequent siblings)
8 siblings, 0 replies; 20+ messages in thread
From: Ian Campbell @ 2014-07-09 12:07 UTC (permalink / raw)
To: xen-devel; +Cc: julien.grall, tim, Ian Campbell, stefano.stabellini
Currently none are actually created, but they will be shortly.
Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
Acked-by: Julien Grall <julien.grall@linaro.org>
---
xen/arch/arm/p2m.c | 9 ++++++++-
1 file changed, 8 insertions(+), 1 deletion(-)
diff --git a/xen/arch/arm/p2m.c b/xen/arch/arm/p2m.c
index ea05b6d..8a6d295 100644
--- a/xen/arch/arm/p2m.c
+++ b/xen/arch/arm/p2m.c
@@ -123,6 +123,7 @@ paddr_t p2m_lookup(struct domain *d, paddr_t paddr, p2m_type_t *t)
struct p2m_domain *p2m = &d->arch.p2m;
lpae_t pte, *first = NULL, *second = NULL, *third = NULL;
paddr_t maddr = INVALID_PADDR;
+ paddr_t mask;
p2m_type_t _t;
/* Allow t to be NULL */
@@ -136,15 +137,21 @@ paddr_t p2m_lookup(struct domain *d, paddr_t paddr, p2m_type_t *t)
if ( !first )
goto err;
+ mask = FIRST_MASK;
pte = first[first_table_offset(paddr)];
if ( !pte.p2m.valid || !pte.p2m.table )
goto done;
+ mask = SECOND_MASK;
second = map_domain_page(pte.p2m.base);
pte = second[second_table_offset(paddr)];
if ( !pte.p2m.valid || !pte.p2m.table )
goto done;
+ mask = THIRD_MASK;
+
+ BUILD_BUG_ON(THIRD_MASK != PAGE_MASK);
+
third = map_domain_page(pte.p2m.base);
pte = third[third_table_offset(paddr)];
@@ -156,7 +163,7 @@ done:
if ( pte.p2m.valid )
{
ASSERT(pte.p2m.type != p2m_invalid);
- maddr = (pte.bits & PADDR_MASK & PAGE_MASK) | (paddr & ~PAGE_MASK);
+ maddr = (pte.bits & PADDR_MASK & mask) | (paddr & ~mask);
*t = pte.p2m.type;
}
--
1.7.10.4
^ permalink raw reply related [flat|nested] 20+ messages in thread* [PATCH v5 6/8] xen: arm: add some helpers for assessing p2m pte
2014-07-09 12:06 [PATCH v5 0/8] xen: arm: Use super pages in p2m Ian Campbell
` (4 preceding siblings ...)
2014-07-09 12:07 ` [PATCH v5 5/8] xen: arm: handle superpage mappings in p2m_lookup Ian Campbell
@ 2014-07-09 12:07 ` Ian Campbell
2014-07-09 12:07 ` [PATCH v5 7/8] xen: arm: use superpages in p2m when pages are suitably aligned Ian Campbell
` (2 subsequent siblings)
8 siblings, 0 replies; 20+ messages in thread
From: Ian Campbell @ 2014-07-09 12:07 UTC (permalink / raw)
To: xen-devel; +Cc: julien.grall, tim, Ian Campbell, stefano.stabellini
Not terribly helpful right now, since they aren't widely used, but makes future
patches easier to read.
p2m_mapping is unused for the time-being and is therefore commented out
(otherwise the compiler complains about an unused function).
Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
Acked-by: Julien Grall <julien.grall@linaro.org>
---
v5: coding style
v3: Use static functions. s/p2m_entry/p2m_mapping/ as its a better name.
v2: clarify common on p2m_{table,entry}
---
xen/arch/arm/p2m.c | 32 +++++++++++++++++++++++++-------
1 file changed, 25 insertions(+), 7 deletions(-)
diff --git a/xen/arch/arm/p2m.c b/xen/arch/arm/p2m.c
index 8a6d295..cb22e9c 100644
--- a/xen/arch/arm/p2m.c
+++ b/xen/arch/arm/p2m.c
@@ -14,6 +14,24 @@
#define P2M_FIRST_ORDER 1
#define P2M_FIRST_ENTRIES (LPAE_ENTRIES<<P2M_FIRST_ORDER)
+static bool_t p2m_valid(lpae_t pte)
+{
+ return pte.p2m.valid;
+}
+/* These two can only be used on L0..L2 ptes because L3 mappings set
+ * the table bit and therefore these would return the opposite to what
+ * you would expect. */
+static bool_t p2m_table(lpae_t pte)
+{
+ return p2m_valid(pte) && pte.p2m.table;
+}
+#if 0
+static bool_t p2m_mapping(lpae_t pte)
+{
+ return p2m_valid(pte) && !pte.p2m.table;
+}
+#endif
+
void dump_p2m_lookup(struct domain *d, paddr_t addr)
{
struct p2m_domain *p2m = &d->arch.p2m;
@@ -139,13 +157,13 @@ paddr_t p2m_lookup(struct domain *d, paddr_t paddr, p2m_type_t *t)
mask = FIRST_MASK;
pte = first[first_table_offset(paddr)];
- if ( !pte.p2m.valid || !pte.p2m.table )
+ if ( !p2m_table(pte) )
goto done;
mask = SECOND_MASK;
second = map_domain_page(pte.p2m.base);
pte = second[second_table_offset(paddr)];
- if ( !pte.p2m.valid || !pte.p2m.table )
+ if ( !p2m_table(pte) )
goto done;
mask = THIRD_MASK;
@@ -156,11 +174,11 @@ paddr_t p2m_lookup(struct domain *d, paddr_t paddr, p2m_type_t *t)
pte = third[third_table_offset(paddr)];
/* This bit must be one in the level 3 entry */
- if ( !pte.p2m.table )
+ if ( !p2m_table(pte) )
pte.bits = 0;
done:
- if ( pte.p2m.valid )
+ if ( p2m_valid(pte) )
{
ASSERT(pte.p2m.type != p2m_invalid);
maddr = (pte.bits & PADDR_MASK & mask) | (paddr & ~mask);
@@ -367,7 +385,7 @@ static int apply_p2m_changes(struct domain *d,
cur_first_page = p2m_first_level_index(addr);
}
- if ( !first[first_table_offset(addr)].p2m.valid )
+ if ( !p2m_valid(first[first_table_offset(addr)]) )
{
if ( !populate )
{
@@ -384,7 +402,7 @@ static int apply_p2m_changes(struct domain *d,
}
}
- BUG_ON(!first[first_table_offset(addr)].p2m.valid);
+ BUG_ON(!p2m_valid(first[first_table_offset(addr)]));
if ( cur_first_offset != first_table_offset(addr) )
{
@@ -394,7 +412,7 @@ static int apply_p2m_changes(struct domain *d,
}
/* else: second already valid */
- if ( !second[second_table_offset(addr)].p2m.valid )
+ if ( !p2m_valid(second[second_table_offset(addr)]) )
{
if ( !populate )
{
--
1.7.10.4
^ permalink raw reply related [flat|nested] 20+ messages in thread* [PATCH v5 7/8] xen: arm: use superpages in p2m when pages are suitably aligned
2014-07-09 12:06 [PATCH v5 0/8] xen: arm: Use super pages in p2m Ian Campbell
` (5 preceding siblings ...)
2014-07-09 12:07 ` [PATCH v5 6/8] xen: arm: add some helpers for assessing p2m pte Ian Campbell
@ 2014-07-09 12:07 ` Ian Campbell
2014-07-09 16:28 ` Julien Grall
2014-07-09 12:07 ` [PATCH v5 8/8] xen: arm: allocate more than one bank for 1:1 domain 0 if needed Ian Campbell
2014-07-10 10:32 ` [PATCH v5 0/8] xen: arm: Use super pages in p2m Ian Campbell
8 siblings, 1 reply; 20+ messages in thread
From: Ian Campbell @ 2014-07-09 12:07 UTC (permalink / raw)
To: xen-devel; +Cc: julien.grall, tim, Ian Campbell, stefano.stabellini
This creates superpage (1G and 2M) mappings in the p2m for both domU and dom0
when the guest and machine addresses are suitably aligned. This relies on the
domain builder to allocate suitably sized regions, this is trivially true for
1:1 mapped dom0's and was arranged for guests in a previous patch. A non-1:1
dom0's memory is not currently deliberately aligned.
Since ARM pagetables are (mostly) consistent at each level this is implemented
by refactoring the handling of a single level of pagetable into a common
function. The two inconsistencies are that there are no superpage mappings at
level zero and that level three entry mappings must set the table bit.
When inserting new mappings the code shatters superpage mappings as necessary,
but currently makes no attempt to coalesce anything again. In particular when
inserting a mapping which could be a superpage over an existing table mapping
we do not attempt to free that lower page table and instead descend into it.
Some p2m statistics are added to keep track of the number of each level of
mapping and the number of times we've had to shatter an existing mapping.
Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
---
v5: Use p2m_valid() and p2m_table() where appropriate.
Really fix CACHEFLUSH
v4: On CACHEFLUSH flush the expected page, not the one after it.
v3: s/p2m_entry/p2m_mapping/ after similar change in previous patch
Increment addr/maddr for ALLOCATE case, tested with dom0_11_mapping = 0 (as
far as possible, which is to say it crashes mounting rootfs which involves
DMA)
Don't describe L3 as superpages, just say "aligned for mapping"
Consitently check level < 3 never level != 3
Comment for p2m_dump_info
Use ret for return value of apply_one_level, to avoid "count += rc".
Add comment on p2m->stats.
v2: p2m stats as unsigned long, to cope with numbers of 4K mappings which are
possible on both arm32 and arm64
Fix "decend"
Remove spurious {} around single line else clause.
Drop spurious changes to apply_p2m_changes callers.
fixup
---
xen/arch/arm/domain.c | 1 +
xen/arch/arm/p2m.c | 496 ++++++++++++++++++++++++++++++++++-----------
xen/include/asm-arm/p2m.h | 12 ++
3 files changed, 388 insertions(+), 121 deletions(-)
diff --git a/xen/arch/arm/domain.c b/xen/arch/arm/domain.c
index bb5c810..e275f7d 100644
--- a/xen/arch/arm/domain.c
+++ b/xen/arch/arm/domain.c
@@ -747,6 +747,7 @@ int domain_relinquish_resources(struct domain *d)
void arch_dump_domain_info(struct domain *d)
{
+ p2m_dump_info(d);
}
diff --git a/xen/arch/arm/p2m.c b/xen/arch/arm/p2m.c
index cb22e9c..642591b 100644
--- a/xen/arch/arm/p2m.c
+++ b/xen/arch/arm/p2m.c
@@ -1,6 +1,7 @@
#include <xen/config.h>
#include <xen/sched.h>
#include <xen/lib.h>
+#include <xen/stdbool.h>
#include <xen/errno.h>
#include <xen/domain_page.h>
#include <xen/bitops.h>
@@ -25,12 +26,26 @@ static bool_t p2m_table(lpae_t pte)
{
return p2m_valid(pte) && pte.p2m.table;
}
-#if 0
static bool_t p2m_mapping(lpae_t pte)
{
return p2m_valid(pte) && !pte.p2m.table;
}
-#endif
+
+void p2m_dump_info(struct domain *d)
+{
+ struct p2m_domain *p2m = &d->arch.p2m;
+
+ spin_lock(&p2m->lock);
+ printk("p2m mappings for domain %d (vmid %d):\n",
+ d->domain_id, p2m->vmid);
+ BUG_ON(p2m->stats.mappings[0] || p2m->stats.shattered[0]);
+ printk(" 1G mappings: %ld (shattered %ld)\n",
+ p2m->stats.mappings[1], p2m->stats.shattered[1]);
+ printk(" 2M mappings: %ld (shattered %ld)\n",
+ p2m->stats.mappings[2], p2m->stats.shattered[2]);
+ printk(" 4K mappings: %ld\n", p2m->stats.mappings[3]);
+ spin_unlock(&p2m->lock);
+}
void dump_p2m_lookup(struct domain *d, paddr_t addr)
{
@@ -287,15 +302,26 @@ static inline void p2m_write_pte(lpae_t *p, lpae_t pte, bool_t flush_cache)
clean_xen_dcache(*p);
}
-/* Allocate a new page table page and hook it in via the given entry */
-static int p2m_create_table(struct domain *d, lpae_t *entry, bool_t flush_cache)
+/*
+ * Allocate a new page table page and hook it in via the given entry.
+ * apply_one_level relies on this returning 0 on success
+ * and -ve on failure.
+ *
+ * If the existing entry is present then it must be a mapping and not
+ * a table and it will be shattered into the next level down.
+ *
+ * level_shift is the number of bits at the level we want to create.
+ */
+static int p2m_create_table(struct domain *d, lpae_t *entry,
+ int level_shift, bool_t flush_cache)
{
struct p2m_domain *p2m = &d->arch.p2m;
struct page_info *page;
- void *p;
+ lpae_t *p;
lpae_t pte;
+ int splitting = p2m_valid(*entry);
- BUG_ON(entry->p2m.valid);
+ BUG_ON(p2m_table(*entry));
page = alloc_domheap_page(NULL, 0);
if ( page == NULL )
@@ -304,9 +330,37 @@ static int p2m_create_table(struct domain *d, lpae_t *entry, bool_t flush_cache)
page_list_add(page, &p2m->pages);
p = __map_domain_page(page);
- clear_page(p);
+ if ( splitting )
+ {
+ p2m_type_t t = entry->p2m.type;
+ unsigned long base_pfn = entry->p2m.base;
+ int i;
+
+ /*
+ * We are either splitting a first level 1G page into 512 second level
+ * 2M pages, or a second level 2M page into 512 third level 4K pages.
+ */
+ for ( i=0 ; i < LPAE_ENTRIES; i++ )
+ {
+ pte = mfn_to_p2m_entry(base_pfn + (i<<(level_shift-LPAE_SHIFT)),
+ MATTR_MEM, t);
+
+ /*
+ * First and second level super pages set p2m.table = 0, but
+ * third level entries set table = 1.
+ */
+ if ( level_shift - LPAE_SHIFT )
+ pte.p2m.table = 0;
+
+ write_pte(&p[i], pte);
+ }
+ }
+ else
+ clear_page(p);
+
if ( flush_cache )
clean_xen_dcache_va_range(p, PAGE_SIZE);
+
unmap_domain_page(p);
pte = mfn_to_p2m_entry(page_to_mfn(page), MATTR_MEM, p2m_invalid);
@@ -324,8 +378,14 @@ enum p2m_operation {
CACHEFLUSH,
};
-static void p2m_put_page(const lpae_t pte)
+/* Put any references on the single 4K page referenced by pte. TODO:
+ * Handle superpages, for now we only take special references for leaf
+ * pages (specifically foreign ones, which can't be super mapped today).
+ */
+static void p2m_put_l3_page(const lpae_t pte)
{
+ ASSERT(p2m_valid(pte));
+
/* TODO: Handle other p2m types
*
* It's safe to do the put_page here because page_alloc will
@@ -341,6 +401,263 @@ static void p2m_put_page(const lpae_t pte)
}
}
+/*
+ * Returns true if start_gpaddr..end_gpaddr contains at least one
+ * suitably aligned level_size mappping of maddr.
+ *
+ * So long as the range is large enough the end_gpaddr need not be
+ * aligned (callers should create one superpage mapping based on this
+ * result and then call this again on the new range, eventually the
+ * slop at the end will cause this function to return false).
+ */
+static bool_t is_mapping_aligned(const paddr_t start_gpaddr,
+ const paddr_t end_gpaddr,
+ const paddr_t maddr,
+ const paddr_t level_size)
+{
+ const paddr_t level_mask = level_size - 1;
+
+ /* No hardware superpages at level 0 */
+ if ( level_size == ZEROETH_SIZE )
+ return false;
+
+ /*
+ * A range smaller than the size of a superpage at this level
+ * cannot be superpage aligned.
+ */
+ if ( ( end_gpaddr - start_gpaddr ) < level_size - 1 )
+ return false;
+
+ /* Both the gpaddr and maddr must be aligned */
+ if ( start_gpaddr & level_mask )
+ return false;
+ if ( maddr & level_mask )
+ return false;
+ return true;
+}
+
+#define P2M_ONE_DESCEND 0
+#define P2M_ONE_PROGRESS_NOP 0x1
+#define P2M_ONE_PROGRESS 0x10
+
+/*
+ * 0 == (P2M_ONE_DESCEND) continue to descend the tree
+ * +ve == (P2M_ONE_PROGRESS_*) handled at this level, continue, flush,
+ * entry, addr and maddr updated. Return value is an
+ * indication of the amount of work done (for preemption).
+ * -ve == (-Exxx) error.
+ */
+static int apply_one_level(struct domain *d,
+ lpae_t *entry,
+ unsigned int level,
+ bool_t flush_cache,
+ enum p2m_operation op,
+ paddr_t start_gpaddr,
+ paddr_t end_gpaddr,
+ paddr_t *addr,
+ paddr_t *maddr,
+ bool_t *flush,
+ int mattr,
+ p2m_type_t t)
+{
+ /* Helpers to lookup the properties of each level */
+ const paddr_t level_sizes[] =
+ { ZEROETH_SIZE, FIRST_SIZE, SECOND_SIZE, THIRD_SIZE };
+ const paddr_t level_masks[] =
+ { ZEROETH_MASK, FIRST_MASK, SECOND_MASK, THIRD_MASK };
+ const paddr_t level_shifts[] =
+ { ZEROETH_SHIFT, FIRST_SHIFT, SECOND_SHIFT, THIRD_SHIFT };
+ const paddr_t level_size = level_sizes[level];
+ const paddr_t level_mask = level_masks[level];
+ const paddr_t level_shift = level_shifts[level];
+
+ struct p2m_domain *p2m = &d->arch.p2m;
+ lpae_t pte;
+ const lpae_t orig_pte = *entry;
+ int rc;
+
+ BUG_ON(level > 3);
+
+ switch ( op )
+ {
+ case ALLOCATE:
+ ASSERT(level < 3 || !p2m_valid(orig_pte));
+ ASSERT(*maddr == 0);
+
+ if ( p2m_valid(orig_pte) )
+ return P2M_ONE_DESCEND;
+
+ if ( is_mapping_aligned(*addr, end_gpaddr, 0, level_size) )
+ {
+ struct page_info *page;
+
+ page = alloc_domheap_pages(d, level_shift - PAGE_SHIFT, 0);
+ if ( page )
+ {
+ pte = mfn_to_p2m_entry(page_to_mfn(page), mattr, t);
+ if ( level < 3 )
+ pte.p2m.table = 0;
+ p2m_write_pte(entry, pte, flush_cache);
+ p2m->stats.mappings[level]++;
+
+ *addr += level_size;
+ *maddr += level_size;
+
+ return P2M_ONE_PROGRESS;
+ }
+ else if ( level == 3 )
+ return -ENOMEM;
+ }
+
+ /* L3 is always suitably aligned for mapping (handled, above) */
+ BUG_ON(level == 3);
+
+ /*
+ * If we get here then we failed to allocate a sufficiently
+ * large contiguous region for this level (which can't be
+ * L3). Create a page table and continue to descend so we try
+ * smaller allocations.
+ */
+ rc = p2m_create_table(d, entry, 0, flush_cache);
+ if ( rc < 0 )
+ return rc;
+
+ return P2M_ONE_DESCEND;
+
+ case INSERT:
+ if ( is_mapping_aligned(*addr, end_gpaddr, *maddr, level_size) &&
+ /* We do not handle replacing an existing table with a superpage */
+ (level == 3 || !p2m_table(orig_pte)) )
+ {
+ /* New mapping is superpage aligned, make it */
+ pte = mfn_to_p2m_entry(*maddr >> PAGE_SHIFT, mattr, t);
+ if ( level < 3 )
+ pte.p2m.table = 0; /* Superpage entry */
+
+ p2m_write_pte(entry, pte, flush_cache);
+
+ *flush |= p2m_valid(orig_pte);
+
+ *addr += level_size;
+ *maddr += level_size;
+
+ if ( p2m_valid(orig_pte) )
+ {
+ /*
+ * We can't currently get here for an existing table
+ * mapping, since we don't handle replacing an
+ * existing table with a superpage. If we did we would
+ * need to handle freeing (and accounting) for the bit
+ * of the p2m tree which we would be about to lop off.
+ */
+ BUG_ON(level < 3 && p2m_table(orig_pte));
+ if ( level == 3 )
+ p2m_put_l3_page(orig_pte);
+ }
+ else /* New mapping */
+ p2m->stats.mappings[level]++;
+
+ return P2M_ONE_PROGRESS;
+ }
+ else
+ {
+ /* New mapping is not superpage aligned, create a new table entry */
+
+ /* L3 is always suitably aligned for mapping (handled, above) */
+ BUG_ON(level == 3);
+
+ /* Not present -> create table entry and descend */
+ if ( !p2m_valid(orig_pte) )
+ {
+ rc = p2m_create_table(d, entry, 0, flush_cache);
+ if ( rc < 0 )
+ return rc;
+ return P2M_ONE_DESCEND;
+ }
+
+ /* Existing superpage mapping -> shatter and descend */
+ if ( p2m_mapping(orig_pte) )
+ {
+ *flush = true;
+ rc = p2m_create_table(d, entry,
+ level_shift - PAGE_SHIFT, flush_cache);
+ if ( rc < 0 )
+ return rc;
+
+ p2m->stats.shattered[level]++;
+ p2m->stats.mappings[level]--;
+ p2m->stats.mappings[level+1] += LPAE_ENTRIES;
+ } /* else: an existing table mapping -> descend */
+
+ BUG_ON(!p2m_table(*entry));
+
+ return P2M_ONE_DESCEND;
+ }
+
+ break;
+
+ case RELINQUISH:
+ case REMOVE:
+ if ( !p2m_valid(orig_pte) )
+ {
+ /* Progress up to next boundary */
+ *addr = (*addr + level_size) & level_mask;
+ return P2M_ONE_PROGRESS_NOP;
+ }
+
+ if ( level < 3 && p2m_table(orig_pte) )
+ return P2M_ONE_DESCEND;
+
+ *flush = true;
+
+ memset(&pte, 0x00, sizeof(pte));
+ p2m_write_pte(entry, pte, flush_cache);
+
+ *addr += level_size;
+
+ p2m->stats.mappings[level]--;
+
+ if ( level == 3 )
+ p2m_put_l3_page(orig_pte);
+
+ /*
+ * This is still a single pte write, no matter the level, so no need to
+ * scale.
+ */
+ return P2M_ONE_PROGRESS;
+
+ case CACHEFLUSH:
+ if ( !p2m_valid(orig_pte) )
+ {
+ *addr = (*addr + level_size) & level_mask;
+ return P2M_ONE_PROGRESS_NOP;
+ }
+
+ if ( level < 3 && p2m_table(orig_pte) )
+ return P2M_ONE_DESCEND;
+
+ /*
+ * could flush up to the next boundary, but would need to be
+ * careful about preemption, so just do one page now and loop.
+ */
+ if ( p2m_is_ram(orig_pte.p2m.type) )
+ {
+ unsigned long offset = paddr_to_pfn(*addr & ~level_mask);
+ flush_page_to_ram(orig_pte.p2m.base + offset);
+
+ *addr += PAGE_SIZE;
+ return P2M_ONE_PROGRESS;
+ }
+ else
+ {
+ *addr += PAGE_SIZE;
+ return P2M_ONE_PROGRESS_NOP;
+ }
+ }
+
+ BUG(); /* Should never get here */
+}
+
static int apply_p2m_changes(struct domain *d,
enum p2m_operation op,
paddr_t start_gpaddr,
@@ -349,7 +666,7 @@ static int apply_p2m_changes(struct domain *d,
int mattr,
p2m_type_t t)
{
- int rc;
+ int rc, ret;
struct p2m_domain *p2m = &d->arch.p2m;
lpae_t *first = NULL, *second = NULL, *third = NULL;
paddr_t addr;
@@ -357,9 +674,7 @@ static int apply_p2m_changes(struct domain *d,
cur_first_offset = ~0,
cur_second_offset = ~0;
unsigned long count = 0;
- unsigned int flush = 0;
- bool_t populate = (op == INSERT || op == ALLOCATE);
- lpae_t pte;
+ bool_t flush = false;
bool_t flush_pt;
/* Some IOMMU don't support coherent PT walk. When the p2m is
@@ -373,6 +688,25 @@ static int apply_p2m_changes(struct domain *d,
addr = start_gpaddr;
while ( addr < end_gpaddr )
{
+ /*
+ * Arbitrarily, preempt every 512 operations or 8192 nops.
+ * 512*P2M_ONE_PROGRESS == 8192*P2M_ONE_PROGRESS_NOP == 0x2000
+ *
+ * count is initialised to 0 above, so we are guaranteed to
+ * always make at least one pass.
+ */
+
+ if ( op == RELINQUISH && count >= 0x2000 )
+ {
+ if ( hypercall_preempt_check() )
+ {
+ p2m->lowest_mapped_gfn = addr >> PAGE_SHIFT;
+ rc = -ERESTART;
+ goto out;
+ }
+ count = 0;
+ }
+
if ( cur_first_page != p2m_first_level_index(addr) )
{
if ( first ) unmap_domain_page(first);
@@ -385,22 +719,18 @@ static int apply_p2m_changes(struct domain *d,
cur_first_page = p2m_first_level_index(addr);
}
- if ( !p2m_valid(first[first_table_offset(addr)]) )
- {
- if ( !populate )
- {
- addr = (addr + FIRST_SIZE) & FIRST_MASK;
- continue;
- }
+ /* We only use a 3 level p2m at the moment, so no level 0,
+ * current hardware doesn't support super page mappings at
+ * level 0 anyway */
- rc = p2m_create_table(d, &first[first_table_offset(addr)],
- flush_pt);
- if ( rc < 0 )
- {
- printk("p2m_populate_ram: L1 failed\n");
- goto out;
- }
- }
+ ret = apply_one_level(d, &first[first_table_offset(addr)],
+ 1, flush_pt, op,
+ start_gpaddr, end_gpaddr,
+ &addr, &maddr, &flush,
+ mattr, t);
+ if ( ret < 0 ) { rc = ret ; goto out; }
+ count += ret;
+ if ( ret != P2M_ONE_DESCEND ) continue;
BUG_ON(!p2m_valid(first[first_table_offset(addr)]));
@@ -412,23 +742,16 @@ static int apply_p2m_changes(struct domain *d,
}
/* else: second already valid */
- if ( !p2m_valid(second[second_table_offset(addr)]) )
- {
- if ( !populate )
- {
- addr = (addr + SECOND_SIZE) & SECOND_MASK;
- continue;
- }
-
- rc = p2m_create_table(d, &second[second_table_offset(addr)],
- flush_pt);
- if ( rc < 0 ) {
- printk("p2m_populate_ram: L2 failed\n");
- goto out;
- }
- }
+ ret = apply_one_level(d,&second[second_table_offset(addr)],
+ 2, flush_pt, op,
+ start_gpaddr, end_gpaddr,
+ &addr, &maddr, &flush,
+ mattr, t);
+ if ( ret < 0 ) { rc = ret ; goto out; }
+ count += ret;
+ if ( ret != P2M_ONE_DESCEND ) continue;
- BUG_ON(!second[second_table_offset(addr)].p2m.valid);
+ BUG_ON(!p2m_valid(second[second_table_offset(addr)]));
if ( cur_second_offset != second_table_offset(addr) )
{
@@ -438,84 +761,15 @@ static int apply_p2m_changes(struct domain *d,
cur_second_offset = second_table_offset(addr);
}
- pte = third[third_table_offset(addr)];
-
- flush |= pte.p2m.valid;
-
- switch (op) {
- case ALLOCATE:
- {
- /* Allocate a new RAM page and attach */
- struct page_info *page;
-
- ASSERT(!pte.p2m.valid);
- rc = -ENOMEM;
- page = alloc_domheap_page(d, 0);
- if ( page == NULL ) {
- printk("p2m_populate_ram: failed to allocate page\n");
- goto out;
- }
-
- pte = mfn_to_p2m_entry(page_to_mfn(page), mattr, t);
-
- p2m_write_pte(&third[third_table_offset(addr)],
- pte, flush_pt);
- }
- break;
- case INSERT:
- {
- if ( pte.p2m.valid )
- p2m_put_page(pte);
- pte = mfn_to_p2m_entry(maddr >> PAGE_SHIFT, mattr, t);
- p2m_write_pte(&third[third_table_offset(addr)],
- pte, flush_pt);
- maddr += PAGE_SIZE;
- }
- break;
- case RELINQUISH:
- case REMOVE:
- {
- if ( !pte.p2m.valid )
- {
- count++;
- break;
- }
-
- p2m_put_page(pte);
-
- count += 0x10;
-
- memset(&pte, 0x00, sizeof(pte));
- p2m_write_pte(&third[third_table_offset(addr)],
- pte, flush_pt);
- count++;
- }
- break;
-
- case CACHEFLUSH:
- {
- if ( !pte.p2m.valid || !p2m_is_ram(pte.p2m.type) )
- break;
-
- flush_page_to_ram(pte.p2m.base);
- }
- break;
- }
-
- /* Preempt every 2MiB (mapped) or 32 MiB (unmapped) - arbitrary */
- if ( op == RELINQUISH && count >= 0x2000 )
- {
- if ( hypercall_preempt_check() )
- {
- p2m->lowest_mapped_gfn = addr >> PAGE_SHIFT;
- rc = -ERESTART;
- goto out;
- }
- count = 0;
- }
-
- /* Got the next page */
- addr += PAGE_SIZE;
+ ret = apply_one_level(d, &third[third_table_offset(addr)],
+ 3, flush_pt, op,
+ start_gpaddr, end_gpaddr,
+ &addr, &maddr, &flush,
+ mattr, t);
+ if ( ret < 0 ) { rc = ret ; goto out; }
+ /* L3 had better have done something! We cannot descend any further */
+ BUG_ON(ret == P2M_ONE_DESCEND);
+ count += ret;
}
if ( flush )
diff --git a/xen/include/asm-arm/p2m.h b/xen/include/asm-arm/p2m.h
index 911d32d..327a79d 100644
--- a/xen/include/asm-arm/p2m.h
+++ b/xen/include/asm-arm/p2m.h
@@ -29,6 +29,15 @@ struct p2m_domain {
* resume the search. Apart from during teardown this can only
* decrease. */
unsigned long lowest_mapped_gfn;
+
+ /* Gather some statistics for information purposes only */
+ struct {
+ /* Number of mappings at each p2m tree level */
+ unsigned long mappings[4];
+ /* Number of times we have shattered a mapping
+ * at each p2m tree level. */
+ unsigned long shattered[4];
+ } stats;
};
/* List of possible type for each page in the p2m entry.
@@ -79,6 +88,9 @@ int p2m_alloc_table(struct domain *d);
void p2m_save_state(struct vcpu *p);
void p2m_restore_state(struct vcpu *n);
+/* Print debugging/statistial info about a domain's p2m */
+void p2m_dump_info(struct domain *d);
+
/* Look up the MFN corresponding to a domain's PFN. */
paddr_t p2m_lookup(struct domain *d, paddr_t gpfn, p2m_type_t *t);
--
1.7.10.4
^ permalink raw reply related [flat|nested] 20+ messages in thread* Re: [PATCH v5 7/8] xen: arm: use superpages in p2m when pages are suitably aligned
2014-07-09 12:07 ` [PATCH v5 7/8] xen: arm: use superpages in p2m when pages are suitably aligned Ian Campbell
@ 2014-07-09 16:28 ` Julien Grall
2014-07-09 17:11 ` Ian Campbell
0 siblings, 1 reply; 20+ messages in thread
From: Julien Grall @ 2014-07-09 16:28 UTC (permalink / raw)
To: Ian Campbell, xen-devel; +Cc: tim, stefano.stabellini
Hi Ian,
On 07/09/2014 01:07 PM, Ian Campbell wrote:
> diff --git a/xen/arch/arm/p2m.c b/xen/arch/arm/p2m.c
> index cb22e9c..642591b 100644
> --- a/xen/arch/arm/p2m.c
> +++ b/xen/arch/arm/p2m.c
[..]
> + case CACHEFLUSH:
> + if ( !p2m_valid(orig_pte) )
> + {
> + *addr = (*addr + level_size) & level_mask;
> + return P2M_ONE_PROGRESS_NOP;
> + }
> +
> + if ( level < 3 && p2m_table(orig_pte) )
> + return P2M_ONE_DESCEND;
> + /*
> + * could flush up to the next boundary, but would need to be
> + * careful about preemption, so just do one page now and loop.
At the first glance I though this code didn't handle correctly superpage
flush. It took me several minutes to understand that you rely
P2M_ONE_PROGRESS{,_NOP} to do the job for you.
Can you explain this trick in the commit message?
With this changes:
Acked-by: Julien Grall <julien.grall@linaro.org>
Regards,
--
Julien Grall
^ permalink raw reply [flat|nested] 20+ messages in thread* Re: [PATCH v5 7/8] xen: arm: use superpages in p2m when pages are suitably aligned
2014-07-09 16:28 ` Julien Grall
@ 2014-07-09 17:11 ` Ian Campbell
2014-07-10 10:36 ` Julien Grall
0 siblings, 1 reply; 20+ messages in thread
From: Ian Campbell @ 2014-07-09 17:11 UTC (permalink / raw)
To: Julien Grall; +Cc: stefano.stabellini, tim, xen-devel
On Wed, 2014-07-09 at 17:28 +0100, Julien Grall wrote:
> > + /*
> > + * could flush up to the next boundary, but would need to be
> > + * careful about preemption, so just do one page now and loop.
>
> At the first glance I though this code didn't handle correctly superpage
> flush. It took me several minutes to understand that you rely
> P2M_ONE_PROGRESS{,_NOP} to do the job for you.
>
> Can you explain this trick in the commit message?
That's what the existing comment which you've quoted is attempting to
explain. Is it not clear enough? Can you suggest an improvement?
Would "up to the next superpage boundary ... do one 4K page now and
loop" suffice?
> With this changes:
>
> Acked-by: Julien Grall <julien.grall@linaro.org>
>
> Regards,
>
^ permalink raw reply [flat|nested] 20+ messages in thread* Re: [PATCH v5 7/8] xen: arm: use superpages in p2m when pages are suitably aligned
2014-07-09 17:11 ` Ian Campbell
@ 2014-07-10 10:36 ` Julien Grall
2014-07-10 11:17 ` Ian Campbell
0 siblings, 1 reply; 20+ messages in thread
From: Julien Grall @ 2014-07-10 10:36 UTC (permalink / raw)
To: Ian Campbell; +Cc: stefano.stabellini, tim, xen-devel
On 09/07/14 18:11, Ian Campbell wrote:
> On Wed, 2014-07-09 at 17:28 +0100, Julien Grall wrote:
>>> + /*
>>> + * could flush up to the next boundary, but would need to be
>>> + * careful about preemption, so just do one page now and loop.
>>
>> At the first glance I though this code didn't handle correctly superpage
>> flush. It took me several minutes to understand that you rely
>> P2M_ONE_PROGRESS{,_NOP} to do the job for you.
>>
>> Can you explain this trick in the commit message?
>
> That's what the existing comment which you've quoted is attempting to
> explain. Is it not clear enough? Can you suggest an improvement?
>
> Would "up to the next superpage boundary ... do one 4K page now and
> loop" suffice?
I think the most confusing word is "loop". I was waiting for see a
"real" loop below.
I would explain that the outer function taking care of the loop.
Regards,
--
Julien Grall
^ permalink raw reply [flat|nested] 20+ messages in thread* Re: [PATCH v5 7/8] xen: arm: use superpages in p2m when pages are suitably aligned
2014-07-10 10:36 ` Julien Grall
@ 2014-07-10 11:17 ` Ian Campbell
2014-07-10 12:44 ` Julien Grall
0 siblings, 1 reply; 20+ messages in thread
From: Ian Campbell @ 2014-07-10 11:17 UTC (permalink / raw)
To: Julien Grall; +Cc: stefano.stabellini, tim, xen-devel
On Thu, 2014-07-10 at 11:36 +0100, Julien Grall wrote:
>
> On 09/07/14 18:11, Ian Campbell wrote:
> > On Wed, 2014-07-09 at 17:28 +0100, Julien Grall wrote:
> >>> + /*
> >>> + * could flush up to the next boundary, but would need to be
> >>> + * careful about preemption, so just do one page now and loop.
> >>
> >> At the first glance I though this code didn't handle correctly superpage
> >> flush. It took me several minutes to understand that you rely
> >> P2M_ONE_PROGRESS{,_NOP} to do the job for you.
> >>
> >> Can you explain this trick in the commit message?
> >
> > That's what the existing comment which you've quoted is attempting to
> > explain. Is it not clear enough? Can you suggest an improvement?
> >
> > Would "up to the next superpage boundary ... do one 4K page now and
> > loop" suffice?
>
> I think the most confusing word is "loop". I was waiting for see a
> "real" loop below.
>
> I would explain that the outer function taking care of the loop.
OK.
* could flush up to the next superpage boundary, but would need to be
* careful about preemption, so just do one 4K page now and return
* P2M_ONE_PROGRESS so that the caller will continue to loop over the
* rest of the range.
?
Ian.
>
> Regards,
>
^ permalink raw reply [flat|nested] 20+ messages in thread* Re: [PATCH v5 7/8] xen: arm: use superpages in p2m when pages are suitably aligned
2014-07-10 11:17 ` Ian Campbell
@ 2014-07-10 12:44 ` Julien Grall
2014-07-10 15:22 ` Ian Campbell
0 siblings, 1 reply; 20+ messages in thread
From: Julien Grall @ 2014-07-10 12:44 UTC (permalink / raw)
To: Ian Campbell; +Cc: stefano.stabellini, tim, xen-devel
On 10/07/14 12:17, Ian Campbell wrote:
> On Thu, 2014-07-10 at 11:36 +0100, Julien Grall wrote:
>>
>> On 09/07/14 18:11, Ian Campbell wrote:
>>> On Wed, 2014-07-09 at 17:28 +0100, Julien Grall wrote:
>>>>> + /*
>>>>> + * could flush up to the next boundary, but would need to be
>>>>> + * careful about preemption, so just do one page now and loop.
>>>>
>>>> At the first glance I though this code didn't handle correctly superpage
>>>> flush. It took me several minutes to understand that you rely
>>>> P2M_ONE_PROGRESS{,_NOP} to do the job for you.
>>>>
>>>> Can you explain this trick in the commit message?
>>>
>>> That's what the existing comment which you've quoted is attempting to
>>> explain. Is it not clear enough? Can you suggest an improvement?
>>>
>>> Would "up to the next superpage boundary ... do one 4K page now and
>>> loop" suffice?
>>
>> I think the most confusing word is "loop". I was waiting for see a
>> "real" loop below.
>>
>> I would explain that the outer function taking care of the loop.
>
> OK.
>
> * could flush up to the next superpage boundary, but would need to be
> * careful about preemption, so just do one 4K page now and return
> * P2M_ONE_PROGRESS so that the caller will continue to loop over the
> * rest of the range.
>
> ?
It looks better for me.
Thanks,
--
Julien Grall
^ permalink raw reply [flat|nested] 20+ messages in thread* Re: [PATCH v5 7/8] xen: arm: use superpages in p2m when pages are suitably aligned
2014-07-10 12:44 ` Julien Grall
@ 2014-07-10 15:22 ` Ian Campbell
0 siblings, 0 replies; 20+ messages in thread
From: Ian Campbell @ 2014-07-10 15:22 UTC (permalink / raw)
To: Julien Grall; +Cc: stefano.stabellini, tim, xen-devel
On Thu, 2014-07-10 at 13:44 +0100, Julien Grall wrote:
>
> On 10/07/14 12:17, Ian Campbell wrote:
> > * could flush up to the next superpage boundary, but would need to be
> > * careful about preemption, so just do one 4K page now and return
> > * P2M_ONE_PROGRESS so that the caller will continue to loop over the
> > * rest of the range.
> >
> > ?
>
> It looks better for me.
Thanks. I've taken that to invoke your previous:
> With this changes:
>
> Acked-by: Julien Grall <julien.grall@linaro.org>
and applied both this patch and the last one (already acked).
Cheers,
Ian.
^ permalink raw reply [flat|nested] 20+ messages in thread
* [PATCH v5 8/8] xen: arm: allocate more than one bank for 1:1 domain 0 if needed
2014-07-09 12:06 [PATCH v5 0/8] xen: arm: Use super pages in p2m Ian Campbell
` (6 preceding siblings ...)
2014-07-09 12:07 ` [PATCH v5 7/8] xen: arm: use superpages in p2m when pages are suitably aligned Ian Campbell
@ 2014-07-09 12:07 ` Ian Campbell
2014-07-09 16:40 ` Julien Grall
2014-07-10 10:32 ` [PATCH v5 0/8] xen: arm: Use super pages in p2m Ian Campbell
8 siblings, 1 reply; 20+ messages in thread
From: Ian Campbell @ 2014-07-09 12:07 UTC (permalink / raw)
To: xen-devel; +Cc: julien.grall, tim, Ian Campbell, stefano.stabellini
Depending on where Xen and the initial modules were loaded into RAM we may not
be able to allocate a suitably contiguous block of memory for dom0. Especially
since the allocations made by alloc_domheap_pages are naturally aligned (e.g. a
1GB allocation must be at a 1GB boundary).
The alignment requirement in particular is a huge limitation, meaning that even
dom0_mem0=1G on a 2GB system is pretty likely to fail unless you are very
careful with your load addresses. People were also having trouble with dom0 >
128MB on the 1GB cubieboard2 when using fairly standard load addresses for
things.
This patch tries to allocate multiple banks of memory in order to try and
satisfy the entire requested domain 0 allocation. Sadly this turns out to be
pretty tricky to arrange (see the large comment in the code).
Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
Cc: Karim Raslan <karim.allah.ahmed@gmail.com>
---
v4:
Include bits<=32 rather than < 32
Allow new banks below bank 0 iff they are at least 128M in size.
v3:
Handle running out of banks more gracefully
Allow order >= min_low_order, not strictly greater. Otherwise
dom0_mem=128M doesn't work.
v2: New patch
---
xen/arch/arm/domain_build.c | 288 +++++++++++++++++++++++++++++++++++++++----
1 file changed, 266 insertions(+), 22 deletions(-)
diff --git a/xen/arch/arm/domain_build.c b/xen/arch/arm/domain_build.c
index 8c850ca..69188a4 100644
--- a/xen/arch/arm/domain_build.c
+++ b/xen/arch/arm/domain_build.c
@@ -45,6 +45,13 @@ custom_param("dom0_mem", parse_dom0_mem);
# define DPRINT(fmt, args...) do {} while ( 0 )
#endif
+//#define DEBUG_11_ALLOCATION
+#ifdef DEBUG_11_ALLOCATION
+# define D11PRINT(fmt, args...) printk(XENLOG_DEBUG fmt, ##args)
+#else
+# define D11PRINT(fmt, args...) do {} while ( 0 )
+#endif
+
/*
* Amount of extra space required to dom0's device tree. No new nodes
* are added (yet) but one terminating reserve map entry (16 bytes) is
@@ -67,39 +74,276 @@ struct vcpu *__init alloc_dom0_vcpu0(struct domain *dom0)
return alloc_vcpu(dom0, 0, 0);
}
-static void allocate_memory_11(struct domain *d, struct kernel_info *kinfo)
+static unsigned int get_11_allocation_size(paddr_t size)
{
- paddr_t start;
- paddr_t size;
- struct page_info *pg;
- unsigned int order = get_order_from_bytes(dom0_mem);
- int res;
- paddr_t spfn;
+ /*
+ * get_order_from_bytes returns the order greater than or equal to
+ * the given size, but we need less than or equal. Adding one to
+ * the size pushes an evenly aligned size into the next order, so
+ * we can then unconditionally subtract 1 from the order which is
+ * returned.
+ */
+ return get_order_from_bytes(size + 1) - 1;
+}
- if ( is_32bit_domain(d) )
- pg = alloc_domheap_pages(d, order, MEMF_bits(32));
- else
- pg = alloc_domheap_pages(d, order, 0);
- if ( !pg )
- panic("Failed to allocate contiguous memory for dom0");
+/*
+ * Insert the given pages into a memory bank, banks are ordered by address.
+ *
+ * Returns false if the memory would be below bank 0 or we have run
+ * out of banks. In this case it will free the pages.
+ */
+static bool_t insert_11_bank(struct domain *d,
+ struct kernel_info *kinfo,
+ struct page_info *pg,
+ unsigned int order)
+{
+ int res, i;
+ paddr_t spfn;
+ paddr_t start, size;
spfn = page_to_mfn(pg);
start = pfn_to_paddr(spfn);
size = pfn_to_paddr((1 << order));
- // 1:1 mapping
- printk("Populate P2M %#"PRIx64"->%#"PRIx64" (1:1 mapping for dom0)\n",
- start, start + size);
- res = guest_physmap_add_page(d, spfn, spfn, order);
+ D11PRINT("Allocated %#"PRIpaddr"-%#"PRIpaddr" (%ldMB/%ldMB, order %d)\n",
+ start, start + size,
+ 1UL << (order+PAGE_SHIFT-20),
+ /* Don't want format this as PRIpaddr (16 digit hex) */
+ (unsigned long)(kinfo->unassigned_mem >> 20),
+ order);
- if ( res )
- panic("Unable to add pages in DOM0: %d", res);
+ if ( kinfo->mem.nr_banks > 0 &&
+ size < MB(128) &&
+ start + size < kinfo->mem.bank[0].start )
+ {
+ D11PRINT("Allocation below bank 0 is too small, not using\n");
+ goto fail;
+ }
- kinfo->mem.bank[0].start = start;
- kinfo->mem.bank[0].size = size;
- kinfo->mem.nr_banks = 1;
+ res = guest_physmap_add_page(d, spfn, spfn, order);
+ if ( res )
+ panic("Failed map pages to DOM0: %d", res);
kinfo->unassigned_mem -= size;
+
+ if ( kinfo->mem.nr_banks == 0 )
+ {
+ kinfo->mem.bank[0].start = start;
+ kinfo->mem.bank[0].size = size;
+ kinfo->mem.nr_banks = 1;
+ return true;
+ }
+
+ for( i = 0; i < kinfo->mem.nr_banks; i++ )
+ {
+ struct membank *bank = &kinfo->mem.bank[i];
+
+ /* If possible merge new memory into the start of the bank */
+ if ( bank->start == start+size )
+ {
+ bank->start = start;
+ bank->size += size;
+ return true;
+ }
+
+ /* If possible merge new memory onto the end of the bank */
+ if ( start == bank->start + bank->size )
+ {
+ bank->size += size;
+ return true;
+ }
+
+ /*
+ * Otherwise if it is below this bank insert new memory in a
+ * new bank before this one. If there was a lower bank we
+ * could have inserted the memory into/before we would already
+ * have done so, so this must be the right place.
+ */
+ if ( start + size < bank->start && kinfo->mem.nr_banks < NR_MEM_BANKS )
+ {
+ memmove(bank + 1, bank, sizeof(*bank)*(kinfo->mem.nr_banks - i));
+ kinfo->mem.nr_banks++;
+ bank->start = start;
+ bank->size = size;
+ return true;
+ }
+ }
+
+ if ( i == kinfo->mem.nr_banks && kinfo->mem.nr_banks < NR_MEM_BANKS )
+ {
+ struct membank *bank = &kinfo->mem.bank[kinfo->mem.nr_banks];
+
+ bank->start = start;
+ bank->size = size;
+ kinfo->mem.nr_banks++;
+ return true;
+ }
+
+ /* If we get here then there are no more banks to fill. */
+
+fail:
+ free_domheap_pages(pg, order);
+ return false;
+}
+
+/*
+ * This is all pretty horrible.
+ *
+ * Requirements:
+ *
+ * 1. The dom0 kernel should be loaded within the first 128MB of RAM. This
+ * is necessary at least for Linux zImage kernels, which are all we
+ * support today.
+ * 2. We want to put the dom0 kernel, ramdisk and DTB in the same
+ * bank. Partly this is just easier for us to deal with, but also
+ * the ramdisk and DTB must be placed within a certain proximity of
+ * the kernel within RAM.
+ * 3. For 32-bit dom0 we want to place as much of the RAM as we
+ * reasonably can below 4GB, so that it can be used by non-LPAE
+ * enabled kernels.
+ * 4. For 32-bit dom0 the kernel must be located below 4GB.
+ * 5. We want to have a few largers banks rather than many smaller ones.
+ *
+ * For the first two requirements we need to make sure that the lowest
+ * bank is sufficiently large.
+ *
+ * For convenience we also sort the banks by physical address.
+ *
+ * The memory allocator does not really give us the flexibility to
+ * meet these requirements directly. So instead of proceed as follows:
+ *
+ * We first allocate the largest allocation we can as low as we
+ * can. This then becomes the first bank. This bank must be at least
+ * 128MB (or dom0_mem if that is smaller).
+ *
+ * Then we start allocating more memory, trying to allocate the
+ * largest possible size and trying smaller sizes until we
+ * successfully allocate something.
+ *
+ * We then try and insert this memory in to the list of banks. If it
+ * can be merged into an existing bank then this is trivial.
+ *
+ * If the new memory is before the first bank (and cannot be merged into it)
+ * and is at least 128M then we allow it, otherwise we give up. Since the
+ * allocator prefers to allocate high addresses first and the first bank has
+ * already been allocated to be as low as possible this likely means we
+ * wouldn't have been able to allocate much more memory anyway.
+ *
+ * Otherwise we insert a new bank. If we've reached MAX_NR_BANKS then
+ * we give up.
+ *
+ * For 32-bit domain we require that the initial allocation for the
+ * first bank is under 4G. Then for the subsequent allocations we
+ * initially allocate memory only from below 4GB. Once that runs out
+ * (as described above) we allow higher allocations and continue until
+ * that runs out (or we have allocated sufficient dom0 memory).
+ */
+static void allocate_memory_11(struct domain *d, struct kernel_info *kinfo)
+{
+ const unsigned int min_low_order =
+ get_order_from_bytes(min_t(paddr_t, dom0_mem, MB(128)));
+ const unsigned int min_order = get_order_from_bytes(MB(4));
+ struct page_info *pg;
+ unsigned int order = get_11_allocation_size(kinfo->unassigned_mem);
+ int i;
+
+ bool_t lowmem = is_32bit_domain(d);
+ unsigned int bits;
+
+ printk("Allocating 1:1 mappings totalling %ldMB for dom0:\n",
+ /* Don't want format this as PRIpaddr (16 digit hex) */
+ (unsigned long)(kinfo->unassigned_mem >> 20));
+
+ kinfo->mem.nr_banks = 0;
+
+ /*
+ * First try and allocate the largest thing we can as low as
+ * possible to be bank 0.
+ */
+ while ( order >= min_low_order )
+ {
+ for ( bits = order ; bits <= (lowmem ? 32 : PADDR_BITS); bits++ )
+ {
+ pg = alloc_domheap_pages(d, order, MEMF_bits(bits));
+ if ( pg != NULL )
+ goto got_bank0;
+ }
+ order--;
+ }
+
+ panic("Unable to allocate first memory bank");
+
+ got_bank0:
+
+ if ( !insert_11_bank(d, kinfo, pg, order) )
+ BUG(); /* Cannot fail for first bank */
+
+ /* Now allocate more memory and fill in additional banks */
+
+ order = get_11_allocation_size(kinfo->unassigned_mem);
+ while ( kinfo->unassigned_mem && kinfo->mem.nr_banks < NR_MEM_BANKS )
+ {
+ pg = alloc_domheap_pages(d, order, lowmem ? MEMF_bits(32) : 0);
+ if ( !pg )
+ {
+ order --;
+
+ if ( lowmem && order < min_low_order)
+ {
+ D11PRINT("Failed at min_low_order, allow high allocations\n");
+ order = get_11_allocation_size(kinfo->unassigned_mem);
+ lowmem = false;
+ continue;
+ }
+ if ( order >= min_order )
+ continue;
+
+ /* No more we can do */
+ break;
+ }
+
+ if ( !insert_11_bank(d, kinfo, pg, order) )
+ {
+ if ( kinfo->mem.nr_banks == NR_MEM_BANKS )
+ /* Nothing more we can do. */
+ break;
+
+ if ( lowmem )
+ {
+ D11PRINT("Allocation below bank 0, allow high allocations\n");
+ order = get_11_allocation_size(kinfo->unassigned_mem);
+ lowmem = false;
+ continue;
+ }
+ else
+ {
+ D11PRINT("Allocation below bank 0\n");
+ break;
+ }
+ }
+
+ /*
+ * Success, next time around try again to get the largest order
+ * allocation possible.
+ */
+ order = get_11_allocation_size(kinfo->unassigned_mem);
+ }
+
+ if ( kinfo->unassigned_mem )
+ printk("WARNING: Failed to allocate requested dom0 memory."
+ /* Don't want format this as PRIpaddr (16 digit hex) */
+ " %ldMB unallocated\n",
+ (unsigned long)kinfo->unassigned_mem >> 20);
+
+ for( i = 0; i < kinfo->mem.nr_banks; i++ )
+ {
+ printk("BANK[%d] %#"PRIpaddr"-%#"PRIpaddr" (%ldMB)\n",
+ i,
+ kinfo->mem.bank[i].start,
+ kinfo->mem.bank[i].start + kinfo->mem.bank[i].size,
+ /* Don't want format this as PRIpaddr (16 digit hex) */
+ (unsigned long)(kinfo->mem.bank[i].size >> 20));
+ }
}
static void allocate_memory(struct domain *d, struct kernel_info *kinfo)
--
1.7.10.4
^ permalink raw reply related [flat|nested] 20+ messages in thread* Re: [PATCH v5 8/8] xen: arm: allocate more than one bank for 1:1 domain 0 if needed
2014-07-09 12:07 ` [PATCH v5 8/8] xen: arm: allocate more than one bank for 1:1 domain 0 if needed Ian Campbell
@ 2014-07-09 16:40 ` Julien Grall
0 siblings, 0 replies; 20+ messages in thread
From: Julien Grall @ 2014-07-09 16:40 UTC (permalink / raw)
To: Ian Campbell, xen-devel; +Cc: tim, stefano.stabellini
Hi Ian,
On 07/09/2014 01:07 PM, Ian Campbell wrote:
> Depending on where Xen and the initial modules were loaded into RAM we may not
> be able to allocate a suitably contiguous block of memory for dom0. Especially
> since the allocations made by alloc_domheap_pages are naturally aligned (e.g. a
> 1GB allocation must be at a 1GB boundary).
>
> The alignment requirement in particular is a huge limitation, meaning that even
> dom0_mem0=1G on a 2GB system is pretty likely to fail unless you are very
> careful with your load addresses. People were also having trouble with dom0 >
> 128MB on the 1GB cubieboard2 when using fairly standard load addresses for
> things.
>
> This patch tries to allocate multiple banks of memory in order to try and
> satisfy the entire requested domain 0 allocation. Sadly this turns out to be
> pretty tricky to arrange (see the large comment in the code).
>
> Signed-off-by: Ian Campbell <ian.campbell@citrix.com>
Acked-by: Julien Grall <julien.grall@linaro.org>
Regards,
--
Julien Grall
^ permalink raw reply [flat|nested] 20+ messages in thread
* Re: [PATCH v5 0/8] xen: arm: Use super pages in p2m
2014-07-09 12:06 [PATCH v5 0/8] xen: arm: Use super pages in p2m Ian Campbell
` (7 preceding siblings ...)
2014-07-09 12:07 ` [PATCH v5 8/8] xen: arm: allocate more than one bank for 1:1 domain 0 if needed Ian Campbell
@ 2014-07-10 10:32 ` Ian Campbell
8 siblings, 0 replies; 20+ messages in thread
From: Ian Campbell @ 2014-07-10 10:32 UTC (permalink / raw)
To: xen-devel; +Cc: Tim Deegan, Julien Grall, Ian Jackson, Stefano Stabellini
On Wed, 2014-07-09 at 13:06 +0100, Ian Campbell wrote:
> The following series adds support for superpage mappings (1G and 2M) in
> the p2m for dom0 and domU.
>
> On a 32-bit platform this causes the overhead of kernbench vs. native to
> drop from 8-9% to 1.5-3% (it's basically the same for both dom0 and
> domU).
>
> I couldn't get my 64-bit platform to boot natively for some reason but
> in absolute terms kernbench improved by ~5% (domU) to ~15% (dom0).
>
> A xen: arm: dump vcpu gic info in arch_dump_vcpu_info
> At tools/libxc: pull min/max_t into xc_private.h
Ian did actually ack this one in a previous iteration
> At tools: arm: allocate large pages to guests.
And has now acked this one.
> A xen: arm: only put_page for p2m operations which require it.
> A xen: arm: handle superpage mappings in p2m_lookup
> A m xen: arm: add some helpers for assessing p2m pte
So I've applied up to here.
> m xen: arm: use superpages in p2m when pages are suitably aligned
Julien had a comment here so I've not applied this one yet.
> xen: arm: allocate more than one bank for 1:1 domain 0 if needed
>
> A == ARM ack
> t == Tools ACK still needed
> m == modifications this round
>
> Ian.
>
> The following changes since commit f9cff088f470b662df1ac31d1161b4f1870b8546:
>
> oxenstored: perform a 3-way merge of the quota after a transaction (2014-07-04 09:49:09 +0100)
>
> are available in the git repository at:
>
> git://xenbits.xen.org/people/ianc/xen.git arm-p2m-superpages-v5
>
> for you to fetch changes up to 4f8e06b5a901e58cb095878ced7989ac65dd7f3d:
>
> xen: arm: allocate more than one bank for 1:1 domain 0 if needed (2014-07-09 13:02:47 +0100)
>
> ----------------------------------------------------------------
> Ian Campbell (8):
> xen: arm: dump vcpu gic info in arch_dump_vcpu_info
> tools/libxc: pull min/max_t into xc_private.h
> tools: arm: allocate large pages to guests.
> xen: arm: only put_page for p2m operations which require it.
> xen: arm: handle superpage mappings in p2m_lookup
> xen: arm: add some helpers for assessing p2m pte
> xen: arm: use superpages in p2m when pages are suitably aligned
> xen: arm: allocate more than one bank for 1:1 domain 0 if needed
>
> tools/libxc/xc_dom_arm.c | 131 ++++++-
> tools/libxc/xc_dom_decompress_unsafe_xz.c | 5 -
> tools/libxc/xc_private.h | 5 +
> xen/arch/arm/domain.c | 8 +-
> xen/arch/arm/domain_build.c | 288 +++++++++++++--
> xen/arch/arm/p2m.c | 554 ++++++++++++++++++++++-------
> xen/include/asm-arm/p2m.h | 12 +
> 7 files changed, 822 insertions(+), 181 deletions(-)
>
>
>
> _______________________________________________
> Xen-devel mailing list
> Xen-devel@lists.xen.org
> http://lists.xen.org/xen-devel
^ permalink raw reply [flat|nested] 20+ messages in thread