From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1758299AbcCVHeS (ORCPT ); Tue, 22 Mar 2016 03:34:18 -0400 Received: from mx1.redhat.com ([209.132.183.28]:63847 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1758280AbcCVHdf (ORCPT ); Tue, 22 Mar 2016 03:33:35 -0400 From: Baoquan He To: linux-kernel@vger.kernel.org Cc: yinghai@kernel.org, keescook@chromium.org, hpa@zytor.com, mingo@redhat.com, bp@alien8.de, vgoyal@redhat.com, luto@kernel.org, lasse.collin@tukaani.org, akpm@linux-foundation.org, dyoung@redhat.com, Baoquan He Subject: [PATCH v4 14/20] x86, kaslr: Add two functions which will be used later Date: Tue, 22 Mar 2016 15:32:11 +0800 Message-Id: <1458631937-14593-15-git-send-email-bhe@redhat.com> In-Reply-To: <1458631937-14593-1-git-send-email-bhe@redhat.com> References: <1458631937-14593-1-git-send-email-bhe@redhat.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Function store_slot_info() is used to calculate the slot info of passed in memory region and store it into slot_areas[]. Function mem_min_overlap is used to iterate all avoid regions to find the one which overlap with it in the lowest address. E.g there's a memory region[1024M, 2048M), after iterating all avoid regions we found the first avoid region by starting address from low to high is [1536M, 1664M). With this information we can split memory region [1024M, 1536M) out as the avaliable slot area and save it into array slot_areas[]. Signed-off-by: Baoquan He --- arch/x86/boot/compressed/aslr.c | 51 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/arch/x86/boot/compressed/aslr.c b/arch/x86/boot/compressed/aslr.c index 0431c19..44c6768 100644 --- a/arch/x86/boot/compressed/aslr.c +++ b/arch/x86/boot/compressed/aslr.c @@ -257,6 +257,40 @@ static bool mem_avoid_overlap(struct mem_vector *img) return false; } +static unsigned long +mem_min_overlap(struct mem_vector *img, struct mem_vector *out) +{ + int i; + struct setup_data *ptr; + unsigned long min = img->start + img->size; + + for (i = 0; i < MEM_AVOID_MAX; i++) { + if (mem_overlaps(img, &mem_avoid[i]) && + (mem_avoid[i].start < min)) { + *out = mem_avoid[i]; + min = mem_avoid[i].start; + } + } + + /* Check all entries in the setup_data linked list. */ + ptr = (struct setup_data *)(unsigned long)real_mode->hdr.setup_data; + while (ptr) { + struct mem_vector avoid; + + avoid.start = (unsigned long)ptr; + avoid.size = sizeof(*ptr) + ptr->len; + + if (mem_overlaps(img, &avoid) && (avoid.start < min)) { + *out = avoid; + min = avoid.start; + } + + ptr = (struct setup_data *)(unsigned long)ptr->next; + } + + return min; +} + static unsigned long slots[CONFIG_RANDOMIZE_BASE_MAX_OFFSET / CONFIG_PHYSICAL_ALIGN]; @@ -273,6 +307,23 @@ static unsigned long slot_max; static unsigned long slot_area_index; +static void store_slot_info(struct mem_vector *region, unsigned long image_size) +{ + struct slot_area slot_area; + + slot_area.addr = region->start; + if (image_size <= CONFIG_PHYSICAL_ALIGN) + slot_area.num = region->size / CONFIG_PHYSICAL_ALIGN; + else + slot_area.num = (region->size - image_size) / + CONFIG_PHYSICAL_ALIGN + 1; + + if (slot_area.num > 0) { + slot_areas[slot_area_index++] = slot_area; + slot_max += slot_area.num; + } +} + static void slots_append(unsigned long addr) { /* Overflowing the slots list should be impossible. */ -- 2.5.0