From patchwork Tue Jul 1 08:27:01 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Ian Campbell X-Patchwork-Id: 32856 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-ie0-f198.google.com (mail-ie0-f198.google.com [209.85.223.198]) by ip-10-151-82-157.ec2.internal (Postfix) with ESMTPS id 741FF203C0 for ; Tue, 1 Jul 2014 08:29:17 +0000 (UTC) Received: by mail-ie0-f198.google.com with SMTP id rl12sf2262511iec.1 for ; Tue, 01 Jul 2014 01:29:16 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:delivered-to:from:to:date:message-id:in-reply-to :references:mime-version:cc:subject:precedence:list-id :list-unsubscribe:list-post:list-help:list-subscribe:sender :errors-to:x-original-sender:x-original-authentication-results :mailing-list:list-archive:content-type:content-transfer-encoding; bh=sbiQ5j5F1nK4/JHNKzblJlT6rLQEbAdE1EvFl0R2sSI=; b=g8a9RPPsxzaC0miA8ZGiwGFLoOntMDLQBWmMWpIpJgi/xHWpoETxLZSdFQnCZJ+q2M toJgiK1qE31WL2D0mq6rLLI071nyUz/bg7ddOLGpPO2gTrqQh2oimvf8qvAw+ZW9PHor +F3mBFjIVBOJV6xSL4n8hPGVTBmnS4o/bp0ADF3yD31bI8mghnOe4e0hadixE26ViE+H 7KoJinWyFEF4CMdzQVttEW4r1p7RS3rUwSBDK4VOJzdvKdy6KXTeapCEUhfG3ZvYZW32 4YY7XyyWv/ybyMtmWNWr1yh9S4seFfXEZ++oUhj3E4ZJCLsSbbB9KyZeOExyUObDOKhR HYMQ== X-Gm-Message-State: ALoCoQnMMK81JhX5129DNIo8aVPNVmScWU8UvpO6GR3Fccv14b/wtagZmZ2oUUJ6T/zPUmwC83U4 X-Received: by 10.182.28.102 with SMTP id a6mr26253115obh.44.1404203356536; Tue, 01 Jul 2014 01:29:16 -0700 (PDT) X-BeenThere: patchwork-forward@linaro.org Received: by 10.140.106.134 with SMTP id e6ls1970869qgf.34.gmail; Tue, 01 Jul 2014 01:29:16 -0700 (PDT) X-Received: by 10.220.177.133 with SMTP id bi5mr37345718vcb.26.1404203356322; Tue, 01 Jul 2014 01:29:16 -0700 (PDT) Received: from mail-vc0-f181.google.com (mail-vc0-f181.google.com [209.85.220.181]) by mx.google.com with ESMTPS id fj4si11146164vcb.24.2014.07.01.01.29.16 for (version=TLSv1 cipher=ECDHE-RSA-RC4-SHA bits=128/128); Tue, 01 Jul 2014 01:29:16 -0700 (PDT) Received-SPF: pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 209.85.220.181 as permitted sender) client-ip=209.85.220.181; Received: by mail-vc0-f181.google.com with SMTP id il7so8507034vcb.26 for ; Tue, 01 Jul 2014 01:29:16 -0700 (PDT) X-Received: by 10.220.69.72 with SMTP id y8mr43186927vci.21.1404203355975; Tue, 01 Jul 2014 01:29:15 -0700 (PDT) X-Forwarded-To: patchwork-forward@linaro.org X-Forwarded-For: patch@linaro.org patchwork-forward@linaro.org Delivered-To: patch@linaro.org Received: by 10.221.37.5 with SMTP id tc5csp198706vcb; Tue, 1 Jul 2014 01:29:15 -0700 (PDT) X-Received: by 10.224.172.10 with SMTP id j10mr59743182qaz.46.1404203355119; Tue, 01 Jul 2014 01:29:15 -0700 (PDT) Received: from lists.xen.org (lists.xen.org. [50.57.142.19]) by mx.google.com with ESMTPS id o36si19694706qgo.11.2014.07.01.01.29.14 for (version=TLSv1 cipher=RC4-SHA bits=128/128); Tue, 01 Jul 2014 01:29:15 -0700 (PDT) Received-SPF: none (google.com: xen-devel-bounces@lists.xen.org does not designate permitted sender hosts) client-ip=50.57.142.19; Received: from localhost ([127.0.0.1] helo=lists.xen.org) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1X1tPB-0000i2-MP; Tue, 01 Jul 2014 08:27:09 +0000 Received: from mail6.bemta4.messagelabs.com ([85.158.143.247]) by lists.xen.org with esmtp (Exim 4.72) (envelope-from ) id 1X1tP9-0000hv-QR for xen-devel@lists.xen.org; Tue, 01 Jul 2014 08:27:08 +0000 Received: from [85.158.143.35:47326] by server-2.bemta-4.messagelabs.com id 63/FC-06539-BD072B35; Tue, 01 Jul 2014 08:27:07 +0000 X-Env-Sender: Ian.Campbell@citrix.com X-Msg-Ref: server-12.tower-21.messagelabs.com!1404203223!14980133!1 X-Originating-IP: [66.165.176.63] X-SpamReason: No, hits=0.0 required=7.0 tests=sa_preprocessor: VHJ1c3RlZCBJUDogNjYuMTY1LjE3Ni42MyA9PiAzMDYwNDg=\n X-StarScan-Received: X-StarScan-Version: 6.11.3; banners=-,-,- X-VirusChecked: Checked Received: (qmail 26499 invoked from network); 1 Jul 2014 08:27:05 -0000 Received: from smtp02.citrix.com (HELO SMTP02.CITRIX.COM) (66.165.176.63) by server-12.tower-21.messagelabs.com with RC4-SHA encrypted SMTP; 1 Jul 2014 08:27:05 -0000 X-IronPort-AV: E=Sophos;i="5.01,580,1400025600"; d="scan'208";a="148975700" Received: from accessns.citrite.net (HELO FTLPEX01CL03.citrite.net) ([10.9.154.239]) by FTLPIPO02.CITRIX.COM with ESMTP; 01 Jul 2014 08:27:03 +0000 Received: from ukmail1.uk.xensource.com (10.80.16.128) by smtprelay.citrix.com (10.13.107.80) with Microsoft SMTP Server id 14.3.181.6; Tue, 1 Jul 2014 04:27:02 -0400 Received: from marilith-n13-p0.uk.xensource.com ([10.80.229.115] helo=marilith-n13.uk.xensource.com.) by ukmail1.uk.xensource.com with esmtp (Exim 4.69) (envelope-from ) id 1X1tP4-0008Hn-RQ; Tue, 01 Jul 2014 09:27:02 +0100 From: Ian Campbell To: Date: Tue, 1 Jul 2014 09:27:01 +0100 Message-ID: <1404203222-30111-8-git-send-email-ian.campbell@citrix.com> X-Mailer: git-send-email 1.7.10.4 In-Reply-To: <1404202883.1829.125.camel@dagon.hellion.org.uk> References: <1404202883.1829.125.camel@dagon.hellion.org.uk> MIME-Version: 1.0 X-DLP: MIA2 Cc: julien.grall@linaro.org, tim@xen.org, Ian Campbell , stefano.stabellini@eu.citrix.com Subject: [Xen-devel] [PATCH v4 8/8] xen: arm: allocate more than one bank for 1:1 domain 0 if needed X-BeenThere: xen-devel@lists.xen.org X-Mailman-Version: 2.1.13 Precedence: list List-Id: List-Unsubscribe: , List-Post: , List-Help: , List-Subscribe: , Sender: xen-devel-bounces@lists.xen.org Errors-To: xen-devel-bounces@lists.xen.org X-Removed-Original-Auth: Dkim didn't pass. X-Original-Sender: ian.campbell@citrix.com X-Original-Authentication-Results: mx.google.com; spf=pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 209.85.220.181 as permitted sender) smtp.mail=patch+caf_=patchwork-forward=linaro.org@linaro.org Mailing-list: list patchwork-forward@linaro.org; contact patchwork-forward+owners@linaro.org X-Google-Group-Id: 836684582541 List-Archive: 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 Cc: Karim Raslan --- 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 9d9cba9..50dc6e5 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)