Commit 93045705 authored by Philipp Rudo's avatar Philipp Rudo Committed by Linus Torvalds
Browse files

kernel/kexec_file.c: split up __kexec_load_puragory 

When inspecting __kexec_load_purgatory you find that it has two tasks

	1) setting up the kexec_buffer for the new kernel and,
	2) setting up pi->sechdrs for the final load address.

The two tasks are independent of each other.  To improve readability
split up __kexec_load_purgatory into two functions, one for each task,
and call them directly from kexec_load_purgatory.

Link: http://lkml.kernel.org/r/20180321112751.22196-7-prudo@linux.vnet.ibm.com


Signed-off-by: default avatarPhilipp Rudo <prudo@linux.vnet.ibm.com>
Acked-by: default avatarDave Young <dyoung@redhat.com>
Cc: AKASHI Takahiro <takahiro.akashi@linaro.org>
Cc: Eric Biederman <ebiederm@xmission.com>
Cc: Heiko Carstens <heiko.carstens@de.ibm.com>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Martin Schwidefsky <schwidefsky@de.ibm.com>
Cc: Michael Ellerman <mpe@ellerman.id.au>
Cc: Thiago Jung Bauermann <bauerman@linux.vnet.ibm.com>
Cc: Vivek Goyal <vgoyal@redhat.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 8aec395b

kernel/kexec_file.c

+103 −97
Original line number Diff line number Diff line
@@ -710,39 +710,97 @@ out: 
}



#ifdef CONFIG_ARCH_HAS_KEXEC_PURGATORY

/* Actually load purgatory. Lot of code taken from kexec-tools */

static int __kexec_load_purgatory(struct kimage *image, unsigned long min,

				  unsigned long max, int top_down)

{

	struct purgatory_info *pi = &image->purgatory_info;

	unsigned long align, bss_align, bss_sz, bss_pad;

	unsigned long entry, load_addr, curr_load_addr, bss_addr, offset;

	unsigned char *buf_addr, *src;

	int i, ret = 0, entry_sidx = -1;

	const Elf_Shdr *sechdrs_c;

	Elf_Shdr *sechdrs = NULL;

	struct kexec_buf kbuf = { .image = image, .bufsz = 0, .buf_align = 1,

				  .buf_min = min, .buf_max = max,

				  .top_down = top_down };



/*

	 * sechdrs_c points to section headers in purgatory and are read

	 * only. No modifications allowed.

 * kexec_purgatory_setup_kbuf - prepare buffer to load purgatory.

 * @pi:		Purgatory to be loaded.

 * @kbuf:	Buffer to setup.

 *

 * Allocates the memory needed for the buffer. Caller is responsible to free

 * the memory after use.

 *

 * Return: 0 on success, negative errno on error.

 */

	sechdrs_c = (void *)pi->ehdr + pi->ehdr->e_shoff;

static int kexec_purgatory_setup_kbuf(struct purgatory_info *pi,

				      struct kexec_buf *kbuf)

{

	const Elf_Shdr *sechdrs;

	unsigned long bss_align;

	unsigned long bss_sz;

	unsigned long align;

	int i, ret;



	sechdrs = (void *)pi->ehdr + pi->ehdr->e_shoff;

	bss_align = 1;

	bss_sz = 0;



	for (i = 0; i < pi->ehdr->e_shnum; i++) {

		if (!(sechdrs[i].sh_flags & SHF_ALLOC))

			continue;



		align = sechdrs[i].sh_addralign;

		if (sechdrs[i].sh_type != SHT_NOBITS) {

			if (kbuf->buf_align < align)

				kbuf->buf_align = align;

			kbuf->bufsz = ALIGN(kbuf->bufsz, align);

			kbuf->bufsz += sechdrs[i].sh_size;

		} else {

			if (bss_align < align)

				bss_align = align;

			bss_sz = ALIGN(bss_sz, align);

			bss_sz += sechdrs[i].sh_size;

		}

	}

	kbuf->bufsz = ALIGN(kbuf->bufsz, bss_align);

	kbuf->memsz = kbuf->bufsz + bss_sz;

	if (kbuf->buf_align < bss_align)

		kbuf->buf_align = bss_align;



	kbuf->buffer = vzalloc(kbuf->bufsz);

	if (!kbuf->buffer)

		return -ENOMEM;

	pi->purgatory_buf = kbuf->buffer;



	ret = kexec_add_buffer(kbuf);

	if (ret)

		goto out;

	pi->purgatory_load_addr = kbuf->mem;



	return 0;

out:

	vfree(pi->purgatory_buf);

	pi->purgatory_buf = NULL;

	return ret;

}



/*

	 * We can not modify sechdrs_c[] and its fields. It is read only.

	 * Copy it over to a local copy where one can store some temporary

	 * data and free it at the end. We need to modify ->sh_addr and

	 * ->sh_offset fields to keep track of permanent and temporary

	 * locations of sections.

 * kexec_purgatory_setup_sechdrs - prepares the pi->sechdrs buffer.

 * @pi:		Purgatory to be loaded.

 * @kbuf:	Buffer prepared to store purgatory.

 *

 * Allocates the memory needed for the buffer. Caller is responsible to free

 * the memory after use.

 *

 * Return: 0 on success, negative errno on error.

 */

static int kexec_purgatory_setup_sechdrs(struct purgatory_info *pi,

					 struct kexec_buf *kbuf)

{

	unsigned long curr_load_addr;

	unsigned long load_addr;

	unsigned long bss_addr;

	unsigned long offset;

	unsigned char *buf_addr;

	unsigned char *src;

	Elf_Shdr *sechdrs;

	int entry_sidx = -1;

	int i;



	sechdrs = vzalloc(pi->ehdr->e_shnum * sizeof(Elf_Shdr));

	if (!sechdrs)

		return -ENOMEM;



	memcpy(sechdrs, sechdrs_c, pi->ehdr->e_shnum * sizeof(Elf_Shdr));

	memcpy(sechdrs, (void *)pi->ehdr + pi->ehdr->e_shoff,

	       pi->ehdr->e_shnum * sizeof(Elf_Shdr));

	pi->sechdrs = sechdrs;



	/*

	 * We seem to have multiple copies of sections. First copy is which
@@ -770,7 +828,7 @@ static int __kexec_load_purgatory(struct kimage *image, unsigned long min, 
	 * Identify entry point section and make entry relative to section

	 * start.

	 */

	entry = pi->ehdr->e_entry;

	kbuf->image->start = pi->ehdr->e_entry;

	for (i = 0; i < pi->ehdr->e_shnum; i++) {

		if (!(sechdrs[i].sh_flags & SHF_ALLOC))

			continue;
@@ -783,63 +841,19 @@ static int __kexec_load_purgatory(struct kimage *image, unsigned long min, 
		    ((sechdrs[i].sh_addr + sechdrs[i].sh_size) >

		     pi->ehdr->e_entry)) {

			entry_sidx = i;

			entry -= sechdrs[i].sh_addr;

			kbuf->image->start -= sechdrs[i].sh_addr;

			break;

		}

	}



	/* Determine how much memory is needed to load relocatable object. */

	bss_align = 1;

	bss_sz = 0;



	for (i = 0; i < pi->ehdr->e_shnum; i++) {

		if (!(sechdrs[i].sh_flags & SHF_ALLOC))

			continue;



		align = sechdrs[i].sh_addralign;

		if (sechdrs[i].sh_type != SHT_NOBITS) {

			if (kbuf.buf_align < align)

				kbuf.buf_align = align;

			kbuf.bufsz = ALIGN(kbuf.bufsz, align);

			kbuf.bufsz += sechdrs[i].sh_size;

		} else {

			/* bss section */

			if (bss_align < align)

				bss_align = align;

			bss_sz = ALIGN(bss_sz, align);

			bss_sz += sechdrs[i].sh_size;

		}

	}



	/* Determine the bss padding required to align bss properly */

	bss_pad = 0;

	if (kbuf.bufsz & (bss_align - 1))

		bss_pad = bss_align - (kbuf.bufsz & (bss_align - 1));



	kbuf.memsz = kbuf.bufsz + bss_pad + bss_sz;



	/* Allocate buffer for purgatory */

	kbuf.buffer = vzalloc(kbuf.bufsz);

	if (!kbuf.buffer) {

		ret = -ENOMEM;

		goto out;

	}



	if (kbuf.buf_align < bss_align)

		kbuf.buf_align = bss_align;



	/* Add buffer to segment list */

	ret = kexec_add_buffer(&kbuf);

	if (ret)

		goto out;

	pi->purgatory_load_addr = kbuf.mem;



	/* Load SHF_ALLOC sections */

	buf_addr = kbuf.buffer;

	load_addr = curr_load_addr = pi->purgatory_load_addr;

	bss_addr = load_addr + kbuf.bufsz + bss_pad;

	buf_addr = kbuf->buffer;

	load_addr = curr_load_addr = kbuf->mem;

	bss_addr = load_addr + kbuf->bufsz;



	for (i = 0; i < pi->ehdr->e_shnum; i++) {

		unsigned long align;



		if (!(sechdrs[i].sh_flags & SHF_ALLOC))

			continue;
@@ -871,24 +885,9 @@ static int __kexec_load_purgatory(struct kimage *image, unsigned long min, 


	/* Update entry point based on load address of text section */

	if (entry_sidx >= 0)

		entry += sechdrs[entry_sidx].sh_addr;



	/* Make kernel jump to purgatory after shutdown */

	image->start = entry;

		kbuf->image->start += sechdrs[entry_sidx].sh_addr;



	/* Used later to get/set symbol values */

	pi->sechdrs = sechdrs;



	/*

	 * Used later to identify which section is purgatory and skip it

	 * from checksumming.

	 */

	pi->purgatory_buf = kbuf.buffer;

	return ret;

out:

	vfree(sechdrs);

	vfree(kbuf.buffer);

	return ret;

	return 0;

}



static int kexec_apply_relocations(struct kimage *image)
@@ -958,16 +957,23 @@ int kexec_load_purgatory(struct kimage *image, unsigned long min, 
{

	struct purgatory_info *pi = &image->purgatory_info;

	int ret;

	struct kexec_buf kbuf = { .image = image, .bufsz = 0, .buf_align = 1,

				  .buf_min = min, .buf_max = max,

				  .top_down = top_down };



	if (kexec_purgatory_size <= 0)

		return -EINVAL;



	pi->ehdr = (const Elf_Ehdr *)kexec_purgatory;



	ret = __kexec_load_purgatory(image, min, max, top_down);

	ret = kexec_purgatory_setup_kbuf(pi, &kbuf);

	if (ret)

		return ret;



	ret = kexec_purgatory_setup_sechdrs(pi, &kbuf);

	if (ret)

		goto out_free_kbuf;



	ret = kexec_apply_relocations(image);

	if (ret)

		goto out;
@@ -977,7 +983,7 @@ int kexec_load_purgatory(struct kimage *image, unsigned long min, 
out:

	vfree(pi->sechdrs);

	pi->sechdrs = NULL;



out_free_kbuf:

	vfree(pi->purgatory_buf);

	pi->purgatory_buf = NULL;

	return ret;

CRA Git | Maintained and supported by SUSTech CRA and CCSE