mirror of
https://github.com/Atmosphere-NX/Atmosphere.git
synced 2024-12-11 07:26:08 +01:00
thermosphere: remove legacy code
This commit is contained in:
TuxSH
parent
1545fa9d44
commit
1f7a1f71d6
1
thermosphere/.gitignore
vendored
1
thermosphere/.gitignore
vendored
@ -1 +0,0 @@
|
||||
out
|
||||
@ -1,163 +0,0 @@
|
||||
#---------------------------------------------------------------------------------
|
||||
.SUFFIXES:
|
||||
#---------------------------------------------------------------------------------
|
||||
|
||||
ifeq ($(strip $(DEVKITPRO)),)
|
||||
$(error "Please set DEVKITPRO in your environment. export DEVKITPRO=<path to>/devkitpro")
|
||||
endif
|
||||
|
||||
TOPDIR ?= $(CURDIR)
|
||||
include $(DEVKITPRO)/devkitA64/base_rules
|
||||
|
||||
AMSBRANCH := $(shell git symbolic-ref --short HEAD)
|
||||
AMSREV := $(AMSBRANCH)-$(shell git rev-parse --short HEAD)
|
||||
|
||||
ifneq (, $(strip $(shell git status --porcelain 2>/dev/null)))
|
||||
AMSREV := $(AMSREV)-dirty
|
||||
endif
|
||||
|
||||
#---------------------------------------------------------------------------------
|
||||
# TARGET is the name of the output
|
||||
# BUILD is the directory where object files & intermediate files will be placed
|
||||
# SOURCES is a list of directories containing source code
|
||||
# DATA is a list of directories containing data files
|
||||
# INCLUDES is a list of directories containing header files
|
||||
#---------------------------------------------------------------------------------
|
||||
TARGET := $(notdir $(CURDIR))
|
||||
BUILD := build
|
||||
SOURCES := src src/lib
|
||||
DATA := data
|
||||
INCLUDES := include ../common/include
|
||||
|
||||
#---------------------------------------------------------------------------------
|
||||
# options for code generation
|
||||
#---------------------------------------------------------------------------------
|
||||
ARCH := -march=armv8-a -mtune=cortex-a57
|
||||
DEFINES := -DATMOSPHERE_GIT_BRANCH=\"$(AMSBRANCH)\" -DATMOSPHERE_GIT_REV=\"$(AMSREV)\"
|
||||
|
||||
CFLAGS := \
|
||||
-g \
|
||||
-O2 \
|
||||
-ffunction-sections \
|
||||
-fdata-sections \
|
||||
-mgeneral-regs-only \
|
||||
-fomit-frame-pointer \
|
||||
-std=gnu11 \
|
||||
-Werror \
|
||||
-Wall \
|
||||
-Wno-main \
|
||||
$(ARCH) $(DEFINES)
|
||||
|
||||
CFLAGS += $(INCLUDE) -D__CCPLEX__
|
||||
|
||||
CXXFLAGS := $(CFLAGS) -fno-rtti -fno-exceptions -std=gnu++11
|
||||
|
||||
ASFLAGS := -g $(ARCH)
|
||||
LDFLAGS = -specs=$(TOPDIR)/linker.specs -g $(ARCH) -Wl,-Map,$(notdir $*.map)
|
||||
|
||||
LIBS :=
|
||||
|
||||
#---------------------------------------------------------------------------------
|
||||
# list of directories containing libraries, this must be the top level containing
|
||||
# include and lib
|
||||
#---------------------------------------------------------------------------------
|
||||
LIBDIRS :=
|
||||
|
||||
|
||||
#---------------------------------------------------------------------------------
|
||||
# no real need to edit anything past this point unless you need to add additional
|
||||
# rules for different file extensions
|
||||
#---------------------------------------------------------------------------------
|
||||
ifneq ($(BUILD),$(notdir $(CURDIR)))
|
||||
#---------------------------------------------------------------------------------
|
||||
|
||||
export OUTPUT := $(CURDIR)/$(TARGET)
|
||||
export TOPDIR := $(CURDIR)
|
||||
|
||||
export VPATH := $(foreach dir,$(SOURCES),$(CURDIR)/$(dir)) \
|
||||
$(foreach dir,$(DATA),$(CURDIR)/$(dir))
|
||||
|
||||
export DEPSDIR := $(CURDIR)/$(BUILD)
|
||||
|
||||
CFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
|
||||
CPPFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.cpp)))
|
||||
SFILES := $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))
|
||||
BINFILES := $(foreach dir,$(DATA),$(notdir $(wildcard $(dir)/*.*)))
|
||||
|
||||
#---------------------------------------------------------------------------------
|
||||
# use CXX for linking C++ projects, CC for standard C
|
||||
#---------------------------------------------------------------------------------
|
||||
ifeq ($(strip $(CPPFILES)),)
|
||||
#---------------------------------------------------------------------------------
|
||||
export LD := $(CC)
|
||||
#---------------------------------------------------------------------------------
|
||||
else
|
||||
#---------------------------------------------------------------------------------
|
||||
export LD := $(CXX)
|
||||
#---------------------------------------------------------------------------------
|
||||
endif
|
||||
#---------------------------------------------------------------------------------
|
||||
|
||||
export OFILES_BIN := $(addsuffix .o,$(BINFILES))
|
||||
export OFILES_SRC := $(CPPFILES:.cpp=.o) $(CFILES:.c=.o) $(SFILES:.s=.o)
|
||||
export OFILES := $(OFILES_BIN) $(OFILES_SRC)
|
||||
export HFILES_BIN := $(addsuffix .h,$(subst .,_,$(BINFILES)))
|
||||
|
||||
export INCLUDE := $(foreach dir,$(INCLUDES),-I$(CURDIR)/$(dir)) \
|
||||
$(foreach dir,$(LIBDIRS),-I$(dir)/include) \
|
||||
-I$(CURDIR)/$(BUILD)
|
||||
|
||||
export LIBPATHS := $(foreach dir,$(LIBDIRS),-L$(dir)/lib)
|
||||
|
||||
.PHONY: $(BUILD) clean all
|
||||
|
||||
#---------------------------------------------------------------------------------
|
||||
all: $(BUILD)
|
||||
|
||||
$(BUILD):
|
||||
@[ -d $@ ] || mkdir -p $@
|
||||
@$(MAKE) --no-print-directory -C $(BUILD) -f $(CURDIR)/Makefile
|
||||
|
||||
#---------------------------------------------------------------------------------
|
||||
clean:
|
||||
@echo clean ...
|
||||
@rm -fr $(BUILD) $(TARGET).bin $(TARGET).elf
|
||||
|
||||
|
||||
#---------------------------------------------------------------------------------
|
||||
else
|
||||
.PHONY: all
|
||||
|
||||
DEPENDS := $(OFILES:.o=.d)
|
||||
|
||||
#---------------------------------------------------------------------------------
|
||||
# main targets
|
||||
#---------------------------------------------------------------------------------
|
||||
all : $(OUTPUT).bin
|
||||
|
||||
$(OUTPUT).bin : $(OUTPUT).elf
|
||||
$(OBJCOPY) -S -O binary $< $@
|
||||
@echo built ... $(notdir $@)
|
||||
|
||||
$(OUTPUT).elf : $(OFILES)
|
||||
|
||||
%.elf:
|
||||
@echo linking $(notdir $@)
|
||||
$(LD) $(LDFLAGS) $(OFILES) $(LIBPATHS) $(LIBS) -o $@
|
||||
@$(NM) -CSn $@ > $(notdir $*.lst)
|
||||
|
||||
$(OFILES_SRC) : $(HFILES_BIN)
|
||||
|
||||
#---------------------------------------------------------------------------------
|
||||
# you need a rule like this for each extension you use as binary data
|
||||
#---------------------------------------------------------------------------------
|
||||
%.bin.o : %.bin
|
||||
#---------------------------------------------------------------------------------
|
||||
@echo $(notdir $<)
|
||||
@$(bin2o)
|
||||
|
||||
-include $(DEPENDS)
|
||||
|
||||
#---------------------------------------------------------------------------------------
|
||||
endif
|
||||
#---------------------------------------------------------------------------------------
|
||||
@ -1,6 +0,0 @@
|
||||
Thermosphère
|
||||
=====
|
||||
|
||||
|
||||
|
||||
Thermosphère is a hypervisor for the Nintendo Switch.
|
||||
@ -1,55 +0,0 @@
|
||||
OUTPUT_FORMAT("elf64-littleaarch64")
|
||||
OUTPUT_ARCH(aarch64)
|
||||
ENTRY(_start)
|
||||
|
||||
SECTIONS
|
||||
{
|
||||
. = 0x800D0000;
|
||||
|
||||
. = ALIGN(4);
|
||||
.text : {
|
||||
PROVIDE(lds_thermo_start = .);
|
||||
start.o (.text*)
|
||||
*(.text*)
|
||||
}
|
||||
|
||||
. = ALIGN(8);
|
||||
.rodata : {
|
||||
*(SORT_BY_ALIGNMENT(SORT_BY_NAME(.rodata*)))
|
||||
}
|
||||
|
||||
. = ALIGN(8);
|
||||
.data : {
|
||||
*(.data*)
|
||||
}
|
||||
|
||||
/* Uninitialised data */
|
||||
. = ALIGN(8);
|
||||
PROVIDE(lds_bss_start = .);
|
||||
.bss (NOLOAD) : {
|
||||
*(.bss*) . = ALIGN(8);
|
||||
}
|
||||
PROVIDE(lds_bss_end = .);
|
||||
|
||||
/* EL2 stack */
|
||||
. = ALIGN(16);
|
||||
. += 0x10000; /* 64 KiB stack */
|
||||
el2_stack_end = .;
|
||||
|
||||
/* Page align the end of binary */
|
||||
. = ALIGN(512);
|
||||
PROVIDE(lds_el2_thermo_end = .);
|
||||
|
||||
/* EL1 stack */
|
||||
. = ALIGN(16);
|
||||
. += 0x10000; /* 64 KiB stack */
|
||||
el1_stack_end = .;
|
||||
|
||||
lds_thermo_end = .;
|
||||
|
||||
/DISCARD/ : { *(.dynstr*) }
|
||||
/DISCARD/ : { *(.dynamic*) }
|
||||
/DISCARD/ : { *(.plt*) }
|
||||
/DISCARD/ : { *(.interp*) }
|
||||
/DISCARD/ : { *(.gnu*) }
|
||||
}
|
||||
@ -1,7 +0,0 @@
|
||||
%rename link old_link
|
||||
|
||||
*link:
|
||||
%(old_link) -T %:getenv(TOPDIR /linker.ld) --nmagic --gc-sections
|
||||
|
||||
*startfile:
|
||||
crti%O%s crtbegin%O%s
|
||||
@ -1,108 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2018-2020 Atmosphère-NX
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms and conditions of the GNU General Public License,
|
||||
* version 2, as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
#include "exceptions.h"
|
||||
|
||||
#include "lib/printk.h"
|
||||
|
||||
/**
|
||||
* Simple debug function that prints all of our saved registers.
|
||||
*/
|
||||
static void print_registers(struct guest_state *regs)
|
||||
{
|
||||
// print x0-29
|
||||
for(int i = 0; i < 30; i += 2) {
|
||||
printk("x%d:\t0x%p\t", i, regs->x[i]);
|
||||
printk("x%d:\t0x%p\n", i + 1, regs->x[i + 1]);
|
||||
}
|
||||
|
||||
// print x30; don't bother with x31 (SP), as it's used by the stack that's
|
||||
// storing this stuff; we really care about the saved SP anyways
|
||||
printk("x30:\t0x%p\n", regs->x[30]);
|
||||
|
||||
// Special registers.
|
||||
printk("pc:\t0x%p\tcpsr:\t0x%p\n", regs->pc, regs->cpsr);
|
||||
printk("sp_el1:\t0x%p\tsp_el0:\t0x%p\n", regs->sp_el1, regs->sp_el0);
|
||||
printk("elr_el1:0x%p\tspsr_el1:0x%p\n", regs->elr_el1, regs->spsr_el1);
|
||||
|
||||
// Note that we don't print ESR_EL2, as this isn't really part of the saved state.
|
||||
}
|
||||
|
||||
/**
|
||||
* Placeholder function that triggers whenever a vector happens we're not
|
||||
* expecting. Currently prints out some debug information.
|
||||
*/
|
||||
void unhandled_vector(struct guest_state *regs)
|
||||
{
|
||||
printk("\nAn unexpected vector happened!\n");
|
||||
print_registers(regs);
|
||||
printk("\n\n");
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Handles an HVC call.
|
||||
*/
|
||||
static void handle_hvc(struct guest_state *regs, int call_number)
|
||||
{
|
||||
|
||||
switch(call_number) {
|
||||
|
||||
|
||||
default:
|
||||
printk("Got a HVC call from 64-bit code.\n");
|
||||
printk("Calling instruction was: hvc %d\n\n", call_number);
|
||||
printk("Calling context (you can use these regs as hypercall args!):\n");
|
||||
print_registers(regs);
|
||||
printk("\n\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Placeholder function that triggers whenever a user event triggers a
|
||||
* synchronous interrupt. Currently, we really only care about 'hvc',
|
||||
* so that's all we're going to handle here.
|
||||
*/
|
||||
|
||||
void handle_hypercall(struct guest_state *regs)
|
||||
{
|
||||
// This is demonstration code.
|
||||
// In the future, you'd stick your hypercall table here.
|
||||
|
||||
switch (regs->esr_el2.ec) {
|
||||
|
||||
case HSR_EC_HVC64: {
|
||||
// Read the hypercall number.
|
||||
int hvc_nr = regs->esr_el2.iss & 0xFFFF;
|
||||
|
||||
// ... and handle the hypercall.
|
||||
handle_hvc(regs, hvc_nr);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
printk("Unexpected hypercall! ESR=%p\n", regs->esr_el2.bits);
|
||||
print_registers(regs);
|
||||
printk("\n\n");
|
||||
break;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@ -1,185 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2018-2020 Atmosphère-NX
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms and conditions of the GNU General Public License,
|
||||
* version 2, as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef __EXCEPTION_H__
|
||||
#define __EXCEPTION_H__
|
||||
|
||||
/**
|
||||
* Borrowed fom Xen (not copyrightable as these are facts).
|
||||
* Description of the EL2 exception syndrome register.
|
||||
*/
|
||||
#define HSR_EC_UNKNOWN 0x00
|
||||
#define HSR_EC_WFI_WFE 0x01
|
||||
#define HSR_EC_CP15_32 0x03
|
||||
#define HSR_EC_CP15_64 0x04
|
||||
#define HSR_EC_CP14_32 0x05 /* Trapped MCR or MRC access to CP14 */
|
||||
#define HSR_EC_CP14_DBG 0x06 /* Trapped LDC/STC access to CP14 (only for debug registers) */
|
||||
#define HSR_EC_CP 0x07 /* HCPTR-trapped access to CP0-CP13 */
|
||||
#define HSR_EC_CP10 0x08
|
||||
#define HSR_EC_JAZELLE 0x09
|
||||
#define HSR_EC_BXJ 0x0a
|
||||
#define HSR_EC_CP14_64 0x0c
|
||||
#define HSR_EC_SVC32 0x11
|
||||
#define HSR_EC_HVC32 0x12
|
||||
#define HSR_EC_SMC32 0x13
|
||||
#define HSR_EC_HVC64 0x16
|
||||
#define HSR_EC_SMC64 0x17
|
||||
#define HSR_EC_SYSREG 0x18
|
||||
#define HSR_EC_INSTR_ABORT_LOWER_EL 0x20
|
||||
#define HSR_EC_INSTR_ABORT_CURR_EL 0x21
|
||||
#define HSR_EC_DATA_ABORT_LOWER_EL 0x24
|
||||
#define HSR_EC_DATA_ABORT_CURR_EL 0x25
|
||||
#define HSR_EC_BRK 0x3c
|
||||
|
||||
/**
|
||||
* Borrowed fom Xen (not copyrightable as these are facts).
|
||||
* Description of the EL2 exception syndrome register.
|
||||
*/
|
||||
union esr {
|
||||
uint32_t bits;
|
||||
struct {
|
||||
unsigned long iss:25; /* Instruction Specific Syndrome */
|
||||
unsigned long len:1; /* Instruction length */
|
||||
unsigned long ec:6; /* Exception Class */
|
||||
};
|
||||
|
||||
/* Common to all conditional exception classes (0x0N, except 0x00). */
|
||||
struct hsr_cond {
|
||||
unsigned long iss:20; /* Instruction Specific Syndrome */
|
||||
unsigned long cc:4; /* Condition Code */
|
||||
unsigned long ccvalid:1;/* CC Valid */
|
||||
unsigned long len:1; /* Instruction length */
|
||||
unsigned long ec:6; /* Exception Class */
|
||||
} cond;
|
||||
|
||||
struct hsr_wfi_wfe {
|
||||
unsigned long ti:1; /* Trapped instruction */
|
||||
unsigned long sbzp:19;
|
||||
unsigned long cc:4; /* Condition Code */
|
||||
unsigned long ccvalid:1;/* CC Valid */
|
||||
unsigned long len:1; /* Instruction length */
|
||||
unsigned long ec:6; /* Exception Class */
|
||||
} wfi_wfe;
|
||||
|
||||
/* reg, reg0, reg1 are 4 bits on AArch32, the fifth bit is sbzp. */
|
||||
struct hsr_cp32 {
|
||||
unsigned long read:1; /* Direction */
|
||||
unsigned long crm:4; /* CRm */
|
||||
unsigned long reg:5; /* Rt */
|
||||
unsigned long crn:4; /* CRn */
|
||||
unsigned long op1:3; /* Op1 */
|
||||
unsigned long op2:3; /* Op2 */
|
||||
unsigned long cc:4; /* Condition Code */
|
||||
unsigned long ccvalid:1;/* CC Valid */
|
||||
unsigned long len:1; /* Instruction length */
|
||||
unsigned long ec:6; /* Exception Class */
|
||||
} cp32; /* HSR_EC_CP15_32, CP14_32, CP10 */
|
||||
|
||||
struct hsr_cp64 {
|
||||
unsigned long read:1; /* Direction */
|
||||
unsigned long crm:4; /* CRm */
|
||||
unsigned long reg1:5; /* Rt1 */
|
||||
unsigned long reg2:5; /* Rt2 */
|
||||
unsigned long sbzp2:1;
|
||||
unsigned long op1:4; /* Op1 */
|
||||
unsigned long cc:4; /* Condition Code */
|
||||
unsigned long ccvalid:1;/* CC Valid */
|
||||
unsigned long len:1; /* Instruction length */
|
||||
unsigned long ec:6; /* Exception Class */
|
||||
} cp64; /* HSR_EC_CP15_64, HSR_EC_CP14_64 */
|
||||
|
||||
struct hsr_cp {
|
||||
unsigned long coproc:4; /* Number of coproc accessed */
|
||||
unsigned long sbz0p:1;
|
||||
unsigned long tas:1; /* Trapped Advanced SIMD */
|
||||
unsigned long res0:14;
|
||||
unsigned long cc:4; /* Condition Code */
|
||||
unsigned long ccvalid:1;/* CC Valid */
|
||||
unsigned long len:1; /* Instruction length */
|
||||
unsigned long ec:6; /* Exception Class */
|
||||
} cp; /* HSR_EC_CP */
|
||||
|
||||
struct hsr_sysreg {
|
||||
unsigned long read:1; /* Direction */
|
||||
unsigned long crm:4; /* CRm */
|
||||
unsigned long reg:5; /* Rt */
|
||||
unsigned long crn:4; /* CRn */
|
||||
unsigned long op1:3; /* Op1 */
|
||||
unsigned long op2:3; /* Op2 */
|
||||
unsigned long op0:2; /* Op0 */
|
||||
unsigned long res0:3;
|
||||
unsigned long len:1; /* Instruction length */
|
||||
unsigned long ec:6;
|
||||
} sysreg; /* HSR_EC_SYSREG */
|
||||
|
||||
struct hsr_iabt {
|
||||
unsigned long ifsc:6; /* Instruction fault status code */
|
||||
unsigned long res0:1;
|
||||
unsigned long s1ptw:1; /* Stage 2 fault during stage 1 translation */
|
||||
unsigned long res1:1;
|
||||
unsigned long eat:1; /* External abort type */
|
||||
unsigned long res2:15;
|
||||
unsigned long len:1; /* Instruction length */
|
||||
unsigned long ec:6; /* Exception Class */
|
||||
} iabt; /* HSR_EC_INSTR_ABORT_* */
|
||||
|
||||
struct hsr_dabt {
|
||||
unsigned long dfsc:6; /* Data Fault Status Code */
|
||||
unsigned long write:1; /* Write / not Read */
|
||||
unsigned long s1ptw:1; /* Stage 2 fault during stage 1 translation */
|
||||
unsigned long cache:1; /* Cache Maintenance */
|
||||
unsigned long eat:1; /* External Abort Type */
|
||||
unsigned long sbzp0:4;
|
||||
unsigned long ar:1; /* Acquire Release */
|
||||
unsigned long sf:1; /* Sixty Four bit register */
|
||||
unsigned long reg:5; /* Register */
|
||||
unsigned long sign:1; /* Sign extend */
|
||||
unsigned long size:2; /* Access Size */
|
||||
unsigned long valid:1; /* Syndrome Valid */
|
||||
unsigned long len:1; /* Instruction length */
|
||||
unsigned long ec:6; /* Exception Class */
|
||||
} dabt; /* HSR_EC_DATA_ABORT_* */
|
||||
|
||||
struct hsr_brk {
|
||||
unsigned long comment:16; /* Comment */
|
||||
unsigned long res0:9;
|
||||
unsigned long len:1; /* Instruction length */
|
||||
unsigned long ec:6; /* Exception Class */
|
||||
} brk;
|
||||
|
||||
};
|
||||
|
||||
/**
|
||||
* Structure that stores the saved register values on a hypercall.
|
||||
*/
|
||||
struct guest_state {
|
||||
uint64_t pc;
|
||||
uint64_t cpsr;
|
||||
|
||||
uint64_t elr_el1;
|
||||
uint64_t spsr_el1;
|
||||
|
||||
uint64_t sp_el0;
|
||||
uint64_t sp_el1;
|
||||
|
||||
union esr esr_el2;
|
||||
uint64_t x[31];
|
||||
}
|
||||
__attribute__((packed));
|
||||
|
||||
|
||||
|
||||
#endif
|
||||
@ -1,272 +0,0 @@
|
||||
/* inih -- simple .INI file parser
|
||||
|
||||
inih is released under the New BSD license (see LICENSE.txt). Go to the project
|
||||
home page for more info:
|
||||
|
||||
https://github.com/benhoyt/inih
|
||||
|
||||
*/
|
||||
|
||||
#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
|
||||
#define _CRT_SECURE_NO_WARNINGS
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "ini.h"
|
||||
|
||||
#if !INI_USE_STACK
|
||||
#include <stdlib.h>
|
||||
#endif
|
||||
|
||||
#define MAX_SECTION 50
|
||||
#define MAX_NAME 50
|
||||
|
||||
/* Used by ini_parse_string() to keep track of string parsing state. */
|
||||
typedef struct {
|
||||
const char* ptr;
|
||||
size_t num_left;
|
||||
} ini_parse_string_ctx;
|
||||
|
||||
/* Strip whitespace chars off end of given string, in place. Return s. */
|
||||
static char* rstrip(char* s)
|
||||
{
|
||||
char* p = s + strlen(s);
|
||||
while (p > s && isspace((unsigned char)(*--p)))
|
||||
*p = '\0';
|
||||
return s;
|
||||
}
|
||||
|
||||
/* Return pointer to first non-whitespace char in given string. */
|
||||
static char* lskip(const char* s)
|
||||
{
|
||||
while (*s && isspace((unsigned char)(*s)))
|
||||
s++;
|
||||
return (char*)s;
|
||||
}
|
||||
|
||||
/* Return pointer to first char (of chars) or inline comment in given string,
|
||||
or pointer to null at end of string if neither found. Inline comment must
|
||||
be prefixed by a whitespace character to register as a comment. */
|
||||
static char* find_chars_or_comment(const char* s, const char* chars)
|
||||
{
|
||||
#if INI_ALLOW_INLINE_COMMENTS
|
||||
int was_space = 0;
|
||||
while (*s && (!chars || !strchr(chars, *s)) &&
|
||||
!(was_space && strchr(INI_INLINE_COMMENT_PREFIXES, *s))) {
|
||||
was_space = isspace((unsigned char)(*s));
|
||||
s++;
|
||||
}
|
||||
#else
|
||||
while (*s && (!chars || !strchr(chars, *s))) {
|
||||
s++;
|
||||
}
|
||||
#endif
|
||||
return (char*)s;
|
||||
}
|
||||
|
||||
/* Version of strncpy that ensures dest (size bytes) is null-terminated. */
|
||||
static char* strncpy0(char* dest, const char* src, size_t size)
|
||||
{
|
||||
#pragma GCC diagnostic push
|
||||
#pragma GCC diagnostic ignored "-Wstringop-truncation"
|
||||
strncpy(dest, src, size - 1);
|
||||
#pragma GCC diagnostic pop
|
||||
dest[size - 1] = '\0';
|
||||
return dest;
|
||||
}
|
||||
|
||||
/* See documentation in header file. */
|
||||
int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
|
||||
void* user)
|
||||
{
|
||||
/* Uses a fair bit of stack (use heap instead if you need to) */
|
||||
#if INI_USE_STACK
|
||||
char line[INI_MAX_LINE];
|
||||
int max_line = INI_MAX_LINE;
|
||||
#else
|
||||
char* line;
|
||||
int max_line = INI_INITIAL_ALLOC;
|
||||
#endif
|
||||
#if INI_ALLOW_REALLOC
|
||||
char* new_line;
|
||||
int offset;
|
||||
#endif
|
||||
char section[MAX_SECTION] = "";
|
||||
char prev_name[MAX_NAME] = "";
|
||||
|
||||
char* start;
|
||||
char* end;
|
||||
char* name;
|
||||
char* value;
|
||||
int lineno = 0;
|
||||
int error = 0;
|
||||
|
||||
#if !INI_USE_STACK
|
||||
line = (char*)malloc(INI_INITIAL_ALLOC);
|
||||
if (!line) {
|
||||
return -2;
|
||||
}
|
||||
#endif
|
||||
|
||||
#if INI_HANDLER_LINENO
|
||||
#define HANDLER(u, s, n, v) handler(u, s, n, v, lineno)
|
||||
#else
|
||||
#define HANDLER(u, s, n, v) handler(u, s, n, v)
|
||||
#endif
|
||||
|
||||
/* Scan through stream line by line */
|
||||
while (reader(line, max_line, stream) != NULL) {
|
||||
#if INI_ALLOW_REALLOC
|
||||
offset = strlen(line);
|
||||
while (offset == max_line - 1 && line[offset - 1] != '\n') {
|
||||
max_line *= 2;
|
||||
if (max_line > INI_MAX_LINE)
|
||||
max_line = INI_MAX_LINE;
|
||||
new_line = realloc(line, max_line);
|
||||
if (!new_line) {
|
||||
free(line);
|
||||
return -2;
|
||||
}
|
||||
line = new_line;
|
||||
if (reader(line + offset, max_line - offset, stream) == NULL)
|
||||
break;
|
||||
if (max_line >= INI_MAX_LINE)
|
||||
break;
|
||||
offset += strlen(line + offset);
|
||||
}
|
||||
#endif
|
||||
|
||||
lineno++;
|
||||
|
||||
start = line;
|
||||
#if INI_ALLOW_BOM
|
||||
if (lineno == 1 && (unsigned char)start[0] == 0xEF &&
|
||||
(unsigned char)start[1] == 0xBB &&
|
||||
(unsigned char)start[2] == 0xBF) {
|
||||
start += 3;
|
||||
}
|
||||
#endif
|
||||
start = lskip(rstrip(start));
|
||||
|
||||
if (strchr(INI_START_COMMENT_PREFIXES, *start)) {
|
||||
/* Start-of-line comment */
|
||||
}
|
||||
#if INI_ALLOW_MULTILINE
|
||||
else if (*prev_name && *start && start > line) {
|
||||
/* Non-blank line with leading whitespace, treat as continuation
|
||||
of previous name's value (as per Python configparser). */
|
||||
if (!HANDLER(user, section, prev_name, start) && !error)
|
||||
error = lineno;
|
||||
}
|
||||
#endif
|
||||
else if (*start == '[') {
|
||||
/* A "[section]" line */
|
||||
end = find_chars_or_comment(start + 1, "]");
|
||||
if (*end == ']') {
|
||||
*end = '\0';
|
||||
strncpy0(section, start + 1, sizeof(section));
|
||||
*prev_name = '\0';
|
||||
}
|
||||
else if (!error) {
|
||||
/* No ']' found on section line */
|
||||
error = lineno;
|
||||
}
|
||||
}
|
||||
else if (*start) {
|
||||
/* Not a comment, must be a name[=:]value pair */
|
||||
end = find_chars_or_comment(start, "=:");
|
||||
if (*end == '=' || *end == ':') {
|
||||
*end = '\0';
|
||||
name = rstrip(start);
|
||||
value = end + 1;
|
||||
#if INI_ALLOW_INLINE_COMMENTS
|
||||
end = find_chars_or_comment(value, NULL);
|
||||
if (*end)
|
||||
*end = '\0';
|
||||
#endif
|
||||
value = lskip(value);
|
||||
rstrip(value);
|
||||
|
||||
/* Valid name[=:]value pair found, call handler */
|
||||
strncpy0(prev_name, name, sizeof(prev_name));
|
||||
if (!HANDLER(user, section, name, value) && !error)
|
||||
error = lineno;
|
||||
}
|
||||
else if (!error) {
|
||||
/* No '=' or ':' found on name[=:]value line */
|
||||
error = lineno;
|
||||
}
|
||||
}
|
||||
|
||||
#if INI_STOP_ON_FIRST_ERROR
|
||||
if (error)
|
||||
break;
|
||||
#endif
|
||||
}
|
||||
|
||||
#if !INI_USE_STACK
|
||||
free(line);
|
||||
#endif
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
/* See documentation in header file. */
|
||||
int ini_parse_file(FILE* file, ini_handler handler, void* user)
|
||||
{
|
||||
return ini_parse_stream((ini_reader)fgets, file, handler, user);
|
||||
}
|
||||
|
||||
/* See documentation in header file. */
|
||||
int ini_parse(const char* filename, ini_handler handler, void* user)
|
||||
{
|
||||
FILE* file;
|
||||
int error;
|
||||
|
||||
file = fopen(filename, "r");
|
||||
if (!file)
|
||||
return -1;
|
||||
error = ini_parse_file(file, handler, user);
|
||||
fclose(file);
|
||||
return error;
|
||||
}
|
||||
|
||||
/* An ini_reader function to read the next line from a string buffer. This
|
||||
is the fgets() equivalent used by ini_parse_string(). */
|
||||
static char* ini_reader_string(char* str, int num, void* stream) {
|
||||
ini_parse_string_ctx* ctx = (ini_parse_string_ctx*)stream;
|
||||
const char* ctx_ptr = ctx->ptr;
|
||||
size_t ctx_num_left = ctx->num_left;
|
||||
char* strp = str;
|
||||
char c;
|
||||
|
||||
if (ctx_num_left == 0 || num < 2)
|
||||
return NULL;
|
||||
|
||||
while (num > 1 && ctx_num_left != 0) {
|
||||
c = *ctx_ptr++;
|
||||
ctx_num_left--;
|
||||
*strp++ = c;
|
||||
if (c == '\n')
|
||||
break;
|
||||
num--;
|
||||
}
|
||||
|
||||
*strp = '\0';
|
||||
ctx->ptr = ctx_ptr;
|
||||
ctx->num_left = ctx_num_left;
|
||||
return str;
|
||||
}
|
||||
|
||||
/* See documentation in header file. */
|
||||
int ini_parse_string(const char* string, ini_handler handler, void* user) {
|
||||
ini_parse_string_ctx ctx;
|
||||
|
||||
ctx.ptr = string;
|
||||
ctx.num_left = strlen(string);
|
||||
return ini_parse_stream((ini_reader)ini_reader_string, &ctx, handler,
|
||||
user);
|
||||
}
|
||||
@ -1,130 +0,0 @@
|
||||
/* inih -- simple .INI file parser
|
||||
|
||||
inih is released under the New BSD license (see LICENSE.txt). Go to the project
|
||||
home page for more info:
|
||||
|
||||
https://github.com/benhoyt/inih
|
||||
|
||||
*/
|
||||
|
||||
#ifndef __INI_H__
|
||||
#define __INI_H__
|
||||
|
||||
/* Make this header file easier to include in C++ code */
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
/* Nonzero if ini_handler callback should accept lineno parameter. */
|
||||
#ifndef INI_HANDLER_LINENO
|
||||
#define INI_HANDLER_LINENO 0
|
||||
#endif
|
||||
|
||||
/* Typedef for prototype of handler function. */
|
||||
#if INI_HANDLER_LINENO
|
||||
typedef int (*ini_handler)(void* user, const char* section,
|
||||
const char* name, const char* value,
|
||||
int lineno);
|
||||
#else
|
||||
typedef int (*ini_handler)(void* user, const char* section,
|
||||
const char* name, const char* value);
|
||||
#endif
|
||||
|
||||
/* Typedef for prototype of fgets-style reader function. */
|
||||
typedef char* (*ini_reader)(char* str, int num, void* stream);
|
||||
|
||||
/* Parse given INI-style file. May have [section]s, name=value pairs
|
||||
(whitespace stripped), and comments starting with ';' (semicolon). Section
|
||||
is "" if name=value pair parsed before any section heading. name:value
|
||||
pairs are also supported as a concession to Python's configparser.
|
||||
|
||||
For each name=value pair parsed, call handler function with given user
|
||||
pointer as well as section, name, and value (data only valid for duration
|
||||
of handler call). Handler should return nonzero on success, zero on error.
|
||||
|
||||
Returns 0 on success, line number of first error on parse error (doesn't
|
||||
stop on first error), -1 on file open error, or -2 on memory allocation
|
||||
error (only when INI_USE_STACK is zero).
|
||||
*/
|
||||
int ini_parse(const char* filename, ini_handler handler, void* user);
|
||||
|
||||
/* Same as ini_parse(), but takes a FILE* instead of filename. This doesn't
|
||||
close the file when it's finished -- the caller must do that. */
|
||||
int ini_parse_file(FILE* file, ini_handler handler, void* user);
|
||||
|
||||
/* Same as ini_parse(), but takes an ini_reader function pointer instead of
|
||||
filename. Used for implementing custom or string-based I/O (see also
|
||||
ini_parse_string). */
|
||||
int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
|
||||
void* user);
|
||||
|
||||
/* Same as ini_parse(), but takes a zero-terminated string with the INI data
|
||||
instead of a file. Useful for parsing INI data from a network socket or
|
||||
already in memory. */
|
||||
int ini_parse_string(const char* string, ini_handler handler, void* user);
|
||||
|
||||
/* Nonzero to allow multi-line value parsing, in the style of Python's
|
||||
configparser. If allowed, ini_parse() will call the handler with the same
|
||||
name for each subsequent line parsed. */
|
||||
#ifndef INI_ALLOW_MULTILINE
|
||||
#define INI_ALLOW_MULTILINE 1
|
||||
#endif
|
||||
|
||||
/* Nonzero to allow a UTF-8 BOM sequence (0xEF 0xBB 0xBF) at the start of
|
||||
the file. See http://code.google.com/p/inih/issues/detail?id=21 */
|
||||
#ifndef INI_ALLOW_BOM
|
||||
#define INI_ALLOW_BOM 1
|
||||
#endif
|
||||
|
||||
/* Chars that begin a start-of-line comment. Per Python configparser, allow
|
||||
both ; and # comments at the start of a line by default. */
|
||||
#ifndef INI_START_COMMENT_PREFIXES
|
||||
#define INI_START_COMMENT_PREFIXES ";#"
|
||||
#endif
|
||||
|
||||
/* Nonzero to allow inline comments (with valid inline comment characters
|
||||
specified by INI_INLINE_COMMENT_PREFIXES). Set to 0 to turn off and match
|
||||
Python 3.2+ configparser behaviour. */
|
||||
#ifndef INI_ALLOW_INLINE_COMMENTS
|
||||
#define INI_ALLOW_INLINE_COMMENTS 1
|
||||
#endif
|
||||
#ifndef INI_INLINE_COMMENT_PREFIXES
|
||||
#define INI_INLINE_COMMENT_PREFIXES ";"
|
||||
#endif
|
||||
|
||||
/* Nonzero to use stack for line buffer, zero to use heap (malloc/free). */
|
||||
#ifndef INI_USE_STACK
|
||||
#define INI_USE_STACK 1
|
||||
#endif
|
||||
|
||||
/* Maximum line length for any line in INI file (stack or heap). Note that
|
||||
this must be 3 more than the longest line (due to '\r', '\n', and '\0'). */
|
||||
#ifndef INI_MAX_LINE
|
||||
#define INI_MAX_LINE 200
|
||||
#endif
|
||||
|
||||
/* Nonzero to allow heap line buffer to grow via realloc(), zero for a
|
||||
fixed-size buffer of INI_MAX_LINE bytes. Only applies if INI_USE_STACK is
|
||||
zero. */
|
||||
#ifndef INI_ALLOW_REALLOC
|
||||
#define INI_ALLOW_REALLOC 0
|
||||
#endif
|
||||
|
||||
/* Initial size in bytes for heap line buffer. Only applies if INI_USE_STACK
|
||||
is zero. */
|
||||
#ifndef INI_INITIAL_ALLOC
|
||||
#define INI_INITIAL_ALLOC 200
|
||||
#endif
|
||||
|
||||
/* Stop parsing on first error (default is to keep parsing). */
|
||||
#ifndef INI_STOP_ON_FIRST_ERROR
|
||||
#define INI_STOP_ON_FIRST_ERROR 0
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __INI_H__ */
|
||||
@ -1,36 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2018-2020 Atmosphère-NX
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms and conditions of the GNU General Public License,
|
||||
* version 2, as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "printk.h"
|
||||
#include "vsprintf.h"
|
||||
|
||||
/**
|
||||
* Temporary stand-in main printk.
|
||||
*
|
||||
* TODO: This should print via UART, console framebuffer, and to a ring for
|
||||
* consumption by Horizon
|
||||
*/
|
||||
void printk(char *fmt, ...)
|
||||
{
|
||||
va_list list;
|
||||
char buf[512];
|
||||
va_start(list, fmt);
|
||||
vsnprintf(buf, sizeof(buf), fmt, list);
|
||||
|
||||
/* FIXME: print via UART */
|
||||
|
||||
va_end(list);
|
||||
}
|
||||
@ -1,17 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2018-2020 Atmosphère-NX
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms and conditions of the GNU General Public License,
|
||||
* version 2, as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
void printk(char *fmt, ...);
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,25 +0,0 @@
|
||||
/*
|
||||
* Copyright (C) 2011 Andrei Warkentin <andrey.warkentin@gmail.com>
|
||||
*
|
||||
* This program is free software ; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*/
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#ifndef VSPRINTF_H
|
||||
#define VSPRINTF_H
|
||||
|
||||
struct va_format {
|
||||
const char *fmt;
|
||||
va_list *va;
|
||||
};
|
||||
|
||||
unsigned long long simple_strtoull(const char *cp, char **endp, unsigned int base);
|
||||
|
||||
int vsnprintf(char *buf, size_t size, const char *fmt, va_list args);
|
||||
int sscanf(const char *buf, const char *fmt, ...);
|
||||
|
||||
#endif /* VSPRINTF_H */
|
||||
@ -1,145 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2018-2020 Atmosphère-NX
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms and conditions of the GNU General Public License,
|
||||
* version 2, as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "regs.h"
|
||||
#include "lib/printk.h"
|
||||
|
||||
/**
|
||||
* Switches to EL1, and then calls main_el1.
|
||||
* Implemented in assembly in entry.S.
|
||||
*/
|
||||
void switch_to_el1();
|
||||
|
||||
/**
|
||||
* C entry point for execution at EL1.
|
||||
*/
|
||||
void main_el1(void * fdt);
|
||||
|
||||
/**
|
||||
* Reference to the EL2 vector table.
|
||||
* Note that the type here isn't reprsentative-- we just need the address of the label.
|
||||
*/
|
||||
extern uint64_t el2_vector_table;
|
||||
|
||||
/**
|
||||
* Clear out the system's bss.
|
||||
*/
|
||||
void _clear_bss(void)
|
||||
{
|
||||
// These symbols don't actually have a meaningful type-- instead,
|
||||
// we care about the locations at which the linker /placed/ these
|
||||
// symbols, which happen to be at the start and end of the BSS.
|
||||
// We use chars here to make the math easy. :)
|
||||
extern char lds_bss_start, lds_bss_end;
|
||||
|
||||
memset(&lds_bss_start, 0, &lds_bss_end - &lds_bss_start);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Triggered on an unrecoverable condition; prints an error message
|
||||
* and terminates execution.
|
||||
*/
|
||||
void panic(const char * message)
|
||||
{
|
||||
printk("\n\n");
|
||||
printk("-----------------------------------------------------------------\n");
|
||||
printk("PANIC: %s\n", message);
|
||||
printk("-----------------------------------------------------------------\n");
|
||||
|
||||
// TODO: This should probably induce a reboot,
|
||||
// rather than sticking here.
|
||||
while(1);
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Launch an executable kernel image. Should be the last thing called by
|
||||
* Discharge, as it does not return.
|
||||
*
|
||||
* @param kernel The kernel to be executed.
|
||||
* @param fdt The device tree to be passed to the given kernel.
|
||||
*/
|
||||
void launch_kernel(const void *kernel)
|
||||
{
|
||||
// Construct a function pointer to our kernel, which will allow us to
|
||||
// jump there immediately. Note that we don't care what this leaves on
|
||||
// the stack, as either our entire stack will be ignored, or it'll
|
||||
// be torn down by the target kernel anyways.
|
||||
void (*target_kernel)(void) = kernel;
|
||||
|
||||
printk("Launching Horizon kernel...\n");
|
||||
target_kernel();
|
||||
}
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Core section of the stub-- sets up the hypervisor from up in EL2.
|
||||
*/
|
||||
int main(int argc, void **argv)
|
||||
{
|
||||
// Read the currrent execution level...
|
||||
uint32_t el = get_current_el();
|
||||
|
||||
/* Say hello. */
|
||||
printk("Welcome to Atmosph\xe8re Thermosph\xe8" "re!\n");
|
||||
printk("Running at EL%d.\n", el);
|
||||
|
||||
// ... and ensure we're in EL2.
|
||||
if (el != 2) {
|
||||
panic("Thermosph\xe8" "re must be launched from EL2!");
|
||||
}
|
||||
|
||||
// Set up the vector table for EL2, so that the HVC instruction can be used
|
||||
// from EL1. This allows us to return to EL2 after starting the EL1 guest.
|
||||
set_vbar_el2(&el2_vector_table);
|
||||
|
||||
// TODO:
|
||||
// Insert any setup you want done in EL2, here. For now, EL2 is set up
|
||||
// to do almost nothing-- it doesn't take control of any hardware,
|
||||
// and it hasn't set up any trap-to-hypervisor features.
|
||||
printk("\nSwitching to EL1...\n");
|
||||
switch_to_el1();
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Secondary section of the stub, executed once we've surrendered
|
||||
* hypervisor privileges.
|
||||
*/
|
||||
void main_el1(void * fdt)
|
||||
{
|
||||
int rc;
|
||||
(void)rc;
|
||||
|
||||
// Read the currrent execution level...
|
||||
uint32_t el = get_current_el();
|
||||
|
||||
// Validate that we're in EL1.
|
||||
printk("Now executing from EL%d!\n", el);
|
||||
if(el != 1) {
|
||||
panic("Executing with more privilege than we expect!");
|
||||
}
|
||||
|
||||
// If we've made it here, we failed to boot, and we can't recover.
|
||||
panic("We should launch Horizon here!");
|
||||
}
|
||||
@ -1,73 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2018-2020 Atmosphère-NX
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms and conditions of the GNU General Public License,
|
||||
* version 2, as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef __REGS_H__
|
||||
#define __REGS_H__
|
||||
|
||||
/**
|
||||
* Access to system registers.
|
||||
*/
|
||||
#define WRITE_SYSREG(sysreg, val, type) \
|
||||
asm volatile ("msr "#sysreg", %0\n" : : "r"((type)(val)))
|
||||
#define READ_SYSREG(sysreg, val, type) \
|
||||
asm volatile ("mrs %0, "#sysreg"\n" : "=r"((type)(val)))
|
||||
|
||||
#define READ_SYSREG_32(sysreg, val) READ_SYSREG(sysreg, val, uint32_t)
|
||||
#define WRITE_SYSREG_32(sysreg, val) WRITE_SYSREG(sysreg, val, uint32_t)
|
||||
|
||||
#define READ_SYSREG_64(sysreg, val) READ_SYSREG(sysreg, val, uint64_t)
|
||||
#define WRITE_SYSREG_64(sysreg, val) WRITE_SYSREG(sysreg, val, uint64_t)
|
||||
|
||||
|
||||
/**
|
||||
* Returns the system's current Execution Level (EL).
|
||||
*/
|
||||
inline static uint32_t get_current_el(void) {
|
||||
uint32_t val;
|
||||
|
||||
// Read the CurrentEl register, and extract the bits that tell us our EL.
|
||||
READ_SYSREG_32(CurrentEl, val);
|
||||
return val >> 2;
|
||||
}
|
||||
|
||||
/**
|
||||
* Sets the base address of the EL2 exception table.
|
||||
*/
|
||||
inline static void set_vbar_el2(void * address) {
|
||||
WRITE_SYSREG_64(vbar_el2, (uint64_t)address);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Sets the address to 'return to' when leaving EL2.
|
||||
*/
|
||||
inline static void set_elr_el2(void * address) {
|
||||
WRITE_SYSREG_64(elr_el2, (uint64_t)address);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Returns the MMU status bit from the SCTLR register.
|
||||
*/
|
||||
inline static uint32_t get_el2_mmu_status(void) {
|
||||
uint32_t val;
|
||||
|
||||
// Read the CurrentEl register, and extract the bits that tell us our EL.
|
||||
READ_SYSREG_32(sctlr_el2, val);
|
||||
return val & 1;
|
||||
}
|
||||
|
||||
#endif
|
||||
@ -1,263 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2018-2020 Atmosphère-NX
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms and conditions of the GNU General Public License,
|
||||
* version 2, as published by the Free Software Foundation.
|
||||
*
|
||||
* This program is distributed in the hope it will be useful, but WITHOUT
|
||||
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
||||
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
|
||||
* more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
.section ".text"
|
||||
.global _start
|
||||
|
||||
|
||||
/**
|
||||
* Simple macro to help with generating vector table entries.
|
||||
*/
|
||||
.macro ventry label
|
||||
.align 7
|
||||
b \label
|
||||
.endm
|
||||
|
||||
|
||||
/**
|
||||
* Start of day code. This is the first code that executes after we're launched
|
||||
* by the bootloader. We use this only to set up a C environment.
|
||||
*/
|
||||
_start:
|
||||
|
||||
// Create a simple stack for the hypervisor, while executing in EL2.
|
||||
ldr x1, =el2_stack_end
|
||||
mov sp, x1
|
||||
|
||||
// Clear out our binary's bss.
|
||||
stp x0, x1, [sp, #-16]!
|
||||
bl _clear_bss
|
||||
ldp x0, x1, [sp], #16
|
||||
|
||||
// Run the main routine. This shouldn't return.
|
||||
b main
|
||||
|
||||
// We shouldn't ever reach here; trap.
|
||||
1: b 1b
|
||||
|
||||
|
||||
/*
|
||||
* Vector table for interrupts/exceptions that reach EL2.
|
||||
*/
|
||||
.align 11
|
||||
.global el2_vector_table;
|
||||
el2_vector_table:
|
||||
ventry _unhandled_vector // Synchronous EL2t
|
||||
ventry _unhandled_vector // IRQ EL2t
|
||||
ventry _unhandled_vector // FIQ EL2t
|
||||
ventry _unhandled_vector // Error EL2t
|
||||
|
||||
ventry _unhandled_vector // Synchronous EL2h
|
||||
ventry _unhandled_vector // IRQ EL2h
|
||||
ventry _unhandled_vector // FIQ EL2h
|
||||
ventry _unhandled_vector // Error EL2h
|
||||
|
||||
ventry _handle_hypercall // Synchronous 64-bit EL0/EL1
|
||||
ventry _unhandled_vector // IRQ 64-bit EL0/EL1
|
||||
ventry _unhandled_vector // FIQ 64-bit EL0/EL1
|
||||
ventry _unhandled_vector // Error 64-bit EL0/EL1
|
||||
|
||||
ventry _unhandled_vector // Synchronous 32-bit EL0/EL1
|
||||
ventry _unhandled_vector // IRQ 32-bit EL0/EL1
|
||||
ventry _unhandled_vector // FIQ 32-bit EL0/EL1
|
||||
ventry _unhandled_vector // Error 32-bit EL0/EL1
|
||||
|
||||
|
||||
|
||||
/*
|
||||
* Switch down to EL1 and then execute the second half of our stub.
|
||||
* Implemented in assembly, as this manipulates the stack.
|
||||
*
|
||||
* Obliterates the stack, but leaves the rest of memory intact. This should be
|
||||
* fine, as we should be hiding the EL2 memory from the rest of the system.
|
||||
*
|
||||
* x0: The location of the device tree to be passed into EL0.
|
||||
*/
|
||||
.global switch_to_el1
|
||||
switch_to_el1:
|
||||
|
||||
// Set up a post-EL1-switch return address...
|
||||
ldr x2, =_post_el1_switch
|
||||
msr elr_el2, x2
|
||||
|
||||
// .. and set up the CPSR after we switch to EL1.
|
||||
// We overwrite the saved program status register. Note that setting
|
||||
// this with the EL = EL1 is what actually causes the switch.
|
||||
mov x2, #0x3c5 // EL1_SP1 | D | A | I | F
|
||||
msr spsr_el2, x2
|
||||
|
||||
// Reset the stack pointer to the very end of the stack, so it's
|
||||
// fresh and clean for when we jump back up into EL2.
|
||||
ldr x2, =el2_stack_end
|
||||
mov sp, x2
|
||||
|
||||
// ... and switch down to EL1. (This essentially asks the processor
|
||||
// to switch down to EL1 and then load ELR_EL2 to the PC.)
|
||||
eret
|
||||
|
||||
|
||||
/*
|
||||
* Entry point after the switch to EL1.
|
||||
*/
|
||||
.global _post_el1_switch
|
||||
_post_el1_switch:
|
||||
|
||||
// Create a simple stack for us to use while at EL1.
|
||||
// We use this temporarily to launch Horizon.
|
||||
ldr x2, =el1_stack_end
|
||||
mov sp, x2
|
||||
|
||||
// Run the main routine. This shouldn't return.
|
||||
b main_el1
|
||||
|
||||
// We shouldn't ever reach here; trap.
|
||||
1: b 1b
|
||||
|
||||
|
||||
/**
|
||||
* Push and pop 'psuedo-op' macros that simplify the ARM syntax to make the below pretty.
|
||||
*/
|
||||
.macro push, xreg1, xreg2
|
||||
stp \xreg1, \xreg2, [sp, #-16]!
|
||||
.endm
|
||||
.macro pop, xreg1, xreg2
|
||||
ldp \xreg1, \xreg2, [sp], #16
|
||||
.endm
|
||||
|
||||
/**
|
||||
* Macro that saves registers onto the stack when entering an exception handler--
|
||||
* effectively saving the guest state. Once this method is complete, *sp will
|
||||
* point to a struct guest_state.
|
||||
*
|
||||
* You can modify this to save whatever you'd like, but:
|
||||
* 1) We can only push in pairs due to armv8 architecture quirks.
|
||||
* 2) Be careful not to trounce registers until after you've saved them.
|
||||
* 3) r31 is your stack pointer, and doesn't need to be saved. You'll want to
|
||||
* save the lesser EL's stack pointers separately.
|
||||
* 4) Make sure any changes you make are reflected both in _restore_registers_
|
||||
* and in struct guest_state, or things will break pretty badly.
|
||||
*/
|
||||
.macro save_registers
|
||||
// General purpose registers x1 - x30
|
||||
push x29, x30
|
||||
push x27, x28
|
||||
push x25, x26
|
||||
push x23, x24
|
||||
push x21, x22
|
||||
push x19, x20
|
||||
push x17, x18
|
||||
push x15, x16
|
||||
push x13, x14
|
||||
push x11, x12
|
||||
push x9, x10
|
||||
push x7, x8
|
||||
push x5, x6
|
||||
push x3, x4
|
||||
push x1, x2
|
||||
|
||||
// x0 and the el2_esr
|
||||
mrs x20, esr_el2
|
||||
push x20, x0
|
||||
|
||||
// the el1_sp and el0_sp
|
||||
mrs x0, sp_el0
|
||||
mrs x1, sp_el1
|
||||
push x0, x1
|
||||
|
||||
// the el1 elr/spsr
|
||||
mrs x0, elr_el1
|
||||
mrs x1, spsr_el1
|
||||
push x0, x1
|
||||
|
||||
// the el2 elr/spsr
|
||||
mrs x0, elr_el2
|
||||
mrs x1, spsr_el2
|
||||
push x0, x1
|
||||
|
||||
.endm
|
||||
|
||||
/**
|
||||
* Macro that restores registers when returning from EL2.
|
||||
* Mirrors save_registers.
|
||||
*/
|
||||
.macro restore_registers
|
||||
// the el2 elr/spsr
|
||||
pop x0, x1
|
||||
msr elr_el2, x0
|
||||
msr spsr_el2, x1
|
||||
|
||||
// the el1 elr/spsr
|
||||
pop x0, x1
|
||||
msr elr_el1, x0
|
||||
msr spsr_el1, x1
|
||||
|
||||
// the el1_sp and el0_sp
|
||||
pop x0, x1
|
||||
msr sp_el0, x0
|
||||
msr sp_el1, x1
|
||||
|
||||
// x0, and the el2_esr
|
||||
// Note that we don't restore el2_esr, as this wouldn't
|
||||
// have any meaning.
|
||||
pop x20, x0
|
||||
|
||||
// General purpose registers x1 - x30
|
||||
pop x1, x2
|
||||
pop x3, x4
|
||||
pop x5, x6
|
||||
pop x7, x8
|
||||
pop x9, x10
|
||||
pop x11, x12
|
||||
pop x13, x14
|
||||
pop x15, x16
|
||||
pop x17, x18
|
||||
pop x19, x20
|
||||
pop x21, x22
|
||||
pop x23, x24
|
||||
pop x25, x26
|
||||
pop x27, x28
|
||||
pop x29, x30
|
||||
.endm
|
||||
|
||||
/*
|
||||
* Handler for any vector we're not equipped to handle.
|
||||
*/
|
||||
_unhandled_vector:
|
||||
// TODO: Save interrupt state and turn off interrupts.
|
||||
save_registers
|
||||
|
||||
// Point x0 at our saved registers, and then call our C handler.
|
||||
mov x0, sp
|
||||
bl unhandled_vector
|
||||
|
||||
restore_registers
|
||||
eret
|
||||
|
||||
|
||||
/*
|
||||
* Handler for any synchronous event coming from the guest (any trap-to-EL2).
|
||||
* This _stub_ only uses this to handle hypercalls-- hence the name.
|
||||
*/
|
||||
_handle_hypercall:
|
||||
// TODO: Save interrupt state and turn off interrupts.
|
||||
save_registers
|
||||
|
||||
// Point x0 at our saved registers, and then call our C handler.
|
||||
mov x0, sp
|
||||
bl handle_hypercall
|
||||
|
||||
restore_registers
|
||||
eret
|
||||
Loading…
Reference in New Issue
Block a user