From patchwork Mon Oct 19 23:38:54 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Geoff Levand X-Patchwork-Id: 55271 Return-Path: X-Original-To: linaro@patches.linaro.org Delivered-To: linaro@patches.linaro.org Received: from mail-lb0-f198.google.com (mail-lb0-f198.google.com [209.85.217.198]) by patches.linaro.org (Postfix) with ESMTPS id BEE6A22F11 for ; Mon, 19 Oct 2015 23:52:57 +0000 (UTC) Received: by lbbpp2 with SMTP id pp2sf693727lbb.0 for ; Mon, 19 Oct 2015 16:52:56 -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:message-id:in-reply-to:references :from:patch-date:subject:to:date:precedence:list-id:list-unsubscribe :list-archive:list-post:list-help:list-subscribe:cc:mime-version :content-type:content-transfer-encoding:sender:errors-to :x-original-sender:x-original-authentication-results:mailing-list; bh=7Br06AQAZrh8kk/qVKbQmeyS4/Ovi9WYSkGOZtFYaFY=; b=co5Q/tvIFS9kBKs5fI1kCkiDFDTcLO7+auab3yJfyorpiBPkIG+GwAj1pW+lrQpLBx yl3Krrs4JOCTc3Vij5SYD3BE2WOT1zUkc4SaCKcadUb6goNZt+VWL33rYfdQ9tcExnBa Ito+8U/7eZwx2ChNlRP7V2e9YGkXh4ac2E03XI8QGGvOZmrz2BSNl0wItY/ff0e+Ki9l Vuu1okv/F5SWzJU1hFgycwtQTPnPhheQKp42qk+/cHtgqWwt7Y12e7kSm40nq7mWcYkb B4h+hj4Qi1xJ/Nt27dHhrWeYKrf8gsgDjeW9o/vjL5w7M+PRzfLHN7izWmlsmJs33iYk LdSw== X-Gm-Message-State: ALoCoQnNxeRsztNdntpVGAnvp/mpvUrNy4mAxG+ICt+uw3b+HbAQKQp3fUtBWy8Is/YJ4XjaVj4t X-Received: by 10.112.173.170 with SMTP id bl10mr23020lbc.7.1445298776739; Mon, 19 Oct 2015 16:52:56 -0700 (PDT) X-BeenThere: patchwork-forward@linaro.org Received: by 10.25.90.85 with SMTP id o82ls3354lfb.98.gmail; Mon, 19 Oct 2015 16:52:56 -0700 (PDT) X-Received: by 10.25.84.84 with SMTP id i81mr39781lfb.43.1445298776334; Mon, 19 Oct 2015 16:52:56 -0700 (PDT) Received: from mail-lb0-f173.google.com (mail-lb0-f173.google.com. [209.85.217.173]) by mx.google.com with ESMTPS id v139si172964lfd.60.2015.10.19.16.52.56 for (version=TLSv1.2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 19 Oct 2015 16:52:56 -0700 (PDT) Received-SPF: pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 209.85.217.173 as permitted sender) client-ip=209.85.217.173; Received: by lbbpp2 with SMTP id pp2so1141380lbb.0 for ; Mon, 19 Oct 2015 16:52:56 -0700 (PDT) X-Received: by 10.25.38.9 with SMTP id m9mr41791lfm.112.1445298776043; Mon, 19 Oct 2015 16:52:56 -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.112.59.35 with SMTP id w3csp1760001lbq; Mon, 19 Oct 2015 16:52:54 -0700 (PDT) X-Received: by 10.68.139.194 with SMTP id ra2mr256805pbb.6.1445298774718; Mon, 19 Oct 2015 16:52:54 -0700 (PDT) Received: from bombadil.infradead.org (bombadil.infradead.org. [2001:1868:205::9]) by mx.google.com with ESMTPS id ym8si413044pac.23.2015.10.19.16.52.54 for (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Mon, 19 Oct 2015 16:52:54 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-arm-kernel-bounces+patch=linaro.org@lists.infradead.org designates 2001:1868:205::9 as permitted sender) client-ip=2001:1868:205::9; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.80.1 #2 (Red Hat Linux)) id 1ZoK7G-0007Zp-Ts; Mon, 19 Oct 2015 23:45:22 +0000 Received: from merlin.infradead.org ([2001:4978:20e::2]) by bombadil.infradead.org with esmtps (Exim 4.80.1 #2 (Red Hat Linux)) id 1ZoK16-0002lD-4y; Mon, 19 Oct 2015 23:39:00 +0000 Received: from geoff by merlin.infradead.org with local (Exim 4.85 #2 (Red Hat Linux)) id 1ZoK10-0000wu-C6; Mon, 19 Oct 2015 23:38:54 +0000 Message-Id: In-Reply-To: References: From: Geoff Levand Patch-Date: Wed, 19 Aug 2015 16:43:42 +0900 Subject: [PATCH 13/16] arm64: kdump: add kdump support To: Catalin Marinas , Will Deacon Date: Mon, 19 Oct 2015 23:38:54 +0000 X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: , List-Help: , List-Subscribe: , Cc: Mark Rutland , AKASHI@infradead.org, marc.zyngier@arm.com, kexec@lists.infradead.org, Takahiro , linux-arm-kernel@lists.infradead.org, christoffer.dall@linaro.org MIME-Version: 1.0 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+patch=linaro.org@lists.infradead.org X-Removed-Original-Auth: Dkim didn't pass. X-Original-Sender: geoff@infradead.org X-Original-Authentication-Results: mx.google.com; spf=pass (google.com: domain of patch+caf_=patchwork-forward=linaro.org@linaro.org designates 209.85.217.173 as permitted sender) smtp.mailfrom=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 From: AKASHI Takahiro On crash dump kernel, all the information about primary kernel's core image is available in elf core header specified by "elfcorehdr=" boot parameter. reserve_elfcorehdr() will set aside the region to avoid any corruption by crash dump kernel. Crash dump kernel will access the system memory of primary kernel via copy_oldmem_page(), which reads one page by ioremap'ing it since it does not reside in linear mapping on crash dump kernel. Please note that we should add "mem=X[MG]" boot parameter to limit the memory size and avoid the following assertion at ioremap(): if (WARN_ON(pfn_valid(__phys_to_pfn(phys_addr)))) return NULL; when accessing any pages beyond the usable memories of crash dump kernel. We also need our own elfcorehdr_read() here since the weak definition of elfcorehdr_read() utilizes copy_oldmem_page() and will hit the assertion above on arm64. Signed-off-by: AKASHI Takahiro --- arch/arm64/Kconfig | 12 +++++++ arch/arm64/kernel/Makefile | 1 + arch/arm64/kernel/crash_dump.c | 71 ++++++++++++++++++++++++++++++++++++++++++ arch/arm64/mm/init.c | 29 +++++++++++++++++ 4 files changed, 113 insertions(+) create mode 100644 arch/arm64/kernel/crash_dump.c diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig index 73e8e31..262bd49 100644 --- a/arch/arm64/Kconfig +++ b/arch/arm64/Kconfig @@ -501,6 +501,18 @@ config KEXEC but it is independent of the system firmware. And like a reboot you can start any kernel with it, not just Linux. +config CRASH_DUMP + bool "Build kdump crash kernel" + help + Generate crash dump after being started by kexec. This should + be normally only set in special crash dump kernels which are + loaded in the main kernel with kexec-tools into a specially + reserved region and then later executed after a crash by + kdump/kexec. The crash dump kernel must be compiled to a + memory address not used by the main kernel. + + For more details see Documentation/kdump/kdump.txt + config XEN_DOM0 def_bool y depends on XEN diff --git a/arch/arm64/kernel/Makefile b/arch/arm64/kernel/Makefile index 989ccd7..7ef9fa4 100644 --- a/arch/arm64/kernel/Makefile +++ b/arch/arm64/kernel/Makefile @@ -38,6 +38,7 @@ arm64-obj-$(CONFIG_ARMV8_DEPRECATED) += armv8_deprecated.o arm64-obj-$(CONFIG_ACPI) += acpi.o arm64-obj-$(CONFIG_KEXEC) += machine_kexec.o relocate_kernel.o \ cpu-reset.o +arm64-obj-$(CONFIG_CRASH_DUMP) += crash_dump.o obj-y += $(arm64-obj-y) vdso/ obj-m += $(arm64-obj-m) diff --git a/arch/arm64/kernel/crash_dump.c b/arch/arm64/kernel/crash_dump.c new file mode 100644 index 0000000..3d86c0a --- /dev/null +++ b/arch/arm64/kernel/crash_dump.c @@ -0,0 +1,71 @@ +/* + * Routines for doing kexec-based kdump + * + * Copyright (C) 2014 Linaro Limited + * Author: AKASHI Takahiro + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License version 2 as + * published by the Free Software Foundation. + */ + +#include +#include +#include +#include +#include +#include + +/** + * copy_oldmem_page() - copy one page from old kernel memory + * @pfn: page frame number to be copied + * @buf: buffer where the copied page is placed + * @csize: number of bytes to copy + * @offset: offset in bytes into the page + * @userbuf: if set, @buf is in a user address space + * + * This function copies one page from old kernel memory into buffer pointed by + * @buf. If @buf is in userspace, set @userbuf to %1. Returns number of bytes + * copied or negative error in case of failure. + */ +ssize_t copy_oldmem_page(unsigned long pfn, char *buf, + size_t csize, unsigned long offset, + int userbuf) +{ + void *vaddr; + + if (!csize) + return 0; + + vaddr = ioremap_cache(pfn << PAGE_SHIFT, PAGE_SIZE); + if (!vaddr) + return -ENOMEM; + + if (userbuf) { + if (copy_to_user(buf, vaddr + offset, csize)) { + iounmap(vaddr); + return -EFAULT; + } + } else { + memcpy(buf, vaddr + offset, csize); + } + + iounmap(vaddr); + + return csize; +} + +/** + * elfcorehdr_read - read from ELF core header + * @buf: buffer where the data is placed + * @csize: number of bytes to read + * @ppos: address in the memory + * + * This function reads @count bytes from elf core header which exists + * on crash dump kernel's memory. + */ +ssize_t elfcorehdr_read(char *buf, size_t count, u64 *ppos) +{ + memcpy(buf, phys_to_virt((phys_addr_t)*ppos), count); + return count; +} diff --git a/arch/arm64/mm/init.c b/arch/arm64/mm/init.c index f33f201..ff8eeb4 100644 --- a/arch/arm64/mm/init.c +++ b/arch/arm64/mm/init.c @@ -35,6 +35,7 @@ #include #include #include +#include #include #include @@ -116,6 +117,31 @@ static void __init reserve_crashkernel(void) } #endif /* CONFIG_KEXEC */ +#ifdef CONFIG_CRASH_DUMP +/* + * reserve_elfcorehdr() - reserves memory for elf core header + * + * This function reserves elf core header given in "elfcorehdr=" kernel + * command line parameter. This region contains all the information about + * primary kernel's core image and is used by a dump capture kernel to + * access the system memory on primary kernel. + */ +static void __init reserve_elfcorehdr(void) +{ + if (!elfcorehdr_size) + return; + + if (memblock_is_region_reserved(elfcorehdr_addr, elfcorehdr_size)) { + pr_warn("elfcorehdr is overlapped\n"); + return; + } + + memblock_reserve(elfcorehdr_addr, elfcorehdr_size); + + pr_info("Reserving %lldKB of memory at %lldMB for elfcorehdr\n", + elfcorehdr_size >> 10, elfcorehdr_addr >> 20); +} +#endif /* CONFIG_CRASH_DUMP */ /* * Return the maximum physical address for ZONE_DMA (DMA_BIT_MASK(32)). It * currently assumes that for memory starting above 4G, 32-bit devices will @@ -223,6 +249,9 @@ void __init arm64_memblock_init(void) #ifdef CONFIG_KEXEC reserve_crashkernel(); #endif +#ifdef CONFIG_CRASH_DUMP + reserve_elfcorehdr(); +#endif early_init_fdt_scan_reserved_mem();