machine_kexec.c 5.5 KB
Newer Older
M
Michael Ellerman 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/*
 * Code to handle transition of Linux booting another kernel.
 *
 * Copyright (C) 2002-2003 Eric Biederman  <ebiederm@xmission.com>
 * GameCube/ppc32 port Copyright (C) 2004 Albert Herranz
 * Copyright (C) 2005 IBM Corporation.
 *
 * This source code is licensed under the GNU General Public License,
 * Version 2.  See the file COPYING for more details.
 */

#include <linux/kexec.h>
#include <linux/reboot.h>
#include <linux/threads.h>
15
#include <linux/lmb.h>
16
#include <linux/of.h>
M
Michael Ellerman 已提交
17
#include <asm/machdep.h>
18
#include <asm/prom.h>
19
#include <asm/sections.h>
M
Michael Ellerman 已提交
20 21 22 23

void machine_crash_shutdown(struct pt_regs *regs)
{
	if (ppc_md.machine_crash_shutdown)
24
		ppc_md.machine_crash_shutdown(regs);
25 26
	else
		default_machine_crash_shutdown(regs);
M
Michael Ellerman 已提交
27 28 29 30 31 32 33 34 35 36 37
}

/*
 * Do what every setup is needed on image and the
 * reboot code buffer to allow us to avoid allocations
 * later.
 */
int machine_kexec_prepare(struct kimage *image)
{
	if (ppc_md.machine_kexec_prepare)
		return ppc_md.machine_kexec_prepare(image);
38 39
	else
		return default_machine_kexec_prepare(image);
M
Michael Ellerman 已提交
40 41 42 43 44 45 46 47 48 49 50 51
}

void machine_kexec_cleanup(struct kimage *image)
{
	if (ppc_md.machine_kexec_cleanup)
		ppc_md.machine_kexec_cleanup(image);
}

/*
 * Do not allocate memory (or fail in any way) in machine_kexec().
 * We are past the point of no return, committed to rebooting now.
 */
H
Huang Ying 已提交
52
void machine_kexec(struct kimage *image)
M
Michael Ellerman 已提交
53 54 55
{
	if (ppc_md.machine_kexec)
		ppc_md.machine_kexec(image);
56 57 58 59 60
	else
		default_machine_kexec(image);

	/* Fall back to normal restart if we're still alive. */
	machine_restart(NULL);
M
Michael Ellerman 已提交
61 62
	for(;;);
}
63 64 65

void __init reserve_crashkernel(void)
{
66 67 68 69 70 71 72 73 74 75 76
	unsigned long long crash_size, crash_base;
	int ret;

	/* this is necessary because of lmb_phys_mem_size() */
	lmb_analyze();

	/* use common parsing */
	ret = parse_crashkernel(boot_command_line, lmb_phys_mem_size(),
			&crash_size, &crash_base);
	if (ret == 0 && crash_size > 0) {
		crashk_res.start = crash_base;
77
		crashk_res.end = crash_base + crash_size - 1;
78
	}
79

80 81
	if (crashk_res.end == crashk_res.start) {
		crashk_res.start = crashk_res.end = 0;
82
		return;
83
	}
84 85 86 87

	/* We might have got these values via the command line or the
	 * device tree, either way sanitise them now. */

88 89
	crash_size = crashk_res.end - crashk_res.start + 1;

90
#ifndef CONFIG_RELOCATABLE
91 92 93 94 95
	if (crashk_res.start != KDUMP_KERNELBASE)
		printk("Crash kernel location must be 0x%x\n",
				KDUMP_KERNELBASE);

	crashk_res.start = KDUMP_KERNELBASE;
96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112
#else
	if (!crashk_res.start) {
		/*
		 * unspecified address, choose a region of specified size
		 * can overlap with initrd (ignoring corruption when retained)
		 * ppc64 requires kernel and some stacks to be in first segemnt
		 */
		crashk_res.start = KDUMP_KERNELBASE;
	}

	crash_base = PAGE_ALIGN(crashk_res.start);
	if (crash_base != crashk_res.start) {
		printk("Crash kernel base must be aligned to 0x%lx\n",
				PAGE_SIZE);
		crashk_res.start = crash_base;
	}

113
#endif
114 115
	crash_size = PAGE_ALIGN(crash_size);
	crashk_res.end = crashk_res.start + crash_size - 1;
116

117 118 119 120 121 122 123 124
	/* The crash region must not overlap the current kernel */
	if (overlaps_crashkernel(__pa(_stext), _end - _stext)) {
		printk(KERN_WARNING
			"Crash kernel can not overlap current kernel\n");
		crashk_res.start = crashk_res.end = 0;
		return;
	}

125 126 127 128 129 130 131
	/* Crash kernel trumps memory limit */
	if (memory_limit && memory_limit <= crashk_res.end) {
		memory_limit = crashk_res.end + 1;
		printk("Adjusted memory limit for crashkernel, now 0x%lx\n",
				memory_limit);
	}

132 133 134 135 136 137 138
	printk(KERN_INFO "Reserving %ldMB of memory at %ldMB "
			"for crashkernel (System RAM: %ldMB)\n",
			(unsigned long)(crash_size >> 20),
			(unsigned long)(crashk_res.start >> 20),
			(unsigned long)(lmb_phys_mem_size() >> 20));

	lmb_reserve(crashk_res.start, crash_size);
139 140 141 142 143 144
}

int overlaps_crashkernel(unsigned long start, unsigned long size)
{
	return (start + size) > crashk_res.start && start <= crashk_res.end;
}
145 146 147

/* Values we need to export to the second kernel via the device tree. */
static unsigned long kernel_end;
148
static unsigned long crashk_size;
149 150 151 152 153 154 155

static struct property kernel_end_prop = {
	.name = "linux,kernel-end",
	.length = sizeof(unsigned long),
	.value = &kernel_end,
};

156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
static struct property crashk_base_prop = {
	.name = "linux,crashkernel-base",
	.length = sizeof(unsigned long),
	.value = &crashk_res.start,
};

static struct property crashk_size_prop = {
	.name = "linux,crashkernel-size",
	.length = sizeof(unsigned long),
	.value = &crashk_size,
};

static void __init export_crashk_values(struct device_node *node)
{
	struct property *prop;

	/* There might be existing crash kernel properties, but we can't
	 * be sure what's in them, so remove them. */
	prop = of_find_property(node, "linux,crashkernel-base", NULL);
	if (prop)
		prom_remove_property(node, prop);

	prop = of_find_property(node, "linux,crashkernel-size", NULL);
	if (prop)
		prom_remove_property(node, prop);

	if (crashk_res.start != 0) {
		prom_add_property(node, &crashk_base_prop);
		crashk_size = crashk_res.end - crashk_res.start + 1;
		prom_add_property(node, &crashk_size_prop);
	}
}

189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
static int __init kexec_setup(void)
{
	struct device_node *node;
	struct property *prop;

	node = of_find_node_by_path("/chosen");
	if (!node)
		return -ENOENT;

	/* remove any stale properties so ours can be found */
	prop = of_find_property(node, kernel_end_prop.name, NULL);
	if (prop)
		prom_remove_property(node, prop);

	/* information needed by userspace when using default_machine_kexec */
	kernel_end = __pa(_end);
	prom_add_property(node, &kernel_end_prop);

207 208
	export_crashk_values(node);

209 210 211 212
	of_node_put(node);
	return 0;
}
late_initcall(kexec_setup);