lkml.org 
[lkml]   [2016]   [Jul]   [10]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
Date
From
SubjectRe: [PATCH v4 2/9] kexec_file: Change kexec_add_buffer to take kexec_buf as argument.
On 07/07/16 at 01:23pm, Thiago Jung Bauermann wrote:
> Adapt all callers to the new function prototype.
>
> In addition, change the type of kexec_buf.buffer from char * to void *.
> There is no particular reason for it to be a char *, and the change
> allows us to get rid of 3 existing casts to char * in the code.
>
> Signed-off-by: Thiago Jung Bauermann <bauerman@linux.vnet.ibm.com>
> Cc: Eric Biederman <ebiederm@xmission.com>
> Cc: Dave Young <dyoung@redhat.com>
> Cc: Thomas Gleixner <tglx@linutronix.de>
> Cc: Ingo Molnar <mingo@redhat.com>
> Cc: "H. Peter Anvin" <hpa@zytor.com>
> Cc: x86@kernel.org
> ---
> arch/x86/kernel/crash.c | 37 ++++++++--------
> arch/x86/kernel/kexec-bzimage64.c | 48 +++++++++++----------
> include/linux/kexec.h | 8 +---
> kernel/kexec_file.c | 88 ++++++++++++++++++---------------------
> 4 files changed, 87 insertions(+), 94 deletions(-)
>
> diff --git a/arch/x86/kernel/crash.c b/arch/x86/kernel/crash.c
> index 9ef978d69c22..dc026ea361dc 100644
> --- a/arch/x86/kernel/crash.c
> +++ b/arch/x86/kernel/crash.c
> @@ -615,9 +615,9 @@ static int determine_backup_region(u64 start, u64 end, void *arg)
>
> int crash_load_segments(struct kimage *image)
> {
> - unsigned long src_start, src_sz, elf_sz;
> - void *elf_addr;
> int ret;
> + struct kexec_buf kbuf = { .image = image, .buf_min = 0,
> + .buf_max = ULONG_MAX, .top_down = false };
>
> /*
> * Determine and load a segment for backup area. First 640K RAM
> @@ -631,43 +631,44 @@ int crash_load_segments(struct kimage *image)
> if (ret < 0)
> return ret;
>
> - src_start = image->arch.backup_src_start;
> - src_sz = image->arch.backup_src_sz;
> -
> /* Add backup segment. */
> - if (src_sz) {
> + if (image->arch.backup_src_sz) {
> + kbuf.buffer = &crash_zero_bytes;
> + kbuf.bufsz = sizeof(crash_zero_bytes);
> + kbuf.memsz = image->arch.backup_src_sz;
> + kbuf.buf_align = PAGE_SIZE;
> /*
> * Ideally there is no source for backup segment. This is
> * copied in purgatory after crash. Just add a zero filled
> * segment for now to make sure checksum logic works fine.
> */
> - ret = kexec_add_buffer(image, (char *)&crash_zero_bytes,
> - sizeof(crash_zero_bytes), src_sz,
> - PAGE_SIZE, 0, -1, 0,
> - &image->arch.backup_load_addr);
> + ret = kexec_add_buffer(&kbuf);
> if (ret)
> return ret;
> + image->arch.backup_load_addr = kbuf.mem;
> pr_debug("Loaded backup region at 0x%lx backup_start=0x%lx memsz=0x%lx\n",
> - image->arch.backup_load_addr, src_start, src_sz);
> + image->arch.backup_load_addr,
> + image->arch.backup_src_start, kbuf.memsz);
> }
>
> /* Prepare elf headers and add a segment */
> - ret = prepare_elf_headers(image, &elf_addr, &elf_sz);
> + ret = prepare_elf_headers(image, &kbuf.buffer, &kbuf.bufsz);
> if (ret)
> return ret;
>
> - image->arch.elf_headers = elf_addr;
> - image->arch.elf_headers_sz = elf_sz;
> + image->arch.elf_headers = kbuf.buffer;
> + image->arch.elf_headers_sz = kbuf.bufsz;
>
> - ret = kexec_add_buffer(image, (char *)elf_addr, elf_sz, elf_sz,
> - ELF_CORE_HEADER_ALIGN, 0, -1, 0,
> - &image->arch.elf_load_addr);
> + kbuf.memsz = kbuf.bufsz;
> + kbuf.buf_align = ELF_CORE_HEADER_ALIGN;
> + ret = kexec_add_buffer(&kbuf);
> if (ret) {
> vfree((void *)image->arch.elf_headers);
> return ret;
> }
> + image->arch.elf_load_addr = kbuf.mem;
> pr_debug("Loaded ELF headers at 0x%lx bufsz=0x%lx memsz=0x%lx\n",
> - image->arch.elf_load_addr, elf_sz, elf_sz);
> + image->arch.elf_load_addr, kbuf.bufsz, kbuf.bufsz);
>
> return ret;
> }
> diff --git a/arch/x86/kernel/kexec-bzimage64.c b/arch/x86/kernel/kexec-bzimage64.c
> index f2356bda2b05..4b3a75329fb6 100644
> --- a/arch/x86/kernel/kexec-bzimage64.c
> +++ b/arch/x86/kernel/kexec-bzimage64.c
> @@ -331,17 +331,17 @@ static void *bzImage64_load(struct kimage *image, char *kernel,
>
> struct setup_header *header;
> int setup_sects, kern16_size, ret = 0;
> - unsigned long setup_header_size, params_cmdline_sz, params_misc_sz;
> + unsigned long setup_header_size, params_cmdline_sz;
> struct boot_params *params;
> unsigned long bootparam_load_addr, kernel_load_addr, initrd_load_addr;
> unsigned long purgatory_load_addr;
> - unsigned long kernel_bufsz, kernel_memsz, kernel_align;
> - char *kernel_buf;
> struct bzimage64_data *ldata;
> struct kexec_entry64_regs regs64;
> void *stack;
> unsigned int setup_hdr_offset = offsetof(struct boot_params, hdr);
> unsigned int efi_map_offset, efi_map_sz, efi_setup_data_offset;
> + struct kexec_buf kbuf = { .image = image, .buf_max = ULONG_MAX,
> + .top_down = true };
>
> header = (struct setup_header *)(kernel + setup_hdr_offset);
> setup_sects = header->setup_sects;
> @@ -402,11 +402,11 @@ static void *bzImage64_load(struct kimage *image, char *kernel,
> params_cmdline_sz = sizeof(struct boot_params) + cmdline_len +
> MAX_ELFCOREHDR_STR_LEN;
> params_cmdline_sz = ALIGN(params_cmdline_sz, 16);
> - params_misc_sz = params_cmdline_sz + efi_map_sz +
> + kbuf.bufsz = params_cmdline_sz + efi_map_sz +
> sizeof(struct setup_data) +
> sizeof(struct efi_setup_data);
>
> - params = kzalloc(params_misc_sz, GFP_KERNEL);
> + params = kzalloc(kbuf.bufsz, GFP_KERNEL);
> if (!params)
> return ERR_PTR(-ENOMEM);
> efi_map_offset = params_cmdline_sz;
> @@ -418,37 +418,41 @@ static void *bzImage64_load(struct kimage *image, char *kernel,
> /* Is there a limit on setup header size? */
> memcpy(&params->hdr, (kernel + setup_hdr_offset), setup_header_size);
>
> - ret = kexec_add_buffer(image, (char *)params, params_misc_sz,
> - params_misc_sz, 16, MIN_BOOTPARAM_ADDR,
> - ULONG_MAX, 1, &bootparam_load_addr);
> + kbuf.buffer = params;
> + kbuf.memsz = kbuf.bufsz;
> + kbuf.buf_align = 16;
> + kbuf.buf_min = MIN_BOOTPARAM_ADDR;
> + ret = kexec_add_buffer(&kbuf);
> if (ret)
> goto out_free_params;
> + bootparam_load_addr = kbuf.mem;
> pr_debug("Loaded boot_param, command line and misc at 0x%lx bufsz=0x%lx memsz=0x%lx\n",
> - bootparam_load_addr, params_misc_sz, params_misc_sz);
> + bootparam_load_addr, kbuf.bufsz, kbuf.bufsz);
>
> /* Load kernel */
> - kernel_buf = kernel + kern16_size;
> - kernel_bufsz = kernel_len - kern16_size;
> - kernel_memsz = PAGE_ALIGN(header->init_size);
> - kernel_align = header->kernel_alignment;
> -
> - ret = kexec_add_buffer(image, kernel_buf,
> - kernel_bufsz, kernel_memsz, kernel_align,
> - MIN_KERNEL_LOAD_ADDR, ULONG_MAX, 1,
> - &kernel_load_addr);
> + kbuf.buffer = kernel + kern16_size;
> + kbuf.bufsz = kernel_len - kern16_size;
> + kbuf.memsz = PAGE_ALIGN(header->init_size);
> + kbuf.buf_align = header->kernel_alignment;
> + kbuf.buf_min = MIN_KERNEL_LOAD_ADDR;
> + ret = kexec_add_buffer(&kbuf);
> if (ret)
> goto out_free_params;
> + kernel_load_addr = kbuf.mem;
>
> pr_debug("Loaded 64bit kernel at 0x%lx bufsz=0x%lx memsz=0x%lx\n",
> - kernel_load_addr, kernel_memsz, kernel_memsz);
> + kernel_load_addr, kbuf.bufsz, kbuf.memsz);
>
> /* Load initrd high */
> if (initrd) {
> - ret = kexec_add_buffer(image, initrd, initrd_len, initrd_len,
> - PAGE_SIZE, MIN_INITRD_LOAD_ADDR,
> - ULONG_MAX, 1, &initrd_load_addr);
> + kbuf.buffer = initrd;
> + kbuf.bufsz = kbuf.memsz = initrd_len;
> + kbuf.buf_align = PAGE_SIZE;
> + kbuf.buf_min = MIN_INITRD_LOAD_ADDR;
> + ret = kexec_add_buffer(&kbuf);
> if (ret)
> goto out_free_params;
> + initrd_load_addr = kbuf.mem;
>
> pr_debug("Loaded initrd at 0x%lx bufsz=0x%lx memsz=0x%lx\n",
> initrd_load_addr, initrd_len, initrd_len);
> diff --git a/include/linux/kexec.h b/include/linux/kexec.h
> index 2549a99a748c..ff5fa7707bd7 100644
> --- a/include/linux/kexec.h
> +++ b/include/linux/kexec.h
> @@ -161,7 +161,7 @@ struct kexec_file_ops {
> */
> struct kexec_buf {
> struct kimage *image;
> - char *buffer;
> + void *buffer;
> unsigned long bufsz;
> unsigned long mem;
> unsigned long memsz;
> @@ -173,6 +173,7 @@ struct kexec_buf {
>
> int __weak arch_kexec_walk_mem(struct kexec_buf *kbuf,
> int (*func)(u64, u64, void *));
> +extern int kexec_add_buffer(struct kexec_buf *kbuf);
> #endif /* CONFIG_KEXEC_FILE */
>
> struct kimage {
> @@ -237,11 +238,6 @@ extern asmlinkage long sys_kexec_load(unsigned long entry,
> struct kexec_segment __user *segments,
> unsigned long flags);
> extern int kernel_kexec(void);
> -extern int kexec_add_buffer(struct kimage *image, char *buffer,
> - unsigned long bufsz, unsigned long memsz,
> - unsigned long buf_align, unsigned long buf_min,
> - unsigned long buf_max, bool top_down,
> - unsigned long *load_addr);
> extern struct page *kimage_alloc_control_pages(struct kimage *image,
> unsigned int order);
> extern int kexec_load_purgatory(struct kimage *image, unsigned long min,
> diff --git a/kernel/kexec_file.c b/kernel/kexec_file.c
> index 9c0c565a08db..82ccfc4ee97e 100644
> --- a/kernel/kexec_file.c
> +++ b/kernel/kexec_file.c
> @@ -449,25 +449,27 @@ int __weak arch_kexec_walk_mem(struct kexec_buf *kbuf,
> return walk_system_ram_res(0, ULONG_MAX, kbuf, func);
> }
>
> -/*
> - * Helper function for placing a buffer in a kexec segment. This assumes
> - * that kexec_mutex is held.
> +/**
> + * kexec_add_buffer - place a buffer in a kexec segment
> + * @kbuf: Buffer contents and memory parameters.
> + *
> + * This function assumes that kexec_mutex is held.
> + * On successful return, @kbuf->mem will have the physical address of
> + * the buffer in memory.
> + *
> + * Return: 0 on success, negative errno on error.
> */
> -int kexec_add_buffer(struct kimage *image, char *buffer, unsigned long bufsz,
> - unsigned long memsz, unsigned long buf_align,
> - unsigned long buf_min, unsigned long buf_max,
> - bool top_down, unsigned long *load_addr)
> +int kexec_add_buffer(struct kexec_buf *kbuf)
> {
>
> struct kexec_segment *ksegment;
> - struct kexec_buf buf, *kbuf;
> int ret;
>
> /* Currently adding segment this way is allowed only in file mode */
> - if (!image->file_mode)
> + if (!kbuf->image->file_mode)
> return -EINVAL;
>
> - if (image->nr_segments >= KEXEC_SEGMENT_MAX)
> + if (kbuf->image->nr_segments >= KEXEC_SEGMENT_MAX)
> return -EINVAL;
>
> /*
> @@ -477,22 +479,14 @@ int kexec_add_buffer(struct kimage *image, char *buffer, unsigned long bufsz,
> * logic goes through list of segments to make sure there are
> * no destination overlaps.
> */
> - if (!list_empty(&image->control_pages)) {
> + if (!list_empty(&kbuf->image->control_pages)) {
> WARN_ON(1);
> return -EINVAL;
> }
>
> - memset(&buf, 0, sizeof(struct kexec_buf));
> - kbuf = &buf;
> - kbuf->image = image;
> - kbuf->buffer = buffer;
> - kbuf->bufsz = bufsz;
> -
> - kbuf->memsz = ALIGN(memsz, PAGE_SIZE);
> - kbuf->buf_align = max(buf_align, PAGE_SIZE);
> - kbuf->buf_min = buf_min;
> - kbuf->buf_max = buf_max;
> - kbuf->top_down = top_down;
> + /* Ensure minimum alignment needed for segments. */
> + kbuf->memsz = ALIGN(kbuf->memsz, PAGE_SIZE);
> + kbuf->buf_align = max(kbuf->buf_align, PAGE_SIZE);
>
> /* Walk the RAM ranges and allocate a suitable range for the buffer */
> ret = arch_kexec_walk_mem(kbuf, locate_mem_hole_callback);
> @@ -502,13 +496,12 @@ int kexec_add_buffer(struct kimage *image, char *buffer, unsigned long bufsz,
> }
>
> /* Found a suitable memory range */
> - ksegment = &image->segment[image->nr_segments];
> + ksegment = &kbuf->image->segment[kbuf->image->nr_segments];
> ksegment->kbuf = kbuf->buffer;
> ksegment->bufsz = kbuf->bufsz;
> ksegment->mem = kbuf->mem;
> ksegment->memsz = kbuf->memsz;
> - image->nr_segments++;
> - *load_addr = ksegment->mem;
> + kbuf->image->nr_segments++;
> return 0;
> }
>
> @@ -630,13 +623,15 @@ 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, buf_align, bss_align, buf_sz, bss_sz, bss_pad;
> - unsigned long memsz, entry, load_addr, curr_load_addr, bss_addr, offset;
> + 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;
> - void *purgatory_buf = 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
> @@ -702,9 +697,7 @@ static int __kexec_load_purgatory(struct kimage *image, unsigned long min,
> }
>
> /* Determine how much memory is needed to load relocatable object. */
> - buf_align = 1;
> bss_align = 1;
> - buf_sz = 0;
> bss_sz = 0;
>
> for (i = 0; i < pi->ehdr->e_shnum; i++) {
> @@ -713,10 +706,10 @@ static int __kexec_load_purgatory(struct kimage *image, unsigned long min,
>
> align = sechdrs[i].sh_addralign;
> if (sechdrs[i].sh_type != SHT_NOBITS) {
> - if (buf_align < align)
> - buf_align = align;
> - buf_sz = ALIGN(buf_sz, align);
> - buf_sz += sechdrs[i].sh_size;
> + 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)
> @@ -728,32 +721,31 @@ static int __kexec_load_purgatory(struct kimage *image, unsigned long min,
>
> /* Determine the bss padding required to align bss properly */
> bss_pad = 0;
> - if (buf_sz & (bss_align - 1))
> - bss_pad = bss_align - (buf_sz & (bss_align - 1));
> + if (kbuf.bufsz & (bss_align - 1))
> + bss_pad = bss_align - (kbuf.bufsz & (bss_align - 1));
>
> - memsz = buf_sz + bss_pad + bss_sz;
> + kbuf.memsz = kbuf.bufsz + bss_pad + bss_sz;
>
> /* Allocate buffer for purgatory */
> - purgatory_buf = vzalloc(buf_sz);
> - if (!purgatory_buf) {
> + kbuf.buffer = vzalloc(kbuf.bufsz);
> + if (!kbuf.buffer) {
> ret = -ENOMEM;
> goto out;
> }
>
> - if (buf_align < bss_align)
> - buf_align = bss_align;
> + if (kbuf.buf_align < bss_align)
> + kbuf.buf_align = bss_align;
>
> /* Add buffer to segment list */
> - ret = kexec_add_buffer(image, purgatory_buf, buf_sz, memsz,
> - buf_align, min, max, top_down,
> - &pi->purgatory_load_addr);
> + ret = kexec_add_buffer(&kbuf);
> if (ret)
> goto out;
> + pi->purgatory_load_addr = kbuf.mem;
>
> /* Load SHF_ALLOC sections */
> - buf_addr = purgatory_buf;
> + buf_addr = kbuf.buffer;
> load_addr = curr_load_addr = pi->purgatory_load_addr;
> - bss_addr = load_addr + buf_sz + bss_pad;
> + bss_addr = load_addr + kbuf.bufsz + bss_pad;
>
> for (i = 0; i < pi->ehdr->e_shnum; i++) {
> if (!(sechdrs[i].sh_flags & SHF_ALLOC))
> @@ -799,11 +791,11 @@ static int __kexec_load_purgatory(struct kimage *image, unsigned long min,
> * Used later to identify which section is purgatory and skip it
> * from checksumming.
> */
> - pi->purgatory_buf = purgatory_buf;
> + pi->purgatory_buf = kbuf.buffer;
> return ret;
> out:
> vfree(sechdrs);
> - vfree(purgatory_buf);
> + vfree(kbuf.buffer);
> return ret;
> }
>
> --
> 1.9.1
>

Acked-by: Dave Young <dyoung@redhat.com>

Thanks
Dave

\
 
 \ /
  Last update: 2016-07-11 06:01    [W:0.156 / U:0.600 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site