Skip to content

Commit

Permalink
kernel/kexec_file.c: split up __kexec_load_puragory
Browse files Browse the repository at this point in the history 
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/[email protected]
Signed-off-by: Philipp Rudo <[email protected]>
Acked-by: Dave Young <[email protected]>
Cc: AKASHI Takahiro <[email protected]>
Cc: Eric Biederman <[email protected]>
Cc: Heiko Carstens <[email protected]>
Cc: Ingo Molnar <[email protected]>
Cc: Martin Schwidefsky <[email protected]>
Cc: Michael Ellerman <[email protected]>
Cc: Thiago Jung Bauermann <[email protected]>
Cc: Vivek Goyal <[email protected]>
Signed-off-by: Andrew Morton <[email protected]>
Signed-off-by: Linus Torvalds <[email protected]>
  • Loading branch information
@torvalds
Philipp Rudo authored and torvalds committed Apr 14, 2018
1 parent 8aec395 commit 9304570
Showing 1 changed file with 103 additions and 97 deletions.
200 changes: 103 additions & 97 deletions kernel/kexec_file.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -710,39 +710,97 @@ static int kexec_calculate_store_digests(struct kimage *image)
}

#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)
/*
* 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.
*/
static int kexec_purgatory_setup_kbuf(struct purgatory_info *pi,
struct kexec_buf *kbuf)
{
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 };
const Elf_Shdr *sechdrs;
unsigned long bss_align;
unsigned long bss_sz;
unsigned long align;
int i, ret;

/*
* sechdrs_c points to section headers in purgatory and are read
* only. No modifications allowed.
*/
sechdrs_c = (void *)pi->ehdr + pi->ehdr->e_shoff;
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;
}

/*
* 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;

/*
* 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.
*/
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
Expand Down Expand Up @@ -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;
Expand All @@ -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;

Expand Down Expand Up @@ -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;

/* Used later to get/set symbol values */
pi->sechdrs = sechdrs;
kbuf->image->start += sechdrs[entry_sidx].sh_addr;

/*
* 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)
Expand Down Expand Up @@ -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;
Expand All @@ -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;
Expand Down

0 comments on commit 9304570

Please sign in to comment.