[mirror_ubuntu-artful-kernel.git] / arch / mips / kernel / relocate.c

/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Support for Kernel relocation at boot time
 *
 * Copyright (C) 2015, Imagination Technologies Ltd.
 * Authors: Matt Redfearn (matt.redfearn@imgtec.com)
 */
#include <asm/bootinfo.h>
#include <asm/cacheflush.h>
#include <asm/fw/fw.h>
#include <asm/sections.h>
#include <asm/setup.h>
#include <asm/timex.h>
#include <linux/elf.h>
#include <linux/kernel.h>
#include <linux/libfdt.h>
#include <linux/of_fdt.h>
#include <linux/sched.h>
#include <linux/start_kernel.h>
#include <linux/string.h>
#include <linux/printk.h>

#define RELOCATED(x) ((void *)((long)x + offset))

extern u32 _relocation_start[];	/* End kernel image / start relocation table */
extern u32 _relocation_end[];	/* End relocation table */

extern long __start___ex_table;	/* Start exception table */
extern long __stop___ex_table;	/* End exception table */

extern void __weak plat_fdt_relocated(void *new_location);

/*
 * This function may be defined for a platform to perform any post-relocation
 * fixup necessary.
 * Return non-zero to abort relocation
 */
int __weak plat_post_relocation(long offset)
{
	return 0;
}

static inline u32 __init get_synci_step(void)
{
	u32 res;

	__asm__("rdhwr  %0, $1" : "=r" (res));

	return res;
}

static void __init sync_icache(void *kbase, unsigned long kernel_length)
{
	void *kend = kbase + kernel_length;
	u32 step = get_synci_step();

	do {
		__asm__ __volatile__(
			"synci  0(%0)"
			: /* no output */
			: "r" (kbase));

		kbase += step;
	} while (kbase < kend);

	/* Completion barrier */
	__sync();
}

static int __init apply_r_mips_64_rel(u32 *loc_orig, u32 *loc_new, long offset)
{
	*(u64 *)loc_new += offset;

	return 0;
}

static int __init apply_r_mips_32_rel(u32 *loc_orig, u32 *loc_new, long offset)
{
	*loc_new += offset;

	return 0;
}

static int __init apply_r_mips_26_rel(u32 *loc_orig, u32 *loc_new, long offset)
{
	unsigned long target_addr = (*loc_orig) & 0x03ffffff;

	if (offset % 4) {
		pr_err("Dangerous R_MIPS_26 REL relocation\n");
		return -ENOEXEC;
	}

	/* Original target address */
	target_addr <<= 2;
	target_addr += (unsigned long)loc_orig & ~0x03ffffff;

	/* Get the new target address */
	target_addr += offset;

	if ((target_addr & 0xf0000000) != ((unsigned long)loc_new & 0xf0000000)) {
		pr_err("R_MIPS_26 REL relocation overflow\n");
		return -ENOEXEC;
	}

	target_addr -= (unsigned long)loc_new & ~0x03ffffff;
	target_addr >>= 2;

	*loc_new = (*loc_new & ~0x03ffffff) | (target_addr & 0x03ffffff);

	return 0;
}


static int __init apply_r_mips_hi16_rel(u32 *loc_orig, u32 *loc_new, long offset)
{
	unsigned long insn = *loc_orig;
	unsigned long target = (insn & 0xffff) << 16; /* high 16bits of target */

	target += offset;

	*loc_new = (insn & ~0xffff) | ((target >> 16) & 0xffff);
	return 0;
}

static int (*reloc_handlers_rel[]) (u32 *, u32 *, long) __initdata = {
	[R_MIPS_64]		= apply_r_mips_64_rel,
	[R_MIPS_32]		= apply_r_mips_32_rel,
	[R_MIPS_26]		= apply_r_mips_26_rel,
	[R_MIPS_HI16]		= apply_r_mips_hi16_rel,
};

int __init do_relocations(void *kbase_old, void *kbase_new, long offset)
{
	u32 *r;
	u32 *loc_orig;
	u32 *loc_new;
	int type;
	int res;

	for (r = _relocation_start; r < _relocation_end; r++) {
		/* Sentinel for last relocation */
		if (*r == 0)
			break;

		type = (*r >> 24) & 0xff;
		loc_orig = (void *)(kbase_old + ((*r & 0x00ffffff) << 2));
		loc_new = RELOCATED(loc_orig);

		if (reloc_handlers_rel[type] == NULL) {
			/* Unsupported relocation */
			pr_err("Unhandled relocation type %d at 0x%pK\n",
			       type, loc_orig);
			return -ENOEXEC;
		}

		res = reloc_handlers_rel[type](loc_orig, loc_new, offset);
		if (res)
			return res;
	}

	return 0;
}

/*
 * The exception table is filled in by the relocs tool after vmlinux is linked.
 * It must be relocated separately since there will not be any relocation
 * information for it filled in by the linker.
 */
static int __init relocate_exception_table(long offset)
{
	unsigned long *etable_start, *etable_end, *e;

	etable_start = RELOCATED(&__start___ex_table);
	etable_end = RELOCATED(&__stop___ex_table);

	for (e = etable_start; e < etable_end; e++)
		*e += offset;

	return 0;
}

#ifdef CONFIG_RANDOMIZE_BASE

static inline __init unsigned long rotate_xor(unsigned long hash,
					      const void *area, size_t size)
{
	size_t i;
	unsigned long *ptr = (unsigned long *)area;

	for (i = 0; i < size / sizeof(hash); i++) {
		/* Rotate by odd number of bits and XOR. */
		hash = (hash << ((sizeof(hash) * 8) - 7)) | (hash >> 7);
		hash ^= ptr[i];
	}

	return hash;
}

static inline __init unsigned long get_random_boot(void)
{
	unsigned long entropy = random_get_entropy();
	unsigned long hash = 0;

	/* Attempt to create a simple but unpredictable starting entropy. */
	hash = rotate_xor(hash, linux_banner, strlen(linux_banner));

	/* Add in any runtime entropy we can get */
	hash = rotate_xor(hash, &entropy, sizeof(entropy));

#if defined(CONFIG_USE_OF)
	/* Get any additional entropy passed in device tree */
	if (initial_boot_params) {
		int node, len;
		u64 *prop;

		node = fdt_path_offset(initial_boot_params, "/chosen");
		if (node >= 0) {
			prop = fdt_getprop_w(initial_boot_params, node,
					     "kaslr-seed", &len);
			if (prop && (len == sizeof(u64)))
				hash = rotate_xor(hash, prop, sizeof(*prop));
		}
	}
#endif /* CONFIG_USE_OF */

	return hash;
}

static inline __init bool kaslr_disabled(void)
{
	char *str;

#if defined(CONFIG_CMDLINE_BOOL)
	const char *builtin_cmdline = CONFIG_CMDLINE;

	str = strstr(builtin_cmdline, "nokaslr");
	if (str == builtin_cmdline ||
	    (str > builtin_cmdline && *(str - 1) == ' '))
		return true;
#endif
	str = strstr(arcs_cmdline, "nokaslr");
	if (str == arcs_cmdline || (str > arcs_cmdline && *(str - 1) == ' '))
		return true;

	return false;
}

static inline void __init *determine_relocation_address(void)
{
	/* Choose a new address for the kernel */
	unsigned long kernel_length;
	void *dest = &_text;
	unsigned long offset;

	if (kaslr_disabled())
		return dest;

	kernel_length = (long)_end - (long)(&_text);

	offset = get_random_boot() << 16;
	offset &= (CONFIG_RANDOMIZE_BASE_MAX_OFFSET - 1);
	if (offset < kernel_length)
		offset += ALIGN(kernel_length, 0xffff);

	return RELOCATED(dest);
}

#else

static inline void __init *determine_relocation_address(void)
{
	/*
	 * Choose a new address for the kernel
	 * For now we'll hard code the destination
	 */
	return (void *)0xffffffff81000000;
}

#endif

static inline int __init relocation_addr_valid(void *loc_new)
{
	if ((unsigned long)loc_new & 0x0000ffff) {
		/* Inappropriately aligned new location */
		return 0;
	}
	if ((unsigned long)loc_new < (unsigned long)&_end) {
		/* New location overlaps original kernel */
		return 0;
	}
	return 1;
}

void *__init relocate_kernel(void)
{
	void *loc_new;
	unsigned long kernel_length;
	unsigned long bss_length;
	long offset = 0;
	int res = 1;
	/* Default to original kernel entry point */
	void *kernel_entry = start_kernel;
	void *fdt = NULL;

	/* Get the command line */
	fw_init_cmdline();
#if defined(CONFIG_USE_OF)
	/* Deal with the device tree */
	fdt = plat_get_fdt();
	early_init_dt_scan(fdt);
	if (boot_command_line[0]) {
		/* Boot command line was passed in device tree */
		strlcpy(arcs_cmdline, boot_command_line, COMMAND_LINE_SIZE);
	}
#endif /* CONFIG_USE_OF */

	kernel_length = (long)(&_relocation_start) - (long)(&_text);
	bss_length = (long)&__bss_stop - (long)&__bss_start;

	loc_new = determine_relocation_address();

	/* Sanity check relocation address */
	if (relocation_addr_valid(loc_new))
		offset = (unsigned long)loc_new - (unsigned long)(&_text);

	/* Reset the command line now so we don't end up with a duplicate */
	arcs_cmdline[0] = '\0';

	if (offset) {
		void (*fdt_relocated_)(void *) = NULL;
#if defined(CONFIG_USE_OF)
		unsigned long fdt_phys = virt_to_phys(fdt);

		/*
		 * If built-in dtb is used then it will have been relocated
		 * during kernel _text relocation. If appended DTB is used
		 * then it will not be relocated, but it should remain
		 * intact in the original location. If dtb is loaded by
		 * the bootloader then it may need to be moved if it crosses
		 * the target memory area
		 */

		if (fdt_phys >= virt_to_phys(RELOCATED(&_text)) &&
			fdt_phys <= virt_to_phys(RELOCATED(&_end))) {
			void *fdt_relocated =
				RELOCATED(ALIGN((long)&_end, PAGE_SIZE));
			memcpy(fdt_relocated, fdt, fdt_totalsize(fdt));
			fdt = fdt_relocated;
			fdt_relocated_ = RELOCATED(&plat_fdt_relocated);
		}
#endif /* CONFIG_USE_OF */

		/* Copy the kernel to it's new location */
		memcpy(loc_new, &_text, kernel_length);

		/* Perform relocations on the new kernel */
		res = do_relocations(&_text, loc_new, offset);
		if (res < 0)
			goto out;

		/* Sync the caches ready for execution of new kernel */
		sync_icache(loc_new, kernel_length);

		res = relocate_exception_table(offset);
		if (res < 0)
			goto out;

		/*
		 * The original .bss has already been cleared, and
		 * some variables such as command line parameters
		 * stored to it so make a copy in the new location.
		 */
		memcpy(RELOCATED(&__bss_start), &__bss_start, bss_length);

		/*
		 * If fdt was stored outside of the kernel image and
		 * had to be moved then update platform's state data
		 * with the new fdt location
		 */
		if (fdt_relocated_)
			fdt_relocated_(fdt);

		/*
		 * Last chance for the platform to abort relocation.
		 * This may also be used by the platform to perform any
		 * initialisation required now that the new kernel is
		 * resident in memory and ready to be executed.
		 */
		if (plat_post_relocation(offset))
			goto out;

		/* The current thread is now within the relocated image */
		__current_thread_info = RELOCATED(&init_thread_union);

		/* Return the new kernel's entry point */
		kernel_entry = RELOCATED(start_kernel);
	}
out:
	return kernel_entry;
}

/*
 * Show relocation information on panic.
 */
void show_kernel_relocation(const char *level)
{
	unsigned long offset;

	offset = __pa_symbol(_text) - __pa_symbol(VMLINUX_LOAD_ADDRESS);

	if (IS_ENABLED(CONFIG_RELOCATABLE) && offset > 0) {
		printk(level);
		pr_cont("Kernel relocated by 0x%pK\n", (void *)offset);
		pr_cont(" .text @ 0x%pK\n", _text);
		pr_cont(" .data @ 0x%pK\n", _sdata);
		pr_cont(" .bss  @ 0x%pK\n", __bss_start);
	}
}

static int kernel_location_notifier_fn(struct notifier_block *self,
				       unsigned long v, void *p)
{
	show_kernel_relocation(KERN_EMERG);
	return NOTIFY_DONE;
}

static struct notifier_block kernel_location_notifier = {
	.notifier_call = kernel_location_notifier_fn
};

static int __init register_kernel_offset_dumper(void)
{
	atomic_notifier_chain_register(&panic_notifier_list,
				       &kernel_location_notifier);
	return 0;
}
__initcall(register_kernel_offset_dumper);
Commit	Line	Data
279b991b MR	1	/*
	2	* This file is subject to the terms and conditions of the GNU General Public
	3	* License. See the file "COPYING" in the main directory of this archive
	4	* for more details.
	5	*
	6	* Support for Kernel relocation at boot time
	7	*
	8	* Copyright (C) 2015, Imagination Technologies Ltd.
	9	* Authors: Matt Redfearn (matt.redfearn@imgtec.com)
	10	*/
405bc8fd	11	#include <asm/bootinfo.h>
279b991b	12	#include <asm/cacheflush.h>
405bc8fd	13	#include <asm/fw/fw.h>
279b991b MR	14	#include <asm/sections.h>
	15	#include <asm/setup.h>
	16	#include <asm/timex.h>
	17	#include <linux/elf.h>
	18	#include <linux/kernel.h>
405bc8fd MR	19	#include <linux/libfdt.h>
405bc8fd MR	20	#include <linux/of_fdt.h>
279b991b MR	21	#include <linux/sched.h>
	22	#include <linux/start_kernel.h>
	23	#include <linux/string.h>
405bc8fd	24	#include <linux/printk.h>
279b991b MR	25
	26	#define RELOCATED(x) ((void *)((long)x + offset))
	27
	28	extern u32 _relocation_start[]; /* End kernel image / start relocation table */
	29	extern u32 _relocation_end[]; /* End relocation table */
	30
	31	extern long __start___ex_table; /* Start exception table */
	32	extern long __stop___ex_table; /* End exception table */
	33
4c9fff36 MN	34	extern void __weak plat_fdt_relocated(void *new_location);
4c9fff36 MN	35
8cc709d7 SH	36	/*
	37	* This function may be defined for a platform to perform any post-relocation
	38	* fixup necessary.
	39	* Return non-zero to abort relocation
	40	*/
	41	int __weak plat_post_relocation(long offset)
	42	{
	43	return 0;
	44	}
	45
279b991b MR	46	static inline u32 __init get_synci_step(void)
	47	{
	48	u32 res;
	49
	50	__asm__("rdhwr %0, $1" : "=r" (res));
	51
	52	return res;
	53	}
	54
	55	static void __init sync_icache(void *kbase, unsigned long kernel_length)
	56	{
	57	void *kend = kbase + kernel_length;
	58	u32 step = get_synci_step();
	59
	60	do {
	61	__asm__ __volatile__(
	62	"synci 0(%0)"
	63	: /* no output */
	64	: "r" (kbase));
	65
	66	kbase += step;
	67	} while (kbase < kend);
	68
	69	/* Completion barrier */
	70	__sync();
	71	}
	72
	73	static int __init apply_r_mips_64_rel(u32 loc_orig, u32 loc_new, long offset)
	74	{
	75	(u64 )loc_new += offset;
	76
	77	return 0;
	78	}
	79
	80	static int __init apply_r_mips_32_rel(u32 loc_orig, u32 loc_new, long offset)
	81	{
	82	*loc_new += offset;
	83
	84	return 0;
	85	}
	86
	87	static int __init apply_r_mips_26_rel(u32 loc_orig, u32 loc_new, long offset)
	88	{
	89	unsigned long target_addr = (*loc_orig) & 0x03ffffff;
	90
	91	if (offset % 4) {
	92	pr_err("Dangerous R_MIPS_26 REL relocation\n");
	93	return -ENOEXEC;
	94	}
	95
	96	/* Original target address */
	97	target_addr <<= 2;
	98	target_addr += (unsigned long)loc_orig & ~0x03ffffff;
	99
	100	/* Get the new target address */
	101	target_addr += offset;
	102
	103	if ((target_addr & 0xf0000000) != ((unsigned long)loc_new & 0xf0000000)) {
	104	pr_err("R_MIPS_26 REL relocation overflow\n");
	105	return -ENOEXEC;
	106	}
	107
	108	target_addr -= (unsigned long)loc_new & ~0x03ffffff;
	109	target_addr >>= 2;
110
111	loc_new = (loc_new & ~0x03ffffff) \| (target_addr & 0x03ffffff);
112
113	return 0;
114	}
115
116
117	static int __init apply_r_mips_hi16_rel(u32 loc_orig, u32 loc_new, long offset)
118	{
119	unsigned long insn = *loc_orig;
120	unsigned long target = (insn & 0xffff) << 16; /* high 16bits of target */
121
122	target += offset;
123
124	*loc_new = (insn & ~0xffff) \| ((target >> 16) & 0xffff);
125	return 0;
126	}
127
128	static int (reloc_handlers_rel[]) (u32 , u32 *, long) __initdata = {
129	[R_MIPS_64] = apply_r_mips_64_rel,
130	[R_MIPS_32] = apply_r_mips_32_rel,
131	[R_MIPS_26] = apply_r_mips_26_rel,
132	[R_MIPS_HI16] = apply_r_mips_hi16_rel,
133	};
134
135	int __init do_relocations(void kbase_old, void kbase_new, long offset)
136	{
137	u32 *r;
138	u32 *loc_orig;
139	u32 *loc_new;
140	int type;
141	int res;
142
143	for (r = _relocation_start; r < _relocation_end; r++) {
144	/* Sentinel for last relocation */
145	if (*r == 0)
146	break;
147
148	type = (*r >> 24) & 0xff;
149	loc_orig = (void )(kbase_old + ((r & 0x00ffffff) << 2));
150	loc_new = RELOCATED(loc_orig);
151
152	if (reloc_handlers_rel[type] == NULL) {
153	/* Unsupported relocation */
154	pr_err("Unhandled relocation type %d at 0x%pK\n",
155	type, loc_orig);
156	return -ENOEXEC;
157	}
158
159	res = reloc_handlers_rel[type](loc_orig, loc_new, offset);
160	if (res)
161	return res;
162	}
163
164	return 0;
165	}
166
167	/*
168	* The exception table is filled in by the relocs tool after vmlinux is linked.
169	* It must be relocated separately since there will not be any relocation
170	* information for it filled in by the linker.
171	*/
172	static int __init relocate_exception_table(long offset)
173	{
174	unsigned long etable_start, etable_end, *e;
175
176	etable_start = RELOCATED(&__start___ex_table);
177	etable_end = RELOCATED(&__stop___ex_table);
178
179	for (e = etable_start; e < etable_end; e++)
180	*e += offset;
181
182	return 0;
183	}
184
405bc8fd MR	185	#ifdef CONFIG_RANDOMIZE_BASE
	186
	187	static inline __init unsigned long rotate_xor(unsigned long hash,
	188	const void *area, size_t size)
	189	{
	190	size_t i;
	191	unsigned long ptr = (unsigned long )area;
	192
	193	for (i = 0; i < size / sizeof(hash); i++) {
	194	/* Rotate by odd number of bits and XOR. */
	195	hash = (hash << ((sizeof(hash) * 8) - 7)) \| (hash >> 7);
	196	hash ^= ptr[i];
	197	}
	198
	199	return hash;
	200	}
	201
	202	static inline __init unsigned long get_random_boot(void)
	203	{
	204	unsigned long entropy = random_get_entropy();
	205	unsigned long hash = 0;
	206
	207	/* Attempt to create a simple but unpredictable starting entropy. */
	208	hash = rotate_xor(hash, linux_banner, strlen(linux_banner));
	209
	210	/* Add in any runtime entropy we can get */
	211	hash = rotate_xor(hash, &entropy, sizeof(entropy));
	212
	213	#if defined(CONFIG_USE_OF)
	214	/* Get any additional entropy passed in device tree */
47366979	215	if (initial_boot_params) {
405bc8fd MR	216	int node, len;
	217	u64 *prop;
	218
	219	node = fdt_path_offset(initial_boot_params, "/chosen");
	220	if (node >= 0) {
	221	prop = fdt_getprop_w(initial_boot_params, node,
	222	"kaslr-seed", &len);
	223	if (prop && (len == sizeof(u64)))
	224	hash = rotate_xor(hash, prop, sizeof(*prop));
	225	}
	226	}
	227	#endif /* CONFIG_USE_OF */
	228
	229	return hash;
	230	}
	231
	232	static inline __init bool kaslr_disabled(void)
	233	{
	234	char *str;
	235
	236	#if defined(CONFIG_CMDLINE_BOOL)
	237	const char *builtin_cmdline = CONFIG_CMDLINE;
	238
	239	str = strstr(builtin_cmdline, "nokaslr");
	240	if (str == builtin_cmdline \|\|
	241	(str > builtin_cmdline && *(str - 1) == ' '))
	242	return true;
	243	#endif
	244	str = strstr(arcs_cmdline, "nokaslr");
	245	if (str == arcs_cmdline \|\| (str > arcs_cmdline && *(str - 1) == ' '))
	246	return true;
	247
	248	return false;
	249	}
	250
	251	static inline void __init *determine_relocation_address(void)
	252	{
	253	/* Choose a new address for the kernel */
	254	unsigned long kernel_length;
	255	void *dest = &_text;
	256	unsigned long offset;
	257
	258	if (kaslr_disabled())
	259	return dest;
	260
	261	kernel_length = (long)_end - (long)(&_text);
	262
	263	offset = get_random_boot() << 16;
	264	offset &= (CONFIG_RANDOMIZE_BASE_MAX_OFFSET - 1);
	265	if (offset < kernel_length)
	266	offset += ALIGN(kernel_length, 0xffff);
	267
	268	return RELOCATED(dest);
	269	}
	270
	271	#else
	272
279b991b MR	273	static inline void __init *determine_relocation_address(void)
	274	{
	275	/*
	276	* Choose a new address for the kernel
	277	* For now we'll hard code the destination
	278	*/
	279	return (void *)0xffffffff81000000;
	280	}
	281
405bc8fd MR	282	#endif
405bc8fd MR	283
279b991b MR	284	static inline int __init relocation_addr_valid(void *loc_new)
	285	{
	286	if ((unsigned long)loc_new & 0x0000ffff) {
	287	/* Inappropriately aligned new location */
	288	return 0;
	289	}
	290	if ((unsigned long)loc_new < (unsigned long)&_end) {
	291	/* New location overlaps original kernel */
	292	return 0;
	293	}
	294	return 1;
	295	}
	296
	297	void *__init relocate_kernel(void)
	298	{
	299	void *loc_new;
	300	unsigned long kernel_length;
	301	unsigned long bss_length;
	302	long offset = 0;
	303	int res = 1;
	304	/* Default to original kernel entry point */
	305	void *kernel_entry = start_kernel;
4c9fff36	306	void *fdt = NULL;
279b991b	307
405bc8fd MR	308	/* Get the command line */
	309	fw_init_cmdline();
	310	#if defined(CONFIG_USE_OF)
	311	/* Deal with the device tree */
4c9fff36 MN	312	fdt = plat_get_fdt();
4c9fff36 MN	313	early_init_dt_scan(fdt);
405bc8fd MR	314	if (boot_command_line[0]) {
	315	/* Boot command line was passed in device tree */
	316	strlcpy(arcs_cmdline, boot_command_line, COMMAND_LINE_SIZE);
	317	}
	318	#endif /* CONFIG_USE_OF */
	319
279b991b MR	320	kernel_length = (long)(&_relocation_start) - (long)(&_text);
	321	bss_length = (long)&__bss_stop - (long)&__bss_start;
	322
	323	loc_new = determine_relocation_address();
	324
	325	/* Sanity check relocation address */
	326	if (relocation_addr_valid(loc_new))
	327	offset = (unsigned long)loc_new - (unsigned long)(&_text);
	328
405bc8fd MR	329	/* Reset the command line now so we don't end up with a duplicate */
	330	arcs_cmdline[0] = '\0';
	331
279b991b	332	if (offset) {
4c9fff36 MN	333	void (fdt_relocated_)(void ) = NULL;
	334	#if defined(CONFIG_USE_OF)
	335	unsigned long fdt_phys = virt_to_phys(fdt);
	336
	337	/*
	338	* If built-in dtb is used then it will have been relocated
	339	* during kernel _text relocation. If appended DTB is used
	340	* then it will not be relocated, but it should remain
	341	* intact in the original location. If dtb is loaded by
	342	* the bootloader then it may need to be moved if it crosses
	343	* the target memory area
	344	*/
	345
	346	if (fdt_phys >= virt_to_phys(RELOCATED(&_text)) &&
	347	fdt_phys <= virt_to_phys(RELOCATED(&_end))) {
	348	void *fdt_relocated =
	349	RELOCATED(ALIGN((long)&_end, PAGE_SIZE));
	350	memcpy(fdt_relocated, fdt, fdt_totalsize(fdt));
	351	fdt = fdt_relocated;
	352	fdt_relocated_ = RELOCATED(&plat_fdt_relocated);
	353	}
	354	#endif /* CONFIG_USE_OF */
	355
279b991b MR	356	/* Copy the kernel to it's new location */
	357	memcpy(loc_new, &_text, kernel_length);
	358
	359	/* Perform relocations on the new kernel */
	360	res = do_relocations(&_text, loc_new, offset);
	361	if (res < 0)
	362	goto out;
	363
	364	/* Sync the caches ready for execution of new kernel */
	365	sync_icache(loc_new, kernel_length);
	366
	367	res = relocate_exception_table(offset);
	368	if (res < 0)
	369	goto out;
	370
	371	/*
	372	* The original .bss has already been cleared, and
	373	* some variables such as command line parameters
	374	* stored to it so make a copy in the new location.
	375	*/
	376	memcpy(RELOCATED(&__bss_start), &__bss_start, bss_length);
	377
4c9fff36 MN	378	/*
	379	* If fdt was stored outside of the kernel image and
	380	* had to be moved then update platform's state data
	381	* with the new fdt location
	382	*/
	383	if (fdt_relocated_)
	384	fdt_relocated_(fdt);
	385
8cc709d7 SH	386	/*
	387	* Last chance for the platform to abort relocation.
	388	* This may also be used by the platform to perform any
	389	* initialisation required now that the new kernel is
	390	* resident in memory and ready to be executed.
	391	*/
	392	if (plat_post_relocation(offset))
	393	goto out;
	394
279b991b MR	395	/* The current thread is now within the relocated image */
	396	__current_thread_info = RELOCATED(&init_thread_union);
	397
	398	/* Return the new kernel's entry point */
	399	kernel_entry = RELOCATED(start_kernel);
	400	}
	401	out:
	402	return kernel_entry;
	403	}
405bc8fd MR	404
	405	/*
	406	* Show relocation information on panic.
	407	*/
	408	void show_kernel_relocation(const char *level)
	409	{
	410	unsigned long offset;
	411
	412	offset = __pa_symbol(_text) - __pa_symbol(VMLINUX_LOAD_ADDRESS);
	413
	414	if (IS_ENABLED(CONFIG_RELOCATABLE) && offset > 0) {
	415	printk(level);
	416	pr_cont("Kernel relocated by 0x%pK\n", (void *)offset);
	417	pr_cont(" .text @ 0x%pK\n", _text);
	418	pr_cont(" .data @ 0x%pK\n", _sdata);
	419	pr_cont(" .bss @ 0x%pK\n", __bss_start);
	420	}
	421	}
	422
	423	static int kernel_location_notifier_fn(struct notifier_block *self,
	424	unsigned long v, void *p)
	425	{
	426	show_kernel_relocation(KERN_EMERG);
	427	return NOTIFY_DONE;
	428	}
	429
	430	static struct notifier_block kernel_location_notifier = {
	431	.notifier_call = kernel_location_notifier_fn
	432	};
	433
	434	static int __init register_kernel_offset_dumper(void)
	435	{
	436	atomic_notifier_chain_register(&panic_notifier_list,
	437	&kernel_location_notifier);
	438	return 0;
	439	}
	440	__initcall(register_kernel_offset_dumper);