boot-hosted.cc

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * 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 <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <memory.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
 
#include <sys/mman.h>
#include <sys/stat.h>
 
#ifndef PEDIGREE_HOSTED_DARWIN
#include <elf.h>
#endif
 
#include "pedigree/kernel/BootstrapInfo.h"
#include "pedigree/kernel/TargetInfo.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/processor/hosted/FunctionProfile.h"
#include "pedigree/kernel/processor/hosted/smoke.h"
 
extern "C" void _main(BootstrapStruct_t& bs);
extern "C" {
HostedSmokeStage g_HostedSmokeStage = HostedSmokeNone;
}
static size_t profileDivisor = 1;
 
size_t hostedSyscallProfileDivisor() {
  return profileDivisor;
}
 
bool hostedSyscallProfileRequested() {
#if HOSTED_SMOKE_TESTS
  const char* value = getenv("PEDIGREE_HOSTED_SYSCALL_PROFILE");
  return value && !strcmp(value, "1");
#else
  return false;
#endif
}
 
static void* add_ptr(void* ptr, size_t addend) {
  uintptr_t ptr_u = (uintptr_t)ptr;
  ptr_u += addend;
  return (void*)ptr_u;
}
 
extern "C" int main(int argc, char* argv[]) {
  struct stat st;
  int r = 0;
  int s = 0;
  int initrd = -1;
  int kernel = -1;
  int diskimage = -1;
  void* initrd_mapping = MAP_FAILED;
#ifndef PEDIGREE_HOSTED_DARWIN
  void* kernel_mapping = MAP_FAILED;
#endif
  void* diskimage_mapping = MAP_FAILED;
  uintptr_t* module_region = (uintptr_t*)MAP_FAILED;
  size_t initrd_length = 0;
#ifndef PEDIGREE_HOSTED_DARWIN
  size_t kernel_length = 0;
#endif
  size_t diskimage_length = 0;
#ifndef PEDIGREE_HOSTED_DARWIN
  Elf64_Ehdr* ehdr = 0;
  Elf64_Shdr* shdrs = 0;
#endif
  BootstrapStruct_t bs = {};
 
  if (hostedSyscallProfileRequested()) {
    const char* value = getenv("PEDIGREE_HOSTED_PROFILE_DIVISOR");
    if (value) {
      char* end = nullptr;
      const unsigned long divisor = strtoul(value, &end, 10);
      if (!*value || *end || divisor < 1 || divisor > 100000) {
        fprintf(stderr, "PEDIGREE_HOSTED_PROFILE_DIVISOR must be between 1 and 100000.\n");
        goto fail;
      }
      profileDivisor = divisor;
    }
  }
 
  if (argc < 2 || argc > 4) {
    fprintf(stderr,
            "Usage: kernel initrd "
            "[diskimage [root|init|command|shutdown]]\n");
    goto fail;
  }
 
#if PEDIGREE_HOSTED_FUNCTION_PROFILE
  if (!hostedFunctionProfileInitialise()) {
    goto fail;
  }
#endif
 
  if (argc == 4) {
    if (!strcmp(argv[3], "root")) {
      g_HostedSmokeStage = HostedSmokeRoot;
    } else if (!strcmp(argv[3], "init")) {
      g_HostedSmokeStage = HostedSmokeInit;
    } else if (!strcmp(argv[3], "command")) {
      g_HostedSmokeStage = HostedSmokeCommand;
    } else if (!strcmp(argv[3], "shutdown")) {
      g_HostedSmokeStage = HostedSmokeShutdown;
    } else {
      fprintf(stderr, "Unknown hosted smoke stage: %s\n", argv[3]);
      goto fail;
    }
  }
 
  fprintf(stderr, "Hosted runtime: %s; heap: %s\n",
          HAS_ADDRESS_SANITIZER ? "AddressSanitizer" : "unsanitized",
          HOSTED_SYSTEM_MALLOC ? "system malloc" : "Pedigree SlamAllocator");
  fprintf(stderr, "Pedigree is starting...\n");
 
  // Load initrd into RAM.
  initrd = open(argv[1], O_RDONLY);
  if (initrd < 0) {
    fprintf(stderr, "Can't open initrd: %s\n", strerror(errno));
    goto fail;
  }
 
#ifndef PEDIGREE_HOSTED_DARWIN
  // ELF hosts expose the kernel's section table through Multiboot metadata.
  kernel = open(argv[0], O_RDONLY);
  if (kernel < 0) {
    fprintf(stderr, "Can't open kernel: %s\n", strerror(errno));
    goto fail;
  }
#endif
 
  // Map the initrd.
  r = fstat(initrd, &st);
  if (r != 0) {
    fprintf(stderr, "Can't stat initrd: %s\n", strerror(errno));
    goto fail;
  }
  initrd_length = st.st_size;
  initrd_mapping = mmap(0, initrd_length, PROT_READ, MAP_PRIVATE, initrd, 0);
  if (initrd_mapping == MAP_FAILED) {
    fprintf(stderr, "Can't map initrd: %s\n", strerror(errno));
    goto fail;
  }
  fprintf(stderr, "initrd is at %p\n", initrd_mapping);
 
#ifndef PEDIGREE_HOSTED_DARWIN
  r = fstat(kernel, &st);
  if (r != 0) {
    fprintf(stderr, "Can't stat kernel: %s\n", strerror(errno));
    goto fail;
  }
  kernel_length = st.st_size;
  kernel_mapping = mmap(0, kernel_length, PROT_READ | PROT_WRITE, MAP_PRIVATE, kernel, 0);
  if (kernel_mapping == MAP_FAILED) {
    fprintf(stderr, "Can't map kernel: %s\n", strerror(errno));
    goto fail;
  }
  fprintf(stderr, "kernel is at %p\n", kernel_mapping);
#endif
 
  // Make the module locations available to the kernel.
  module_region = (uintptr_t*)mmap(0, TargetInfo::getPageSize(), PROT_READ | PROT_WRITE,
                                   MAP_PRIVATE | MAP_ANON, -1, 0);
  if (module_region == MAP_FAILED) {
    fprintf(stderr, "Can't map module information region: %s\n", strerror(errno));
    goto fail;
  }
  fprintf(stderr, "module region is at %p\n", module_region);
  memset(module_region, 0, TargetInfo::getPageSize());
 
  // initrd
  module_region[0] = reinterpret_cast<uintptr_t>(initrd_mapping);
  module_region[1] = reinterpret_cast<uintptr_t>(initrd_mapping) + initrd_length;
 
  bs.mods_addr = reinterpret_cast<uintptr_t>(module_region);
  bs.mods_count = 1;
 
  if (argc > 2) {
    diskimage = open(argv[2], O_RDWR);
    if (diskimage < 0) {
      fprintf(stderr, "Can't open disk image: %s\n", strerror(errno));
      goto fail;
    }
 
    r = fstat(diskimage, &st);
    if (r != 0) {
      fprintf(stderr, "Can't stat disk image: %s\n", strerror(errno));
      goto fail;
    }
 
    diskimage_length = st.st_size;
    diskimage_mapping = mmap(0, diskimage_length, PROT_READ | PROT_WRITE,
                             MAP_PRIVATE | MAP_NORESERVE, diskimage, 0);
    if (diskimage_mapping == MAP_FAILED) {
      fprintf(stderr, "Can't map disk image: %s\n", strerror(errno));
      goto fail;
    }
    fprintf(stderr, "disk image is at %p\n", diskimage_mapping);
 
    // Add to the multiboot info.
    bs.mods_count++;
    module_region[4] = reinterpret_cast<uintptr_t>(diskimage_mapping);
    module_region[5] = reinterpret_cast<uintptr_t>(diskimage_mapping) + diskimage_length;
  }
 
#ifndef PEDIGREE_HOSTED_DARWIN
  // Load ELF header to add ELF information.
  ehdr = reinterpret_cast<Elf64_Ehdr*>(kernel_mapping);
  bs.shndx = ehdr->e_shstrndx;
  bs.num = ehdr->e_shnum;
  bs.size = ehdr->e_shentsize;
  bs.addr = reinterpret_cast<uintptr_t>(kernel_mapping) + ehdr->e_shoff;
 
  // Fix up section headers with no addresses.
  shdrs = reinterpret_cast<Elf64_Shdr*>(bs.addr);
  for (uint32_t i = 1; i < bs.num; ++i) {
    if (shdrs[i].sh_addr)
      continue;
 
    shdrs[i].sh_addr = shdrs[i].sh_offset + reinterpret_cast<uintptr_t>(kernel_mapping);
  }
#endif
 
  fprintf(stderr, "Running main(), with mappings:\n");
#ifndef PEDIGREE_HOSTED_DARWIN
  fprintf(stderr, " kernel: %p -> %p\n", kernel_mapping, add_ptr(kernel_mapping, kernel_length));
#else
  fprintf(stderr, " kernel: Mach-O process symbols\n");
#endif
  fprintf(stderr, " diskimage: %p -> %p\n", diskimage_mapping,
          add_ptr(diskimage_mapping, diskimage_length));
  fprintf(stderr, " modules: %p -> %p\n", module_region,
          add_ptr(module_region, TargetInfo::getPageSize()));
  fprintf(stderr, " initrd: %p -> %p\n", initrd_mapping, add_ptr(initrd_mapping, initrd_length));
 
  // Kernel uses flags to know what it can and can't use.
  bs.flags |= BOOTSTRAP_FLAG_MODULES;
#ifndef PEDIGREE_HOSTED_DARWIN
  bs.flags |= BOOTSTRAP_FLAG_ELF;
#endif
  _main(bs);
 
  fprintf(stderr, "main() returned, cleaning up...\n");
 
  goto cleanup;
fail:
  s = 1;
cleanup:
  if (module_region != MAP_FAILED)
    munmap(module_region, TargetInfo::getPageSize());
  if (diskimage_mapping != MAP_FAILED)
    munmap(diskimage_mapping, diskimage_length);
#ifndef PEDIGREE_HOSTED_DARWIN
  if (kernel_mapping != MAP_FAILED)
    munmap(kernel_mapping, kernel_length);
#endif
  if (initrd_mapping != MAP_FAILED)
    munmap(initrd_mapping, initrd_length);
  close(diskimage);
  if (kernel >= 0)
    close(kernel);
  close(initrd);
  return s;
}