/* $NetBSD: loadfile.c,v 1.10 2000/12/03 02:53:04 tsutsui Exp $ */

/* $OpenBSD: loadfile_elf.c,v 1.26 2017/03/27 00:28:04 deraadt Exp $ */

/*-

 * Copyright (c) 1997 The NetBSD Foundation, Inc.

 * All rights reserved.

 *

 * This code is derived from software contributed to The NetBSD Foundation

 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,

 * NASA Ames Research Center and by Christos Zoulas.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS

 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED

 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS

 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 */

/*

 * Copyright (c) 1992, 1993

 *	The Regents of the University of California.  All rights reserved.

 *

 * This code is derived from software contributed to Berkeley by

 * Ralph Campbell.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 *

 *	@(#)boot.c	8.1 (Berkeley) 6/10/93

 */

/*

 * Copyright (c) 2015 Mike Larkin <mlarkin@openbsd.org>

 *

 * Permission to use, copy, modify, and distribute this software for any

 * purpose with or without fee is hereby granted, provided that the above

 * copyright notice and this permission notice appear in all copies.

 *

 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

 */

#include <sys/param.h>	/* PAGE_SIZE PAGE_MASK roundup */

#include <sys/ioctl.h>

#include <sys/reboot.h>

#include <sys/exec.h>

#include <sys/exec_elf.h>

#include <stdio.h>

#include <string.h>

#include <errno.h>

#include <stdlib.h>

#include <unistd.h>

#include <fcntl.h>

#include <err.h>

#include <errno.h>

#include <stddef.h>

#include <machine/vmmvar.h>

#include <machine/biosvar.h>

#include <machine/segments.h>

#include <machine/pte.h>

#include "loadfile.h"

#include "vmd.h"

union {

	Elf32_Ehdr elf32;

	Elf64_Ehdr elf64;

} hdr;

#ifdef __i386__

typedef uint32_t pt_entry_t;

static void setsegment(struct segment_descriptor *, uint32_t,

    size_t, int, int, int, int);

#else

static void setsegment(struct mem_segment_descriptor *, uint32_t,

    size_t, int, int, int, int);

#endif

static int elf32_exec(FILE *, Elf32_Ehdr *, u_long *, int);

static int elf64_exec(FILE *, Elf64_Ehdr *, u_long *, int);

static size_t create_bios_memmap(struct vm_create_params *, bios_memmap_t *);

static uint32_t push_bootargs(bios_memmap_t *, size_t);

static size_t push_stack(uint32_t, uint32_t, uint32_t, uint32_t);

static void push_gdt(void);

static void push_pt(void);

static void marc4random_buf(paddr_t, int);

static void mbzero(paddr_t, int);

static void mbcopy(void *, paddr_t, int);

extern char *__progname;

extern int vm_id;

/*

 * setsegment

 *

 * Initializes a segment selector entry with the provided descriptor.

 * For the purposes of the bootloader mimiced by vmd(8), we only need

 * memory-type segment descriptor support.

 *

 * This function was copied from machdep.c

 *

 * Parameters:

 *  sd: Address of the entry to initialize

 *  base: base of the segment

 *  limit: limit of the segment

 *  type: type of the segment

 *  dpl: privilege level of the egment

 *  def32: default 16/32 bit size of the segment

 *  gran: granularity of the segment (byte/page)

 */

#ifdef __i386__

static void

setsegment(struct segment_descriptor *sd, uint32_t base, size_t limit,

    int type, int dpl, int def32, int gran)

#else

static void

setsegment(struct mem_segment_descriptor *sd, uint32_t base, size_t limit,

    int type, int dpl, int def32, int gran)

#endif

{

#ifdef __i386__

	sd->sd_xx = 0;

#else

#endif

}

/*

 * push_gdt

 *

 * Allocates and populates a page in the guest phys memory space to hold

 * the boot-time GDT. Since vmd(8) is acting as the bootloader, we need to

 * create the same GDT that a real bootloader would have created.

 * This is loaded into the guest phys RAM space at address GDT_PAGE.

 */

static void

push_gdt(void)

{

#ifdef __i386__

	struct segment_descriptor *sd;

#else

	struct mem_segment_descriptor *sd;

#endif

#ifdef __i386__

	sd = (struct segment_descriptor *)&gdtpage;

#else

#endif

	/*

	 * Create three segment descriptors:

	 *

	 * GDT[0] : null desriptor. "Created" via memset above.

	 * GDT[1] (selector @ 0x8): Executable segment, for CS

	 * GDT[2] (selector @ 0x10): RW Data segment, for DS/ES/SS

	 */

}

/*

 * push_pt

 *

 * Create an identity-mapped page directory hierarchy mapping the first

 * 1GB of physical memory. This is used during bootstrapping VMs on

 * CPUs without unrestricted guest capability.

 */

static void

push_pt(void)

{

	uint64_t i;

#ifdef __i386__

	memset(ptes, 0, sizeof(ptes));

	for (i = 0 ; i < NPTE_PG; i++) {

		ptes[i] = PG_V | PG_PS | (NBPD * i);

	}

	write_mem(PML4_PAGE, ptes, PAGE_SIZE);

#else

	/* PML3 [0] - first 1GB */

	/* PML3 [0] - first 1GB */

	/* PML2 [0..511] - first 1GB (in 2MB pages) */

	}

#endif

}

/*

 * loadfile_elf

 *

 * Loads an ELF kernel to it's defined load address in the guest VM.

 * The kernel is loaded to its defined start point as set in the ELF header.

 *

 * Parameters:

 *  fp: file of a kernel file to load

 *  vcp: the VM create parameters, holding the exact memory map

 *  (out) vrs: register state to set on init for this kernel

 *  bootdev: the optional non-default boot device

 *  howto: optionel boot flags for the kernel

 *

 * Return values:

 *  0 if successful

 *  various error codes returned from read(2) or loadelf functions

 */

int

loadfile_elf(FILE *fp, struct vm_create_params *vcp,

    struct vcpu_reg_state *vrs, uint32_t bootdev, uint32_t howto)

{

	int r;

	uint32_t bootargsz;

	size_t n, stacksize;

#ifdef __i386__

	vrs->vrs_gprs[VCPU_REGS_EIP] = (uint32_t)marks[MARK_ENTRY];

	vrs->vrs_gprs[VCPU_REGS_ESP] = (uint32_t)(STACK_PAGE + PAGE_SIZE) - stacksize;

#else

#endif

}

/*

 * create_bios_memmap

 *

 * Construct a memory map as returned by the BIOS INT 0x15, e820 routine.

 *

 * Parameters:

 *  vcp: the VM create parameters, containing the memory map passed to vmm(4)

 *   memmap (out): the BIOS memory map

 *

 * Return values:

 * Number of bios_memmap_t entries, including the terminating nul-entry.

 */

static size_t

create_bios_memmap(struct vm_create_params *vcp, bios_memmap_t *memmap)

{

	size_t i, n = 0, sz;

	paddr_t gpa;

	struct vm_mem_range *vmr;

		/*

		 * Make sure that we do not mark the ROM/video RAM area in the

		 * low memory as physcal memory available to the kernel.

		 */

			else

		}

		}

	}

	/* Null mem map entry to denote the end of the ranges */

}

/*

 * push_bootargs

 *

 * Creates the boot arguments page in the guest address space.

 * Since vmd(8) is acting as the bootloader, we need to create the same boot

 * arguments page that a real bootloader would have created. This is loaded

 * into the guest phys RAM space at address BOOTARGS_PAGE.

 *

 * Parameters:

 *  memmap: the BIOS memory map

 *  n: number of entries in memmap

 *

 * Return values:

 *  The size of the bootargs

 */

static uint32_t

push_bootargs(bios_memmap_t *memmap, size_t n)

{

	uint32_t memmap_sz, consdev_sz, i;

	bios_consdev_t consdev;

	/* Serial console device, COM1 @ 0x3f8 */

	consdev.consdev = makedev(8, 0);	/* com1 @ 0x3f8 */

	consdev.conspeed = 9600;

	consdev.consaddr = 0x3f8;

	consdev.consfreq = 0;

	consdev_sz = 3 * sizeof(int) + sizeof(bios_consdev_t);

}

/*

 * push_stack

 *

 * Creates the boot stack page in the guest address space. When using a real

 * bootloader, the stack will be prepared using the following format before

 * transitioning to kernel start, so vmd(8) needs to mimic the same stack

 * layout. The stack content is pushed to the guest phys RAM at address

 * STACK_PAGE. The bootloader operates in 32 bit mode; each stack entry is

 * 4 bytes.

 *

 * Stack Layout: (TOS == Top Of Stack)

 *  TOS		location of boot arguments page

 *  TOS - 0x4	size of the content in the boot arguments page

 *  TOS - 0x8	size of low memory (biosbasemem: kernel uses BIOS map only if 0)

 *  TOS - 0xc	size of high memory (biosextmem, not used by kernel at all)

 *  TOS - 0x10	kernel 'end' symbol value

 *  TOS - 0x14	version of bootarg API

 *

 * Parameters:

 *  bootargsz: size of boot arguments

 *  end: kernel 'end' symbol value

 *  bootdev: the optional non-default boot device

 *  howto: optionel boot flags for the kernel

 *

 * Return values:

 *  size of the stack

 */

static size_t

push_stack(uint32_t bootargsz, uint32_t end, uint32_t bootdev, uint32_t howto)

{

	uint16_t loc;

	loc = 1024;

}

/*

 * mread

 *

 * Reads 'sz' bytes from the file whose descriptor is provided in 'fd'

 * into the guest address space at paddr 'addr'.

 *

 * Parameters:

 *  fd: file descriptor of the kernel image file to read from.

 *  addr: guest paddr_t to load to

 *  sz: number of bytes to load

 *

 * Return values:

 *  returns 'sz' if successful, or 0 otherwise.

 */

size_t

mread(FILE *fp, paddr_t addr, size_t sz)

{

	size_t ct;

	size_t i, rd, osz;

	/*

	 * break up the 'sz' bytes into PAGE_SIZE chunks for use with

	 * write_mem

	 */

	ct = 0;

	rd = 0;

	osz = sz;

		else

			ct = sz;

		}

		rd += ct;

	}

		else

			ct = PAGE_SIZE;

		}

	}

}

/*

 * marc4random_buf

 *

 * load 'sz' bytes of random data into the guest address space at paddr

 * 'addr'.

 *

 * Parameters:

 *  addr: guest paddr_t to load random bytes into

 *  sz: number of random bytes to load

 *

 * Return values:

 *  nothing

 */

static void

marc4random_buf(paddr_t addr, int sz)

{

	int i, ct;

	/*

	 * break up the 'sz' bytes into PAGE_SIZE chunks for use with

	 * write_mem

	 */

	ct = 0;

	}

		else

			ct = PAGE_SIZE;

	}

}

/*

 * mbzero

 *

 * load 'sz' bytes of zeros into the guest address space at paddr

 * 'addr'.

 *

 * Parameters:

 *  addr: guest paddr_t to zero

 *  sz: number of zero bytes to store

 *

 * Return values:

 *  nothing

 */

static void

mbzero(paddr_t addr, int sz)

{

	int i, ct;

	/*

	 * break up the 'sz' bytes into PAGE_SIZE chunks for use with

	 * write_mem

	 */

	ct = 0;

	}

		else

			ct = PAGE_SIZE;

	}

}

/*

 * mbcopy

 *

 * copies 'sz' bytes from buffer 'src' to guest paddr 'dst'.

 *

 * Parameters:

 *  src: source buffer to copy from

 *  dst: destination guest paddr_t to copy to

 *  sz: number of bytes to copy

 *

 * Return values:

 *  nothing

 */

static void

mbcopy(void *src, paddr_t dst, int sz)

{

}

/*

 * elf64_exec

 *

 * Load the kernel indicated by 'fd' into the guest physical memory

 * space, at the addresses defined in the ELF header.

 *

 * This function is used for 64 bit kernels.

 *

 * Parameters:

 *  fd: file descriptor of the kernel to load

 *  elf: ELF header of the kernel

 *  marks: array to store the offsets of various kernel structures

 *      (start, bss, etc)

 *  flags: flag value to indicate which section(s) to load (usually

 *      LOAD_ALL)

 *

 * Return values:

 *  0 if successful

 *  1 if unsuccessful

 */

static int

elf64_exec(FILE *fp, Elf64_Ehdr *elf, u_long *marks, int flags)

{

	Elf64_Shdr *shp;

	Elf64_Phdr *phdr;

	Elf64_Off off;

	int i;

	size_t sz;

	int first;

	int havesyms, havelines;

	paddr_t minp = ~0, maxp = 0, pos = 0;

	}

	}

			int m;

			/* Fill segment if asked for. */

					    m);

				}

			}

			}

			continue;

		}

			continue;

#define IS_TEXT(p)	(p.p_flags & PF_X)

#define IS_DATA(p)	((p.p_flags & PF_X) == 0)

#define IS_BSS(p)	(p.p_filesz < p.p_memsz)

		/*

		 * XXX: Assume first address is lowest

		 */

			/* Read in segment. */

			}

			}

			first = 0;

		}

		}

		/* Zero out BSS. */

		}

		}

	}

	/*

	 * Copy the ELF and section headers.

	 */

		}

		}

		shpp = maxp;

		}

		}

		/*

		 * Now load the symbol sections themselves. Make sure the

		 * sections are aligned. Don't bother with string tables if

		 * there are no symbol sections.

		 */

					}

					}

				}

				    sizeof(Elf64_Addr));

				    sizeof(Elf64_Addr));

				first = 0;

			}

		}

		}

	}

	/*

	 * Frob the copied ELF header to give information relative

	 * to elfp.

	 */

	}

}

/*

 * elf32_exec

 *

 * Load the kernel indicated by 'fd' into the guest physical memory

 * space, at the addresses defined in the ELF header.

 *

 * This function is used for 32 bit kernels.

 *

 * Parameters:

 *  fd: file descriptor of the kernel to load

 *  elf: ELF header of the kernel

 *  marks: array to store the offsets of various kernel structures

 *      (start, bss, etc)

 *  flags: flag value to indicate which section(s) to load (usually

 *      LOAD_ALL)

 *

 * Return values:

 *  0 if successful

 *  1 if unsuccessful

 */

static int

elf32_exec(FILE *fp, Elf32_Ehdr *elf, u_long *marks, int flags)

{

	Elf32_Shdr *shp;

	Elf32_Phdr *phdr;

	Elf32_Off off;

	int i;

	size_t sz;

	int first;

	int havesyms, havelines;

	paddr_t minp = ~0, maxp = 0, pos = 0;

	}

	}

			int m;

			/* Fill segment if asked for. */

					    m);

				}

			}

			}

			continue;

		}

			continue;

#define IS_TEXT(p)	(p.p_flags & PF_X)

#define IS_DATA(p)	((p.p_flags & PF_X) == 0)

#define IS_BSS(p)	(p.p_filesz < p.p_memsz)

		/*

		 * XXX: Assume first address is lowest

		 */

			/* Read in segment. */

			}

			}

			first = 0;

		}

		}

		/* Zero out BSS. */

		}