/*      $NetBSD: prekern.c,v 1.14 2021/05/04 21:09:16 khorben Exp $     */

/*
* Copyright (c) 2017-2020 The NetBSD Foundation, Inc. All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Maxime Villard.
*
* 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.
*/

#include "prekern.h"

#include <machine/reg.h>
#include <machine/specialreg.h>
#include <machine/frame.h>

#define _KERNEL
#include <machine/bootinfo.h>
#undef _KERNEL

#include <machine/tss.h>
#include <machine/segments.h>

int boothowto;
struct bootinfo bootinfo;

extern paddr_t kernpa_start, kernpa_end;

static uint8_t idtstore[PAGE_SIZE] __aligned(PAGE_SIZE);

#define IDTVEC(name) __CONCAT(X, name)
typedef void (vector)(void);
extern vector *x86_exceptions[];

void fatal(char *msg)
{
       print("\n");
       print_ext(RED_ON_BLACK, "********** FATAL ***********\n");
       print_ext(RED_ON_BLACK, msg);
       print("\n");
       print_ext(RED_ON_BLACK, "****************************\n");

       while (1);
}

/* -------------------------------------------------------------------------- */

struct smallframe {
       uint64_t sf_trapno;
       uint64_t sf_err;
       uint64_t sf_rip;
       uint64_t sf_cs;
       uint64_t sf_rflags;
       uint64_t sf_rsp;
       uint64_t sf_ss;
};

void trap(struct smallframe *);

static char *trap_type[] = {
       "privileged instruction fault",         /*  0 T_PRIVINFLT */
       "breakpoint trap",                      /*  1 T_BPTFLT */
       "arithmetic trap",                      /*  2 T_ARITHTRAP */
       "asynchronous system trap",             /*  3 T_ASTFLT */
       "protection fault",                     /*  4 T_PROTFLT */
       "trace trap",                           /*  5 T_TRCTRAP */
       "page fault",                           /*  6 T_PAGEFLT */
       "alignment fault",                      /*  7 T_ALIGNFLT */
       "integer divide fault",                 /*  8 T_DIVIDE */
       "non-maskable interrupt",               /*  9 T_NMI */
       "overflow trap",                        /* 10 T_OFLOW */
       "bounds check fault",                   /* 11 T_BOUND */
       "FPU not available fault",              /* 12 T_DNA */
       "double fault",                         /* 13 T_DOUBLEFLT */
       "FPU operand fetch fault",              /* 14 T_FPOPFLT */
       "invalid TSS fault",                    /* 15 T_TSSFLT */
       "segment not present fault",            /* 16 T_SEGNPFLT */
       "stack fault",                          /* 17 T_STKFLT */
       "machine check fault",                  /* 18 T_MCA */
       "SSE FP exception",                     /* 19 T_XMM */
       "reserved trap",                        /* 20 T_RESERVED */
};
static int trap_types = __arraycount(trap_type);

/*
* Trap handler.
*/
void
trap(struct smallframe *sf)
{
       uint64_t trapno = sf->sf_trapno;
       char *buf;

       if (trapno < trap_types) {
               buf = trap_type[trapno];
       } else {
               buf = "unknown trap";
       }

       print("\n");
       print_ext(RED_ON_BLACK, "****** FAULT OCCURRED ******\n");
       print_ext(RED_ON_BLACK, buf);
       print("\n");
       print_ext(RED_ON_BLACK, "****************************\n");

       while (1);
}

/* -------------------------------------------------------------------------- */

static void
setregion(struct region_descriptor *rd, void *base, uint16_t limit)
{
       rd->rd_limit = limit;
       rd->rd_base = (uint64_t)base;
}

static void
setgate(struct gate_descriptor *gd, void *func, int ist, int type, int dpl,
   int sel)
{
       gd->gd_looffset = (uint64_t)func & 0xffff;
       gd->gd_selector = sel;
       gd->gd_ist = ist;
       gd->gd_type = type;
       gd->gd_dpl = dpl;
       gd->gd_p = 1;
       gd->gd_hioffset = (uint64_t)func >> 16;
       gd->gd_zero = 0;
       gd->gd_xx1 = 0;
       gd->gd_xx2 = 0;
       gd->gd_xx3 = 0;
}

static void
init_idt(void)
{
       struct region_descriptor region;
       struct gate_descriptor *idt;
       size_t i;

       idt = (struct gate_descriptor *)&idtstore;
       for (i = 0; i < NCPUIDT; i++) {
               setgate(&idt[i], x86_exceptions[i], 0, SDT_SYS386IGT,
                   SEL_KPL, GSEL(GCODE_SEL, SEL_KPL));
       }

       setregion(&region, &idtstore, PAGE_SIZE - 1);
       lidt(&region);
}

/* -------------------------------------------------------------------------- */

#define PREKERN_API_VERSION     2

struct prekern_args {
       int version;
       int boothowto;
       void *bootinfo;
       void *bootspace;
       int esym;
       int biosextmem;
       int biosbasemem;
       int cpuid_level;
       uint32_t nox_flag;
       uint64_t PDPpaddr;
       vaddr_t atdevbase;
       vaddr_t lwp0uarea;
       paddr_t first_avail;
};

struct prekern_args pkargs;

static void
init_prekern_args(void)
{
       extern struct bootspace bootspace;
       extern int esym;
       extern int biosextmem;
       extern int biosbasemem;
       extern int cpuid_level;
       extern uint32_t nox_flag;
       extern uint64_t PDPpaddr;
       extern vaddr_t iom_base;
       extern paddr_t stkpa;
       extern paddr_t pa_avail;

       memset(&pkargs, 0, sizeof(pkargs));
       pkargs.version = PREKERN_API_VERSION;
       pkargs.boothowto = boothowto;
       pkargs.bootinfo = (void *)&bootinfo;
       pkargs.bootspace = &bootspace;
       pkargs.esym = esym;
       pkargs.biosextmem = biosextmem;
       pkargs.biosbasemem = biosbasemem;
       pkargs.cpuid_level = cpuid_level;
       pkargs.nox_flag = nox_flag;
       pkargs.PDPpaddr = PDPpaddr;
       pkargs.atdevbase = iom_base;
       pkargs.lwp0uarea = bootspace.boot.va + (stkpa - bootspace.boot.pa);
       pkargs.first_avail = pa_avail;

       extern vaddr_t stkva;
       stkva = pkargs.lwp0uarea + (USPACE - FRAMESIZE);
}

void
exec_kernel(vaddr_t ent)
{
       int (*jumpfunc)(struct prekern_args *);
       int ret;

       /*
        * Normally, the function does not return. If it does, it means the
        * kernel had trouble processing the arguments, and we panic here. The
        * return value is here for debug.
        */
       jumpfunc = (void *)ent;
       ret = (*jumpfunc)(&pkargs);

       if (ret == -1) {
               fatal("kernel returned: wrong API version");
       } else {
               fatal("kernel returned: unknown value");
       }
}

/*
* Main entry point of the Prekern.
*/
void
init_prekern(paddr_t pa_start)
{
       vaddr_t ent;

       init_cons();
       print_banner();

       if (kernpa_start == 0 || kernpa_end == 0) {
               fatal("init_prekern: unable to locate the kernel");
       }
       if (kernpa_start != (1UL << 21)) {
               fatal("init_prekern: invalid kernpa_start");
       }
       if (kernpa_start % PAGE_SIZE != 0) {
               fatal("init_prekern: kernpa_start not aligned");
       }
       if (kernpa_end % PAGE_SIZE != 0) {
               fatal("init_prekern: kernpa_end not aligned");
       }
       if (kernpa_end <= kernpa_start) {
               fatal("init_prekern: kernpa_end >= kernpa_start");
       }

       /*
        * Our physical space starts after the end of the kernel.
        */
       if (pa_start < kernpa_end) {
               fatal("init_prekern: physical space inside kernel");
       }
       mm_init(pa_start);

       /*
        * Init the IDT. We mostly don't care about this, it's just here
        * to properly handle traps.
        */
       init_idt();

       print_state(STATE_NORMAL, "Prekern loaded");

       /*
        * Init the PRNG.
        */
       prng_init();

       /*
        * Relocate the kernel.
        */
       mm_map_kernel();
       elf_build_info();
       ent = elf_kernel_reloc();
       mm_bootspace_mprotect();

       /*
        * Build the arguments.
        */
       init_prekern_args();

       /*
        * Finally, jump into the kernel.
        */
       print_state(STATE_NORMAL, "Jumping into the kernel");
       jump_kernel(ent);

       fatal("init_prekern: unreachable!");
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.