diff options
Diffstat (limited to '')
61 files changed, 4754 insertions, 12884 deletions
@@ -3,45 +3,88 @@ .PHONY: build fmt clean qemu .SILENT: +AS ?= as +CC ?= cc +LD ?= ld +CPP ?= cpp + +CPPFLAGS += -Ikernel/include + +CFLAGS += -O0 +CFLAGS += -std=c11 +CFLAGS += -Wall -Wextra -pedantic +CFLAGS += -fno-pie -fno-stack-protector +CFLAGS += -fno-omit-frame-pointer -ffreestanding +CFLAGS += -fno-builtin +CFLAGS += -D DEBUG -g +CFLAGS += $(CPPFLAGS) + +LDFLAGS += -nmagic --no-warn-rwx-segments -nostdlib -E + +SRC=kernel +BIN=bin +KERNEL=kernel.bin +ISO=os.iso + +H_SRC = $(shell find $(SRC) -type f -name "*.h") +A_SRC = $(shell find $(SRC) -type f -name "*.S") +A_OBJ = $(patsubst %.S,$(BIN)/%.S.o,$(A_SRC)) +C_SRC = $(shell find $(SRC) -type f -name "*.c") +C_OBJ = $(patsubst %.c,$(BIN)/%.o,$(C_SRC)) + UNAME := $(shell uname) QEMU = qemu-system-x86_64 -QEMUOPTS = -cdrom bin/os.iso \ +QEMUOPTS = -cdrom $(BIN)/$(ISO) \ -no-reboot \ -serial mon:stdio \ -m 4G \ -name kern -qemu: bin/os.iso +qemu: $(BIN)/$(ISO) $(QEMU) $(QEMUOPTS) -qemu-kvm: bin/os.iso +qemu-kvm: $(BIN)/$(ISO) $(QEMU) -cpu host --enable-kvm $(QEMUOPTS) -qemu-nox: bin/os.iso +qemu-nox: $(BIN)/$(ISO) $(QEMU) $(QEMUOPTS) -nographic -qemu-gdb: bin/os.iso +qemu-gdb: $(BIN)/$(ISO) $(QEMU) $(QEMUOPTS) -S -gdb tcp::1337 -qemu-gdb-nox: bin/os.iso +qemu-gdb-nox: $(BIN)/$(ISO) $(QEMU) $(QEMUOPTS) -nographic -S -gdb tcp::1337 gdb: gdb -q -n -x config/gdbinit clean: - rm -fr .zig-cache - rm -fr bin + rm -fr $(BIN) + +build: $(BIN)/$(ISO) + +$(A_OBJ): $(BIN)/%.S.o : %.S + mkdir -p $(@D) + printf "\033[33m AS \033[0m%s\n" $< + $(CPP) $(CPPFLAGS) -o $@.cpp $< + $(AS) -o $@ $@.cpp + +$(C_OBJ): $(BIN)/%.o : %.c + mkdir -p $(@D) + printf "\033[34m CC \033[0m%s\n" $< + $(CC) -c $(CFLAGS) -o $@ $< -build: - zig build +$(BIN)/$(KERNEL): $(C_OBJ) $(A_OBJ) + mkdir -p $(@D) + printf "\033[32m LD \033[0m%s\n" $@ + $(LD) $(LDFLAGS) -T config/kernel.ld -o $(BIN)/$(KERNEL) $(A_OBJ) $(C_OBJ) -bin/os.iso: build - mkdir -p bin/iso/boot/grub - cp config/grub.cfg bin/iso/boot/grub - cp bin/kernel bin/iso/boot - grub-mkrescue -o bin/os.iso bin/iso 2>/dev/null +$(BIN)/$(ISO): $(BIN)/$(KERNEL) + mkdir -p $(BIN)/iso/boot/grub + cp config/grub.cfg $(BIN)/iso/boot/grub + cp $(BIN)/$(KERNEL) $(BIN)/iso/boot + grub-mkrescue -o $(BIN)/$(ISO) bin/iso 2>/dev/null fmt: clang-format -i $(shell find -type f -name "*.[ch]" -and -not -path "./kernel/old/*") @@ -67,6 +67,7 @@ const kernel_src = &[_][]const u8{ "kernel/lib/strtox.c", "kernel/lib/uxtoa.c", "kernel/lib/xtoa.c", + "kernel/mboot/elf.c", "kernel/mboot/mboot.c", "kernel/mboot/mmap.c", "kernel/mboot/rsdp.c", @@ -185,7 +186,7 @@ pub fn build(b: *std.Build) !void { .abi = std.Target.Abi.gnu, .ofmt = std.Target.ObjectFormat.elf, }); - const optimize = std.builtin.OptimizeMode.ReleaseFast; + const optimize = std.builtin.OptimizeMode.Debug; // kernel build_kern_binary(b, .{ diff --git a/config/grub.cfg b/config/grub.cfg index 6cedb28..0157d85 100644 --- a/config/grub.cfg +++ b/config/grub.cfg @@ -4,6 +4,6 @@ terminal_input at_keyboard termianl_output console menuentry "kern" { - multiboot2 /boot/kernel + multiboot2 /boot/kernel.bin boot } diff --git a/config/kernel.ld b/config/kernel.ld index 0806257..52e9088 100644 --- a/config/kernel.ld +++ b/config/kernel.ld @@ -33,4 +33,8 @@ SECTIONS } kernel_end = .; + + /DISCARD/ : { + *(.eh_frame .note.GNU-stack .note.gnu.property .comment) + } } diff --git a/kernel/entry.S b/kernel/entry.S index 997e400..0610495 100644 --- a/kernel/entry.S +++ b/kernel/entry.S @@ -9,15 +9,26 @@ .extern GDT .section .multiboot - .align 8 # multiboot header mb_start: + .align 8 # magic .long 0xe85250d6 .long 0 .long mb_end - mb_start .long 0x100000000 - (0xe85250d6 + (mb_end - mb_start)) +mbi_start: + .align 8 + # info request + .short 1 + .short 1 + .long mbi_end - mbi_start + .long 1 # cmdline + .long 6 # mmap + .long 9 # elf section +mbi_end: + .align 8 # null .short 0 .short 0 diff --git a/kernel/font.S b/kernel/font.S index f125e90..571876b 100644 --- a/kernel/font.S +++ b/kernel/font.S @@ -4,4 +4,4 @@ .align 8 en_font: - .incbin "../../font/default8x16.psfu" + .incbin "font/default8x16.psfu" diff --git a/kernel/include/comus/mboot.h b/kernel/include/comus/mboot.h index ebd5dad..59d2d12 100644 --- a/kernel/include/comus/mboot.h +++ b/kernel/include/comus/mboot.h @@ -26,4 +26,9 @@ int mboot_get_mmap(struct memory_map *map); */ void *mboot_get_rsdp(void); +/** + * Get elf symbols from multiboot + */ +const char *mboot_get_elf_sym(uint64_t addr); + #endif /* mboot.h */ diff --git a/kernel/include/elf.h b/kernel/include/elf.h new file mode 100644 index 0000000..b7e6059 --- /dev/null +++ b/kernel/include/elf.h @@ -0,0 +1,4585 @@ +/* This file defines standard ELF types, structures, and macros. + Copyright (C) 1995-2025 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + <https://www.gnu.org/licenses/>. */ + +#ifndef _ELF_H +#define _ELF_H 1 + +/* Standard ELF types. */ + +#include <stdint.h> + +/* Type for a 16-bit quantity. */ +typedef uint16_t Elf32_Half; +typedef uint16_t Elf64_Half; + +/* Types for signed and unsigned 32-bit quantities. */ +typedef uint32_t Elf32_Word; +typedef int32_t Elf32_Sword; +typedef uint32_t Elf64_Word; +typedef int32_t Elf64_Sword; + +/* Types for signed and unsigned 64-bit quantities. */ +typedef uint64_t Elf32_Xword; +typedef int64_t Elf32_Sxword; +typedef uint64_t Elf64_Xword; +typedef int64_t Elf64_Sxword; + +/* Type of addresses. */ +typedef uint32_t Elf32_Addr; +typedef uint64_t Elf64_Addr; + +/* Type of file offsets. */ +typedef uint32_t Elf32_Off; +typedef uint64_t Elf64_Off; + +/* Type for section indices, which are 16-bit quantities. */ +typedef uint16_t Elf32_Section; +typedef uint16_t Elf64_Section; + +/* Type for version symbol information. */ +typedef Elf32_Half Elf32_Versym; +typedef Elf64_Half Elf64_Versym; + +/* The ELF file header. This appears at the start of every ELF file. */ + +#define EI_NIDENT (16) + +typedef struct { + unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */ + Elf32_Half e_type; /* Object file type */ + Elf32_Half e_machine; /* Architecture */ + Elf32_Word e_version; /* Object file version */ + Elf32_Addr e_entry; /* Entry point virtual address */ + Elf32_Off e_phoff; /* Program header table file offset */ + Elf32_Off e_shoff; /* Section header table file offset */ + Elf32_Word e_flags; /* Processor-specific flags */ + Elf32_Half e_ehsize; /* ELF header size in bytes */ + Elf32_Half e_phentsize; /* Program header table entry size */ + Elf32_Half e_phnum; /* Program header table entry count */ + Elf32_Half e_shentsize; /* Section header table entry size */ + Elf32_Half e_shnum; /* Section header table entry count */ + Elf32_Half e_shstrndx; /* Section header string table index */ +} Elf32_Ehdr; + +typedef struct { + unsigned char e_ident[EI_NIDENT]; /* Magic number and other info */ + Elf64_Half e_type; /* Object file type */ + Elf64_Half e_machine; /* Architecture */ + Elf64_Word e_version; /* Object file version */ + Elf64_Addr e_entry; /* Entry point virtual address */ + Elf64_Off e_phoff; /* Program header table file offset */ + Elf64_Off e_shoff; /* Section header table file offset */ + Elf64_Word e_flags; /* Processor-specific flags */ + Elf64_Half e_ehsize; /* ELF header size in bytes */ + Elf64_Half e_phentsize; /* Program header table entry size */ + Elf64_Half e_phnum; /* Program header table entry count */ + Elf64_Half e_shentsize; /* Section header table entry size */ + Elf64_Half e_shnum; /* Section header table entry count */ + Elf64_Half e_shstrndx; /* Section header string table index */ +} Elf64_Ehdr; + +/* Fields in the e_ident array. The EI_* macros are indices into the + array. The macros under each EI_* macro are the values the byte + may have. */ + +#define EI_MAG0 0 /* File identification byte 0 index */ +#define ELFMAG0 0x7f /* Magic number byte 0 */ + +#define EI_MAG1 1 /* File identification byte 1 index */ +#define ELFMAG1 'E' /* Magic number byte 1 */ + +#define EI_MAG2 2 /* File identification byte 2 index */ +#define ELFMAG2 'L' /* Magic number byte 2 */ + +#define EI_MAG3 3 /* File identification byte 3 index */ +#define ELFMAG3 'F' /* Magic number byte 3 */ + +/* Conglomeration of the identification bytes, for easy testing as a word. */ +#define ELFMAG "\177ELF" +#define SELFMAG 4 + +#define EI_CLASS 4 /* File class byte index */ +#define ELFCLASSNONE 0 /* Invalid class */ +#define ELFCLASS32 1 /* 32-bit objects */ +#define ELFCLASS64 2 /* 64-bit objects */ +#define ELFCLASSNUM 3 + +#define EI_DATA 5 /* Data encoding byte index */ +#define ELFDATANONE 0 /* Invalid data encoding */ +#define ELFDATA2LSB 1 /* 2's complement, little endian */ +#define ELFDATA2MSB 2 /* 2's complement, big endian */ +#define ELFDATANUM 3 + +#define EI_VERSION 6 /* File version byte index */ +/* Value must be EV_CURRENT */ + +#define EI_OSABI 7 /* OS ABI identification */ +#define ELFOSABI_NONE 0 /* UNIX System V ABI */ +#define ELFOSABI_SYSV 0 /* Alias. */ +#define ELFOSABI_HPUX 1 /* HP-UX */ +#define ELFOSABI_NETBSD 2 /* NetBSD. */ +#define ELFOSABI_GNU 3 /* Object uses GNU ELF extensions. */ +#define ELFOSABI_LINUX ELFOSABI_GNU /* Compatibility alias. */ +#define ELFOSABI_SOLARIS 6 /* Sun Solaris. */ +#define ELFOSABI_AIX 7 /* IBM AIX. */ +#define ELFOSABI_IRIX 8 /* SGI Irix. */ +#define ELFOSABI_FREEBSD 9 /* FreeBSD. */ +#define ELFOSABI_TRU64 10 /* Compaq TRU64 UNIX. */ +#define ELFOSABI_MODESTO 11 /* Novell Modesto. */ +#define ELFOSABI_OPENBSD 12 /* OpenBSD. */ +#define ELFOSABI_ARM_AEABI 64 /* ARM EABI */ +#define ELFOSABI_ARM 97 /* ARM */ +#define ELFOSABI_STANDALONE 255 /* Standalone (embedded) application */ + +#define EI_ABIVERSION 8 /* ABI version */ + +#define EI_PAD 9 /* Byte index of padding bytes */ + +/* Legal values for e_type (object file type). */ + +#define ET_NONE 0 /* No file type */ +#define ET_REL 1 /* Relocatable file */ +#define ET_EXEC 2 /* Executable file */ +#define ET_DYN 3 /* Shared object file */ +#define ET_CORE 4 /* Core file */ +#define ET_NUM 5 /* Number of defined types */ +#define ET_LOOS 0xfe00 /* OS-specific range start */ +#define ET_HIOS 0xfeff /* OS-specific range end */ +#define ET_LOPROC 0xff00 /* Processor-specific range start */ +#define ET_HIPROC 0xffff /* Processor-specific range end */ + +/* Legal values for e_machine (architecture). */ + +#define EM_NONE 0 /* No machine */ +#define EM_M32 1 /* AT&T WE 32100 */ +#define EM_SPARC 2 /* SUN SPARC */ +#define EM_386 3 /* Intel 80386 */ +#define EM_68K 4 /* Motorola m68k family */ +#define EM_88K 5 /* Motorola m88k family */ +#define EM_IAMCU 6 /* Intel MCU */ +#define EM_860 7 /* Intel 80860 */ +#define EM_MIPS 8 /* MIPS R3000 big-endian */ +#define EM_S370 9 /* IBM System/370 */ +#define EM_MIPS_RS3_LE 10 /* MIPS R3000 little-endian */ +/* reserved 11-14 */ +#define EM_PARISC 15 /* HPPA */ +/* reserved 16 */ +#define EM_VPP500 17 /* Fujitsu VPP500 */ +#define EM_SPARC32PLUS 18 /* Sun's "v8plus" */ +#define EM_960 19 /* Intel 80960 */ +#define EM_PPC 20 /* PowerPC */ +#define EM_PPC64 21 /* PowerPC 64-bit */ +#define EM_S390 22 /* IBM S390 */ +#define EM_SPU 23 /* IBM SPU/SPC */ +/* reserved 24-35 */ +#define EM_V800 36 /* NEC V800 series */ +#define EM_FR20 37 /* Fujitsu FR20 */ +#define EM_RH32 38 /* TRW RH-32 */ +#define EM_RCE 39 /* Motorola RCE */ +#define EM_ARM 40 /* ARM */ +#define EM_FAKE_ALPHA 41 /* Digital Alpha */ +#define EM_SH 42 /* Hitachi SH */ +#define EM_SPARCV9 43 /* SPARC v9 64-bit */ +#define EM_TRICORE 44 /* Siemens Tricore */ +#define EM_ARC 45 /* Argonaut RISC Core */ +#define EM_H8_300 46 /* Hitachi H8/300 */ +#define EM_H8_300H 47 /* Hitachi H8/300H */ +#define EM_H8S 48 /* Hitachi H8S */ +#define EM_H8_500 49 /* Hitachi H8/500 */ +#define EM_IA_64 50 /* Intel Merced */ +#define EM_MIPS_X 51 /* Stanford MIPS-X */ +#define EM_COLDFIRE 52 /* Motorola Coldfire */ +#define EM_68HC12 53 /* Motorola M68HC12 */ +#define EM_MMA 54 /* Fujitsu MMA Multimedia Accelerator */ +#define EM_PCP 55 /* Siemens PCP */ +#define EM_NCPU 56 /* Sony nCPU embedded RISC */ +#define EM_NDR1 57 /* Denso NDR1 microprocessor */ +#define EM_STARCORE 58 /* Motorola Start*Core processor */ +#define EM_ME16 59 /* Toyota ME16 processor */ +#define EM_ST100 60 /* STMicroelectronic ST100 processor */ +#define EM_TINYJ 61 /* Advanced Logic Corp. Tinyj emb.fam */ +#define EM_X86_64 62 /* AMD x86-64 architecture */ +#define EM_PDSP 63 /* Sony DSP Processor */ +#define EM_PDP10 64 /* Digital PDP-10 */ +#define EM_PDP11 65 /* Digital PDP-11 */ +#define EM_FX66 66 /* Siemens FX66 microcontroller */ +#define EM_ST9PLUS 67 /* STMicroelectronics ST9+ 8/16 mc */ +#define EM_ST7 68 /* STmicroelectronics ST7 8 bit mc */ +#define EM_68HC16 69 /* Motorola MC68HC16 microcontroller */ +#define EM_68HC11 70 /* Motorola MC68HC11 microcontroller */ +#define EM_68HC08 71 /* Motorola MC68HC08 microcontroller */ +#define EM_68HC05 72 /* Motorola MC68HC05 microcontroller */ +#define EM_SVX 73 /* Silicon Graphics SVx */ +#define EM_ST19 74 /* STMicroelectronics ST19 8 bit mc */ +#define EM_VAX 75 /* Digital VAX */ +#define EM_CRIS 76 /* Axis Communications 32-bit emb.proc */ +#define EM_JAVELIN 77 /* Infineon Technologies 32-bit emb.proc */ +#define EM_FIREPATH 78 /* Element 14 64-bit DSP Processor */ +#define EM_ZSP 79 /* LSI Logic 16-bit DSP Processor */ +#define EM_MMIX 80 /* Donald Knuth's educational 64-bit proc */ +#define EM_HUANY 81 /* Harvard University machine-independent object files */ +#define EM_PRISM 82 /* SiTera Prism */ +#define EM_AVR 83 /* Atmel AVR 8-bit microcontroller */ +#define EM_FR30 84 /* Fujitsu FR30 */ +#define EM_D10V 85 /* Mitsubishi D10V */ +#define EM_D30V 86 /* Mitsubishi D30V */ +#define EM_V850 87 /* NEC v850 */ +#define EM_M32R 88 /* Mitsubishi M32R */ +#define EM_MN10300 89 /* Matsushita MN10300 */ +#define EM_MN10200 90 /* Matsushita MN10200 */ +#define EM_PJ 91 /* picoJava */ +#define EM_OPENRISC 92 /* OpenRISC 32-bit embedded processor */ +#define EM_ARC_COMPACT 93 /* ARC International ARCompact */ +#define EM_XTENSA 94 /* Tensilica Xtensa Architecture */ +#define EM_VIDEOCORE 95 /* Alphamosaic VideoCore */ +#define EM_TMM_GPP 96 /* Thompson Multimedia General Purpose Proc */ +#define EM_NS32K 97 /* National Semi. 32000 */ +#define EM_TPC 98 /* Tenor Network TPC */ +#define EM_SNP1K 99 /* Trebia SNP 1000 */ +#define EM_ST200 100 /* STMicroelectronics ST200 */ +#define EM_IP2K 101 /* Ubicom IP2xxx */ +#define EM_MAX 102 /* MAX processor */ +#define EM_CR 103 /* National Semi. CompactRISC */ +#define EM_F2MC16 104 /* Fujitsu F2MC16 */ +#define EM_MSP430 105 /* Texas Instruments msp430 */ +#define EM_BLACKFIN 106 /* Analog Devices Blackfin DSP */ +#define EM_SE_C33 107 /* Seiko Epson S1C33 family */ +#define EM_SEP 108 /* Sharp embedded microprocessor */ +#define EM_ARCA 109 /* Arca RISC */ +#define EM_UNICORE 110 /* PKU-Unity & MPRC Peking Uni. mc series */ +#define EM_EXCESS 111 /* eXcess configurable cpu */ +#define EM_DXP 112 /* Icera Semi. Deep Execution Processor */ +#define EM_ALTERA_NIOS2 113 /* Altera Nios II */ +#define EM_CRX 114 /* National Semi. CompactRISC CRX */ +#define EM_XGATE 115 /* Motorola XGATE */ +#define EM_C166 116 /* Infineon C16x/XC16x */ +#define EM_M16C 117 /* Renesas M16C */ +#define EM_DSPIC30F 118 /* Microchip Technology dsPIC30F */ +#define EM_CE 119 /* Freescale Communication Engine RISC */ +#define EM_M32C 120 /* Renesas M32C */ +/* reserved 121-130 */ +#define EM_TSK3000 131 /* Altium TSK3000 */ +#define EM_RS08 132 /* Freescale RS08 */ +#define EM_SHARC 133 /* Analog Devices SHARC family */ +#define EM_ECOG2 134 /* Cyan Technology eCOG2 */ +#define EM_SCORE7 135 /* Sunplus S+core7 RISC */ +#define EM_DSP24 136 /* New Japan Radio (NJR) 24-bit DSP */ +#define EM_VIDEOCORE3 137 /* Broadcom VideoCore III */ +#define EM_LATTICEMICO32 138 /* RISC for Lattice FPGA */ +#define EM_SE_C17 139 /* Seiko Epson C17 */ +#define EM_TI_C6000 140 /* Texas Instruments TMS320C6000 DSP */ +#define EM_TI_C2000 141 /* Texas Instruments TMS320C2000 DSP */ +#define EM_TI_C5500 142 /* Texas Instruments TMS320C55x DSP */ +#define EM_TI_ARP32 143 /* Texas Instruments App. Specific RISC */ +#define EM_TI_PRU 144 /* Texas Instruments Prog. Realtime Unit */ +/* reserved 145-159 */ +#define EM_MMDSP_PLUS 160 /* STMicroelectronics 64bit VLIW DSP */ +#define EM_CYPRESS_M8C 161 /* Cypress M8C */ +#define EM_R32C 162 /* Renesas R32C */ +#define EM_TRIMEDIA 163 /* NXP Semi. TriMedia */ +#define EM_QDSP6 164 /* QUALCOMM DSP6 */ +#define EM_8051 165 /* Intel 8051 and variants */ +#define EM_STXP7X 166 /* STMicroelectronics STxP7x */ +#define EM_NDS32 167 /* Andes Tech. compact code emb. RISC */ +#define EM_ECOG1X 168 /* Cyan Technology eCOG1X */ +#define EM_MAXQ30 169 /* Dallas Semi. MAXQ30 mc */ +#define EM_XIMO16 170 /* New Japan Radio (NJR) 16-bit DSP */ +#define EM_MANIK 171 /* M2000 Reconfigurable RISC */ +#define EM_CRAYNV2 172 /* Cray NV2 vector architecture */ +#define EM_RX 173 /* Renesas RX */ +#define EM_METAG 174 /* Imagination Tech. META */ +#define EM_MCST_ELBRUS 175 /* MCST Elbrus */ +#define EM_ECOG16 176 /* Cyan Technology eCOG16 */ +#define EM_CR16 177 /* National Semi. CompactRISC CR16 */ +#define EM_ETPU 178 /* Freescale Extended Time Processing Unit */ +#define EM_SLE9X 179 /* Infineon Tech. SLE9X */ +#define EM_L10M 180 /* Intel L10M */ +#define EM_K10M 181 /* Intel K10M */ +/* reserved 182 */ +#define EM_AARCH64 183 /* ARM AARCH64 */ +/* reserved 184 */ +#define EM_AVR32 185 /* Amtel 32-bit microprocessor */ +#define EM_STM8 186 /* STMicroelectronics STM8 */ +#define EM_TILE64 187 /* Tilera TILE64 */ +#define EM_TILEPRO 188 /* Tilera TILEPro */ +#define EM_MICROBLAZE 189 /* Xilinx MicroBlaze */ +#define EM_CUDA 190 /* NVIDIA CUDA */ +#define EM_TILEGX 191 /* Tilera TILE-Gx */ +#define EM_CLOUDSHIELD 192 /* CloudShield */ +#define EM_COREA_1ST 193 /* KIPO-KAIST Core-A 1st gen. */ +#define EM_COREA_2ND 194 /* KIPO-KAIST Core-A 2nd gen. */ +#define EM_ARCV2 195 /* Synopsys ARCv2 ISA. */ +#define EM_OPEN8 196 /* Open8 RISC */ +#define EM_RL78 197 /* Renesas RL78 */ +#define EM_VIDEOCORE5 198 /* Broadcom VideoCore V */ +#define EM_78KOR 199 /* Renesas 78KOR */ +#define EM_56800EX 200 /* Freescale 56800EX DSC */ +#define EM_BA1 201 /* Beyond BA1 */ +#define EM_BA2 202 /* Beyond BA2 */ +#define EM_XCORE 203 /* XMOS xCORE */ +#define EM_MCHP_PIC 204 /* Microchip 8-bit PIC(r) */ +#define EM_INTELGT 205 /* Intel Graphics Technology */ +/* reserved 206-209 */ +#define EM_KM32 210 /* KM211 KM32 */ +#define EM_KMX32 211 /* KM211 KMX32 */ +#define EM_EMX16 212 /* KM211 KMX16 */ +#define EM_EMX8 213 /* KM211 KMX8 */ +#define EM_KVARC 214 /* KM211 KVARC */ +#define EM_CDP 215 /* Paneve CDP */ +#define EM_COGE 216 /* Cognitive Smart Memory Processor */ +#define EM_COOL 217 /* Bluechip CoolEngine */ +#define EM_NORC 218 /* Nanoradio Optimized RISC */ +#define EM_CSR_KALIMBA 219 /* CSR Kalimba */ +#define EM_Z80 220 /* Zilog Z80 */ +#define EM_VISIUM 221 /* Controls and Data Services VISIUMcore */ +#define EM_FT32 222 /* FTDI Chip FT32 */ +#define EM_MOXIE 223 /* Moxie processor */ +#define EM_AMDGPU 224 /* AMD GPU */ +/* reserved 225-242 */ +#define EM_RISCV 243 /* RISC-V */ + +#define EM_BPF 247 /* Linux BPF -- in-kernel virtual machine */ +#define EM_CSKY 252 /* C-SKY */ +#define EM_LOONGARCH 258 /* LoongArch */ + +#define EM_NUM 259 + +/* Old spellings/synonyms. */ + +#define EM_ARC_A5 EM_ARC_COMPACT + +/* If it is necessary to assign new unofficial EM_* values, please + pick large random numbers (0x8523, 0xa7f2, etc.) to minimize the + chances of collision with official or non-GNU unofficial values. */ + +#define EM_ALPHA 0x9026 + +/* Legal values for e_version (version). */ + +#define EV_NONE 0 /* Invalid ELF version */ +#define EV_CURRENT 1 /* Current version */ +#define EV_NUM 2 + +/* Section header. */ + +typedef struct { + Elf32_Word sh_name; /* Section name (string tbl index) */ + Elf32_Word sh_type; /* Section type */ + Elf32_Word sh_flags; /* Section flags */ + Elf32_Addr sh_addr; /* Section virtual addr at execution */ + Elf32_Off sh_offset; /* Section file offset */ + Elf32_Word sh_size; /* Section size in bytes */ + Elf32_Word sh_link; /* Link to another section */ + Elf32_Word sh_info; /* Additional section information */ + Elf32_Word sh_addralign; /* Section alignment */ + Elf32_Word sh_entsize; /* Entry size if section holds table */ +} Elf32_Shdr; + +typedef struct { + Elf64_Word sh_name; /* Section name (string tbl index) */ + Elf64_Word sh_type; /* Section type */ + Elf64_Xword sh_flags; /* Section flags */ + Elf64_Addr sh_addr; /* Section virtual addr at execution */ + Elf64_Off sh_offset; /* Section file offset */ + Elf64_Xword sh_size; /* Section size in bytes */ + Elf64_Word sh_link; /* Link to another section */ + Elf64_Word sh_info; /* Additional section information */ + Elf64_Xword sh_addralign; /* Section alignment */ + Elf64_Xword sh_entsize; /* Entry size if section holds table */ +} Elf64_Shdr; + +/* Special section indices. */ + +#define SHN_UNDEF 0 /* Undefined section */ +#define SHN_LORESERVE 0xff00 /* Start of reserved indices */ +#define SHN_LOPROC 0xff00 /* Start of processor-specific */ +#define SHN_BEFORE \ + 0xff00 /* Order section before all others + (Solaris). */ +#define SHN_AFTER \ + 0xff01 /* Order section after all others + (Solaris). */ +#define SHN_HIPROC 0xff1f /* End of processor-specific */ +#define SHN_LOOS 0xff20 /* Start of OS-specific */ +#define SHN_HIOS 0xff3f /* End of OS-specific */ +#define SHN_ABS 0xfff1 /* Associated symbol is absolute */ +#define SHN_COMMON 0xfff2 /* Associated symbol is common */ +#define SHN_XINDEX 0xffff /* Index is in extra table. */ +#define SHN_HIRESERVE 0xffff /* End of reserved indices */ + +/* Legal values for sh_type (section type). */ + +#define SHT_NULL 0 /* Section header table entry unused */ +#define SHT_PROGBITS 1 /* Program data */ +#define SHT_SYMTAB 2 /* Symbol table */ +#define SHT_STRTAB 3 /* String table */ +#define SHT_RELA 4 /* Relocation entries with addends */ +#define SHT_HASH 5 /* Symbol hash table */ +#define SHT_DYNAMIC 6 /* Dynamic linking information */ +#define SHT_NOTE 7 /* Notes */ +#define SHT_NOBITS 8 /* Program space with no data (bss) */ +#define SHT_REL 9 /* Relocation entries, no addends */ +#define SHT_SHLIB 10 /* Reserved */ +#define SHT_DYNSYM 11 /* Dynamic linker symbol table */ +#define SHT_INIT_ARRAY 14 /* Array of constructors */ +#define SHT_FINI_ARRAY 15 /* Array of destructors */ +#define SHT_PREINIT_ARRAY 16 /* Array of pre-constructors */ +#define SHT_GROUP 17 /* Section group */ +#define SHT_SYMTAB_SHNDX 18 /* Extended section indices */ +#define SHT_RELR 19 /* RELR relative relocations */ +#define SHT_NUM 20 /* Number of defined types. */ +#define SHT_LOOS 0x60000000 /* Start OS-specific. */ +#define SHT_GNU_ATTRIBUTES 0x6ffffff5 /* Object attributes. */ +#define SHT_GNU_HASH 0x6ffffff6 /* GNU-style hash table. */ +#define SHT_GNU_LIBLIST 0x6ffffff7 /* Prelink library list */ +#define SHT_CHECKSUM 0x6ffffff8 /* Checksum for DSO content. */ +#define SHT_LOSUNW 0x6ffffffa /* Sun-specific low bound. */ +#define SHT_SUNW_move 0x6ffffffa +#define SHT_SUNW_COMDAT 0x6ffffffb +#define SHT_SUNW_syminfo 0x6ffffffc +#define SHT_GNU_verdef 0x6ffffffd /* Version definition section. */ +#define SHT_GNU_verneed 0x6ffffffe /* Version needs section. */ +#define SHT_GNU_versym 0x6fffffff /* Version symbol table. */ +#define SHT_HISUNW 0x6fffffff /* Sun-specific high bound. */ +#define SHT_HIOS 0x6fffffff /* End OS-specific type */ +#define SHT_LOPROC 0x70000000 /* Start of processor-specific */ +#define SHT_HIPROC 0x7fffffff /* End of processor-specific */ +#define SHT_LOUSER 0x80000000 /* Start of application-specific */ +#define SHT_HIUSER 0x8fffffff /* End of application-specific */ + +/* Legal values for sh_flags (section flags). */ + +#define SHF_WRITE (1 << 0) /* Writable */ +#define SHF_ALLOC (1 << 1) /* Occupies memory during execution */ +#define SHF_EXECINSTR (1 << 2) /* Executable */ +#define SHF_MERGE (1 << 4) /* Might be merged */ +#define SHF_STRINGS (1 << 5) /* Contains nul-terminated strings */ +#define SHF_INFO_LINK (1 << 6) /* `sh_info' contains SHT index */ +#define SHF_LINK_ORDER (1 << 7) /* Preserve order after combining */ +#define SHF_OS_NONCONFORMING \ + (1 << 8) /* Non-standard OS specific handling + required */ +#define SHF_GROUP (1 << 9) /* Section is member of a group. */ +#define SHF_TLS (1 << 10) /* Section hold thread-local data. */ +#define SHF_COMPRESSED (1 << 11) /* Section with compressed data. */ +#define SHF_MASKOS 0x0ff00000 /* OS-specific. */ +#define SHF_MASKPROC 0xf0000000 /* Processor-specific */ +#define SHF_GNU_RETAIN (1 << 21) /* Not to be GCed by linker. */ +#define SHF_ORDERED \ + (1 << 30) /* Special ordering requirement + (Solaris). */ +#define SHF_EXCLUDE \ + (1U << 31) /* Section is excluded unless + referenced or allocated (Solaris).*/ + +/* Section compression header. Used when SHF_COMPRESSED is set. */ + +typedef struct { + Elf32_Word ch_type; /* Compression format. */ + Elf32_Word ch_size; /* Uncompressed data size. */ + Elf32_Word ch_addralign; /* Uncompressed data alignment. */ +} Elf32_Chdr; + +typedef struct { + Elf64_Word ch_type; /* Compression format. */ + Elf64_Word ch_reserved; + Elf64_Xword ch_size; /* Uncompressed data size. */ + Elf64_Xword ch_addralign; /* Uncompressed data alignment. */ +} Elf64_Chdr; + +/* Legal values for ch_type (compression algorithm). */ +#define ELFCOMPRESS_ZLIB 1 /* ZLIB/DEFLATE algorithm. */ +#define ELFCOMPRESS_ZSTD 2 /* Zstandard algorithm. */ +#define ELFCOMPRESS_LOOS 0x60000000 /* Start of OS-specific. */ +#define ELFCOMPRESS_HIOS 0x6fffffff /* End of OS-specific. */ +#define ELFCOMPRESS_LOPROC 0x70000000 /* Start of processor-specific. */ +#define ELFCOMPRESS_HIPROC 0x7fffffff /* End of processor-specific. */ + +/* Section group handling. */ +#define GRP_COMDAT 0x1 /* Mark group as COMDAT. */ + +/* Symbol table entry. */ + +typedef struct { + Elf32_Word st_name; /* Symbol name (string tbl index) */ + Elf32_Addr st_value; /* Symbol value */ + Elf32_Word st_size; /* Symbol size */ + unsigned char st_info; /* Symbol type and binding */ + unsigned char st_other; /* Symbol visibility */ + Elf32_Section st_shndx; /* Section index */ +} Elf32_Sym; + +typedef struct { + Elf64_Word st_name; /* Symbol name (string tbl index) */ + unsigned char st_info; /* Symbol type and binding */ + unsigned char st_other; /* Symbol visibility */ + Elf64_Section st_shndx; /* Section index */ + Elf64_Addr st_value; /* Symbol value */ + Elf64_Xword st_size; /* Symbol size */ +} Elf64_Sym; + +/* The syminfo section if available contains additional information about + every dynamic symbol. */ + +typedef struct { + Elf32_Half si_boundto; /* Direct bindings, symbol bound to */ + Elf32_Half si_flags; /* Per symbol flags */ +} Elf32_Syminfo; + +typedef struct { + Elf64_Half si_boundto; /* Direct bindings, symbol bound to */ + Elf64_Half si_flags; /* Per symbol flags */ +} Elf64_Syminfo; + +/* Possible values for si_boundto. */ +#define SYMINFO_BT_SELF 0xffff /* Symbol bound to self */ +#define SYMINFO_BT_PARENT 0xfffe /* Symbol bound to parent */ +#define SYMINFO_BT_LOWRESERVE 0xff00 /* Beginning of reserved entries */ + +/* Possible bitmasks for si_flags. */ +#define SYMINFO_FLG_DIRECT 0x0001 /* Direct bound symbol */ +#define SYMINFO_FLG_PASSTHRU 0x0002 /* Pass-through symbol for translator */ +#define SYMINFO_FLG_COPY 0x0004 /* Symbol is a copy-reloc */ +#define SYMINFO_FLG_LAZYLOAD \ + 0x0008 /* Symbol bound to object to be lazy + loaded */ +/* Syminfo version values. */ +#define SYMINFO_NONE 0 +#define SYMINFO_CURRENT 1 +#define SYMINFO_NUM 2 + +/* How to extract and insert information held in the st_info field. */ + +#define ELF32_ST_BIND(val) (((unsigned char)(val)) >> 4) +#define ELF32_ST_TYPE(val) ((val) & 0xf) +#define ELF32_ST_INFO(bind, type) (((bind) << 4) + ((type) & 0xf)) + +/* Both Elf32_Sym and Elf64_Sym use the same one-byte st_info field. */ +#define ELF64_ST_BIND(val) ELF32_ST_BIND(val) +#define ELF64_ST_TYPE(val) ELF32_ST_TYPE(val) +#define ELF64_ST_INFO(bind, type) ELF32_ST_INFO((bind), (type)) + +/* Legal values for ST_BIND subfield of st_info (symbol binding). */ + +#define STB_LOCAL 0 /* Local symbol */ +#define STB_GLOBAL 1 /* Global symbol */ +#define STB_WEAK 2 /* Weak symbol */ +#define STB_NUM 3 /* Number of defined types. */ +#define STB_LOOS 10 /* Start of OS-specific */ +#define STB_GNU_UNIQUE 10 /* Unique symbol. */ +#define STB_HIOS 12 /* End of OS-specific */ +#define STB_LOPROC 13 /* Start of processor-specific */ +#define STB_HIPROC 15 /* End of processor-specific */ + +/* Legal values for ST_TYPE subfield of st_info (symbol type). */ + +#define STT_NOTYPE 0 /* Symbol type is unspecified */ +#define STT_OBJECT 1 /* Symbol is a data object */ +#define STT_FUNC 2 /* Symbol is a code object */ +#define STT_SECTION 3 /* Symbol associated with a section */ +#define STT_FILE 4 /* Symbol's name is file name */ +#define STT_COMMON 5 /* Symbol is a common data object */ +#define STT_TLS 6 /* Symbol is thread-local data object*/ +#define STT_NUM 7 /* Number of defined types. */ +#define STT_LOOS 10 /* Start of OS-specific */ +#define STT_GNU_IFUNC 10 /* Symbol is indirect code object */ +#define STT_HIOS 12 /* End of OS-specific */ +#define STT_LOPROC 13 /* Start of processor-specific */ +#define STT_HIPROC 15 /* End of processor-specific */ + +/* Symbol table indices are found in the hash buckets and chain table + of a symbol hash table section. This special index value indicates + the end of a chain, meaning no further symbols are found in that bucket. */ + +#define STN_UNDEF 0 /* End of a chain. */ + +/* How to extract and insert information held in the st_other field. */ + +#define ELF32_ST_VISIBILITY(o) ((o) & 0x03) + +/* For ELF64 the definitions are the same. */ +#define ELF64_ST_VISIBILITY(o) ELF32_ST_VISIBILITY(o) + +/* Symbol visibility specification encoded in the st_other field. */ +#define STV_DEFAULT 0 /* Default symbol visibility rules */ +#define STV_INTERNAL 1 /* Processor specific hidden class */ +#define STV_HIDDEN 2 /* Sym unavailable in other modules */ +#define STV_PROTECTED 3 /* Not preemptible, not exported */ + +/* Relocation table entry without addend (in section of type SHT_REL). */ + +typedef struct { + Elf32_Addr r_offset; /* Address */ + Elf32_Word r_info; /* Relocation type and symbol index */ +} Elf32_Rel; + +/* I have seen two different definitions of the Elf64_Rel and + Elf64_Rela structures, so we'll leave them out until Novell (or + whoever) gets their act together. */ +/* The following, at least, is used on Sparc v9, MIPS, and Alpha. */ + +typedef struct { + Elf64_Addr r_offset; /* Address */ + Elf64_Xword r_info; /* Relocation type and symbol index */ +} Elf64_Rel; + +/* Relocation table entry with addend (in section of type SHT_RELA). */ + +typedef struct { + Elf32_Addr r_offset; /* Address */ + Elf32_Word r_info; /* Relocation type and symbol index */ + Elf32_Sword r_addend; /* Addend */ +} Elf32_Rela; + +typedef struct { + Elf64_Addr r_offset; /* Address */ + Elf64_Xword r_info; /* Relocation type and symbol index */ + Elf64_Sxword r_addend; /* Addend */ +} Elf64_Rela; + +/* RELR relocation table entry */ + +typedef Elf32_Word Elf32_Relr; +typedef Elf64_Xword Elf64_Relr; + +/* How to extract and insert information held in the r_info field. */ + +#define ELF32_R_SYM(val) ((val) >> 8) +#define ELF32_R_TYPE(val) ((val) & 0xff) +#define ELF32_R_INFO(sym, type) (((sym) << 8) + ((type) & 0xff)) + +#define ELF64_R_SYM(i) ((i) >> 32) +#define ELF64_R_TYPE(i) ((i) & 0xffffffff) +#define ELF64_R_INFO(sym, type) ((((Elf64_Xword)(sym)) << 32) + (type)) + +/* Program segment header. */ + +typedef struct { + Elf32_Word p_type; /* Segment type */ + Elf32_Off p_offset; /* Segment file offset */ + Elf32_Addr p_vaddr; /* Segment virtual address */ + Elf32_Addr p_paddr; /* Segment physical address */ + Elf32_Word p_filesz; /* Segment size in file */ + Elf32_Word p_memsz; /* Segment size in memory */ + Elf32_Word p_flags; /* Segment flags */ + Elf32_Word p_align; /* Segment alignment */ +} Elf32_Phdr; + +typedef struct { + Elf64_Word p_type; /* Segment type */ + Elf64_Word p_flags; /* Segment flags */ + Elf64_Off p_offset; /* Segment file offset */ + Elf64_Addr p_vaddr; /* Segment virtual address */ + Elf64_Addr p_paddr; /* Segment physical address */ + Elf64_Xword p_filesz; /* Segment size in file */ + Elf64_Xword p_memsz; /* Segment size in memory */ + Elf64_Xword p_align; /* Segment alignment */ +} Elf64_Phdr; + +/* Special value for e_phnum. This indicates that the real number of + program headers is too large to fit into e_phnum. Instead the real + value is in the field sh_info of section 0. */ + +#define PN_XNUM 0xffff + +/* Legal values for p_type (segment type). */ + +#define PT_NULL 0 /* Program header table entry unused */ +#define PT_LOAD 1 /* Loadable program segment */ +#define PT_DYNAMIC 2 /* Dynamic linking information */ +#define PT_INTERP 3 /* Program interpreter */ +#define PT_NOTE 4 /* Auxiliary information */ +#define PT_SHLIB 5 /* Reserved */ +#define PT_PHDR 6 /* Entry for header table itself */ +#define PT_TLS 7 /* Thread-local storage segment */ +#define PT_NUM 8 /* Number of defined types */ +#define PT_LOOS 0x60000000 /* Start of OS-specific */ +#define PT_GNU_EH_FRAME 0x6474e550 /* GCC .eh_frame_hdr segment */ +#define PT_GNU_STACK 0x6474e551 /* Indicates stack executability */ +#define PT_GNU_RELRO 0x6474e552 /* Read-only after relocation */ +#define PT_GNU_PROPERTY 0x6474e553 /* GNU property */ +#define PT_GNU_SFRAME 0x6474e554 /* SFrame segment. */ +#define PT_LOSUNW 0x6ffffffa +#define PT_SUNWBSS 0x6ffffffa /* Sun Specific segment */ +#define PT_SUNWSTACK 0x6ffffffb /* Stack segment */ +#define PT_HISUNW 0x6fffffff +#define PT_HIOS 0x6fffffff /* End of OS-specific */ +#define PT_LOPROC 0x70000000 /* Start of processor-specific */ +#define PT_HIPROC 0x7fffffff /* End of processor-specific */ + +/* Legal values for p_flags (segment flags). */ + +#define PF_X (1 << 0) /* Segment is executable */ +#define PF_W (1 << 1) /* Segment is writable */ +#define PF_R (1 << 2) /* Segment is readable */ +#define PF_MASKOS 0x0ff00000 /* OS-specific */ +#define PF_MASKPROC 0xf0000000 /* Processor-specific */ + +/* Legal values for note segment descriptor types for core files. */ + +#define NT_PRSTATUS 1 /* Contains copy of prstatus struct */ +#define NT_PRFPREG \ + 2 /* Contains copy of fpregset + struct. */ +#define NT_FPREGSET 2 /* Contains copy of fpregset struct */ +#define NT_PRPSINFO 3 /* Contains copy of prpsinfo struct */ +#define NT_PRXREG 4 /* Contains copy of prxregset struct */ +#define NT_TASKSTRUCT 4 /* Contains copy of task structure */ +#define NT_PLATFORM 5 /* String from sysinfo(SI_PLATFORM) */ +#define NT_AUXV 6 /* Contains copy of auxv array */ +#define NT_GWINDOWS 7 /* Contains copy of gwindows struct */ +#define NT_ASRS 8 /* Contains copy of asrset struct */ +#define NT_PSTATUS 10 /* Contains copy of pstatus struct */ +#define NT_PSINFO 13 /* Contains copy of psinfo struct */ +#define NT_PRCRED 14 /* Contains copy of prcred struct */ +#define NT_UTSNAME 15 /* Contains copy of utsname struct */ +#define NT_LWPSTATUS 16 /* Contains copy of lwpstatus struct */ +#define NT_LWPSINFO 17 /* Contains copy of lwpinfo struct */ +#define NT_PRFPXREG 20 /* Contains copy of fprxregset struct */ +#define NT_SIGINFO \ + 0x53494749 /* Contains copy of siginfo_t, + size might increase */ +#define NT_FILE \ + 0x46494c45 /* Contains information about mapped + files */ +#define NT_PRXFPREG 0x46e62b7f /* Contains copy of user_fxsr_struct */ +#define NT_PPC_VMX 0x100 /* PowerPC Altivec/VMX registers */ +#define NT_PPC_SPE 0x101 /* PowerPC SPE/EVR registers */ +#define NT_PPC_VSX 0x102 /* PowerPC VSX registers */ +#define NT_PPC_TAR 0x103 /* Target Address Register */ +#define NT_PPC_PPR 0x104 /* Program Priority Register */ +#define NT_PPC_DSCR 0x105 /* Data Stream Control Register */ +#define NT_PPC_EBB 0x106 /* Event Based Branch Registers */ +#define NT_PPC_PMU 0x107 /* Performance Monitor Registers */ +#define NT_PPC_TM_CGPR 0x108 /* TM checkpointed GPR Registers */ +#define NT_PPC_TM_CFPR 0x109 /* TM checkpointed FPR Registers */ +#define NT_PPC_TM_CVMX 0x10a /* TM checkpointed VMX Registers */ +#define NT_PPC_TM_CVSX 0x10b /* TM checkpointed VSX Registers */ +#define NT_PPC_TM_SPR 0x10c /* TM Special Purpose Registers */ +#define NT_PPC_TM_CTAR \ + 0x10d /* TM checkpointed Target Address + Register */ +#define NT_PPC_TM_CPPR \ + 0x10e /* TM checkpointed Program Priority + Register */ +#define NT_PPC_TM_CDSCR \ + 0x10f /* TM checkpointed Data Stream Control + Register */ +#define NT_PPC_PKEY \ + 0x110 /* Memory Protection Keys + registers. */ +#define NT_PPC_DEXCR 0x111 /* PowerPC DEXCR registers. */ +#define NT_PPC_HASHKEYR 0x112 /* PowerPC HASHKEYR register. */ +#define NT_386_TLS 0x200 /* i386 TLS slots (struct user_desc) */ +#define NT_386_IOPERM 0x201 /* x86 io permission bitmap (1=deny) */ +#define NT_X86_XSTATE 0x202 /* x86 extended state using xsave */ +#define NT_X86_SHSTK 0x204 /* x86 SHSTK state */ +#define NT_X86_XSAVE_LAYOUT 0x205 /* XSAVE layout description. */ +#define NT_S390_HIGH_GPRS 0x300 /* s390 upper register halves */ +#define NT_S390_TIMER 0x301 /* s390 timer register */ +#define NT_S390_TODCMP 0x302 /* s390 TOD clock comparator register */ +#define NT_S390_TODPREG 0x303 /* s390 TOD programmable register */ +#define NT_S390_CTRS 0x304 /* s390 control registers */ +#define NT_S390_PREFIX 0x305 /* s390 prefix register */ +#define NT_S390_LAST_BREAK 0x306 /* s390 breaking event address */ +#define NT_S390_SYSTEM_CALL 0x307 /* s390 system call restart data */ +#define NT_S390_TDB 0x308 /* s390 transaction diagnostic block */ +#define NT_S390_VXRS_LOW \ + 0x309 /* s390 vector registers 0-15 + upper half. */ +#define NT_S390_VXRS_HIGH 0x30a /* s390 vector registers 16-31. */ +#define NT_S390_GS_CB 0x30b /* s390 guarded storage registers. */ +#define NT_S390_GS_BC \ + 0x30c /* s390 guarded storage + broadcast control block. */ +#define NT_S390_RI_CB 0x30d /* s390 runtime instrumentation. */ +#define NT_S390_PV_CPU_DATA 0x30e /* s390 protvirt cpu dump data. */ +#define NT_ARM_VFP 0x400 /* ARM VFP/NEON registers */ +#define NT_ARM_TLS 0x401 /* ARM TLS register */ +#define NT_ARM_HW_BREAK 0x402 /* ARM hardware breakpoint registers */ +#define NT_ARM_HW_WATCH 0x403 /* ARM hardware watchpoint registers */ +#define NT_ARM_SYSTEM_CALL 0x404 /* ARM system call number */ +#define NT_ARM_SVE \ + 0x405 /* ARM Scalable Vector Extension + registers */ +#define NT_ARM_PAC_MASK \ + 0x406 /* ARM pointer authentication + code masks. */ +#define NT_ARM_PACA_KEYS \ + 0x407 /* ARM pointer authentication + address keys. */ +#define NT_ARM_PACG_KEYS \ + 0x408 /* ARM pointer authentication + generic key. */ +#define NT_ARM_TAGGED_ADDR_CTRL \ + 0x409 /* AArch64 tagged address + control. */ +#define NT_ARM_PAC_ENABLED_KEYS \ + 0x40a /* AArch64 pointer authentication + enabled keys. */ +#define NT_ARM_SSVE 0x40b /* ARM Streaming SVE registers. */ +#define NT_ARM_ZA 0x40c /* ARM SME ZA registers. */ +#define NT_ARM_ZT 0x40d /* ARM SME ZT registers. */ +#define NT_ARM_FPMR 0x40e /* ARM floating point mode register. */ +#define NT_ARM_POE 0x40f /* ARM POE registers. */ +#define NT_VMCOREDD 0x700 /* Vmcore Device Dump Note. */ +#define NT_MIPS_DSP 0x800 /* MIPS DSP ASE registers. */ +#define NT_MIPS_FP_MODE 0x801 /* MIPS floating-point mode. */ +#define NT_MIPS_MSA 0x802 /* MIPS SIMD registers. */ +#define NT_RISCV_CSR 0x900 /* RISC-V Control and Status Registers */ +#define NT_RISCV_VECTOR 0x901 /* RISC-V vector registers */ +#define NT_LOONGARCH_CPUCFG 0xa00 /* LoongArch CPU config registers. */ +#define NT_LOONGARCH_CSR \ + 0xa01 /* LoongArch control and + status registers. */ +#define NT_LOONGARCH_LSX \ + 0xa02 /* LoongArch Loongson SIMD + Extension registers. */ +#define NT_LOONGARCH_LASX \ + 0xa03 /* LoongArch Loongson Advanced + SIMD Extension registers. */ +#define NT_LOONGARCH_LBT \ + 0xa04 /* LoongArch Loongson Binary + Translation registers. */ +#define NT_LOONGARCH_HW_BREAK \ + 0xa05 /* LoongArch hardware breakpoint registers */ +#define NT_LOONGARCH_HW_WATCH \ + 0xa06 /* LoongArch hardware watchpoint registers */ + +/* Legal values for the note segment descriptor types for object files. */ + +#define NT_VERSION 1 /* Contains a version string. */ + +/* Dynamic section entry. */ + +typedef struct { + Elf32_Sword d_tag; /* Dynamic entry type */ + union { + Elf32_Word d_val; /* Integer value */ + Elf32_Addr d_ptr; /* Address value */ + } d_un; +} Elf32_Dyn; + +typedef struct { + Elf64_Sxword d_tag; /* Dynamic entry type */ + union { + Elf64_Xword d_val; /* Integer value */ + Elf64_Addr d_ptr; /* Address value */ + } d_un; +} Elf64_Dyn; + +/* Legal values for d_tag (dynamic entry type). */ + +#define DT_NULL 0 /* Marks end of dynamic section */ +#define DT_NEEDED 1 /* Name of needed library */ +#define DT_PLTRELSZ 2 /* Size in bytes of PLT relocs */ +#define DT_PLTGOT 3 /* Processor defined value */ +#define DT_HASH 4 /* Address of symbol hash table */ +#define DT_STRTAB 5 /* Address of string table */ +#define DT_SYMTAB 6 /* Address of symbol table */ +#define DT_RELA 7 /* Address of Rela relocs */ +#define DT_RELASZ 8 /* Total size of Rela relocs */ +#define DT_RELAENT 9 /* Size of one Rela reloc */ +#define DT_STRSZ 10 /* Size of string table */ +#define DT_SYMENT 11 /* Size of one symbol table entry */ +#define DT_INIT 12 /* Address of init function */ +#define DT_FINI 13 /* Address of termination function */ +#define DT_SONAME 14 /* Name of shared object */ +#define DT_RPATH 15 /* Library search path (deprecated) */ +#define DT_SYMBOLIC 16 /* Start symbol search here */ +#define DT_REL 17 /* Address of Rel relocs */ +#define DT_RELSZ 18 /* Total size of Rel relocs */ +#define DT_RELENT 19 /* Size of one Rel reloc */ +#define DT_PLTREL 20 /* Type of reloc in PLT */ +#define DT_DEBUG 21 /* For debugging; unspecified */ +#define DT_TEXTREL 22 /* Reloc might modify .text */ +#define DT_JMPREL 23 /* Address of PLT relocs */ +#define DT_BIND_NOW 24 /* Process relocations of object */ +#define DT_INIT_ARRAY 25 /* Array with addresses of init fct */ +#define DT_FINI_ARRAY 26 /* Array with addresses of fini fct */ +#define DT_INIT_ARRAYSZ 27 /* Size in bytes of DT_INIT_ARRAY */ +#define DT_FINI_ARRAYSZ 28 /* Size in bytes of DT_FINI_ARRAY */ +#define DT_RUNPATH 29 /* Library search path */ +#define DT_FLAGS 30 /* Flags for the object being loaded */ +#define DT_ENCODING 32 /* Start of encoded range */ +#define DT_PREINIT_ARRAY 32 /* Array with addresses of preinit fct*/ +#define DT_PREINIT_ARRAYSZ 33 /* size in bytes of DT_PREINIT_ARRAY */ +#define DT_SYMTAB_SHNDX 34 /* Address of SYMTAB_SHNDX section */ +#define DT_RELRSZ 35 /* Total size of RELR relative relocations */ +#define DT_RELR 36 /* Address of RELR relative relocations */ +#define DT_RELRENT 37 /* Size of one RELR relative relocaction */ +#define DT_NUM 38 /* Number used */ +#define DT_LOOS 0x6000000d /* Start of OS-specific */ +#define DT_HIOS 0x6ffff000 /* End of OS-specific */ +#define DT_LOPROC 0x70000000 /* Start of processor-specific */ +#define DT_HIPROC 0x7fffffff /* End of processor-specific */ +#define DT_PROCNUM DT_MIPS_NUM /* Most used by any processor */ + +/* DT_* entries which fall between DT_VALRNGHI & DT_VALRNGLO use the + Dyn.d_un.d_val field of the Elf*_Dyn structure. This follows Sun's + approach. */ +#define DT_VALRNGLO 0x6ffffd00 +#define DT_GNU_PRELINKED 0x6ffffdf5 /* Prelinking timestamp */ +#define DT_GNU_CONFLICTSZ 0x6ffffdf6 /* Size of conflict section */ +#define DT_GNU_LIBLISTSZ 0x6ffffdf7 /* Size of library list */ +#define DT_CHECKSUM 0x6ffffdf8 +#define DT_PLTPADSZ 0x6ffffdf9 +#define DT_MOVEENT 0x6ffffdfa +#define DT_MOVESZ 0x6ffffdfb +#define DT_FEATURE_1 0x6ffffdfc /* Feature selection (DTF_*). */ +#define DT_POSFLAG_1 \ + 0x6ffffdfd /* Flags for DT_* entries, effecting + the following DT_* entry. */ +#define DT_SYMINSZ 0x6ffffdfe /* Size of syminfo table (in bytes) */ +#define DT_SYMINENT 0x6ffffdff /* Entry size of syminfo */ +#define DT_VALRNGHI 0x6ffffdff +#define DT_VALTAGIDX(tag) (DT_VALRNGHI - (tag)) /* Reverse order! */ +#define DT_VALNUM 12 + +/* DT_* entries which fall between DT_ADDRRNGHI & DT_ADDRRNGLO use the + Dyn.d_un.d_ptr field of the Elf*_Dyn structure. + + If any adjustment is made to the ELF object after it has been + built these entries will need to be adjusted. */ +#define DT_ADDRRNGLO 0x6ffffe00 +#define DT_GNU_HASH 0x6ffffef5 /* GNU-style hash table. */ +#define DT_TLSDESC_PLT 0x6ffffef6 +#define DT_TLSDESC_GOT 0x6ffffef7 +#define DT_GNU_CONFLICT 0x6ffffef8 /* Start of conflict section */ +#define DT_GNU_LIBLIST 0x6ffffef9 /* Library list */ +#define DT_CONFIG 0x6ffffefa /* Configuration information. */ +#define DT_DEPAUDIT 0x6ffffefb /* Dependency auditing. */ +#define DT_AUDIT 0x6ffffefc /* Object auditing. */ +#define DT_PLTPAD 0x6ffffefd /* PLT padding. */ +#define DT_MOVETAB 0x6ffffefe /* Move table. */ +#define DT_SYMINFO 0x6ffffeff /* Syminfo table. */ +#define DT_ADDRRNGHI 0x6ffffeff +#define DT_ADDRTAGIDX(tag) (DT_ADDRRNGHI - (tag)) /* Reverse order! */ +#define DT_ADDRNUM 11 + +/* The versioning entry types. The next are defined as part of the + GNU extension. */ +#define DT_VERSYM 0x6ffffff0 + +#define DT_RELACOUNT 0x6ffffff9 +#define DT_RELCOUNT 0x6ffffffa + +/* These were chosen by Sun. */ +#define DT_FLAGS_1 0x6ffffffb /* State flags, see DF_1_* below. */ +#define DT_VERDEF \ + 0x6ffffffc /* Address of version definition + table */ +#define DT_VERDEFNUM 0x6ffffffd /* Number of version definitions */ +#define DT_VERNEED \ + 0x6ffffffe /* Address of table with needed + versions */ +#define DT_VERNEEDNUM 0x6fffffff /* Number of needed versions */ +#define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */ +#define DT_VERSIONTAGNUM 16 + +/* Sun added these machine-independent extensions in the "processor-specific" + range. Be compatible. */ +#define DT_AUXILIARY 0x7ffffffd /* Shared object to load before self */ +#define DT_FILTER 0x7fffffff /* Shared object to get values from */ +#define DT_EXTRATAGIDX(tag) ((Elf32_Word) - ((Elf32_Sword)(tag) << 1 >> 1) - 1) +#define DT_EXTRANUM 3 + +/* Values of `d_un.d_val' in the DT_FLAGS entry. */ +#define DF_ORIGIN 0x00000001 /* Object may use DF_ORIGIN */ +#define DF_SYMBOLIC 0x00000002 /* Symbol resolutions starts here */ +#define DF_TEXTREL 0x00000004 /* Object contains text relocations */ +#define DF_BIND_NOW 0x00000008 /* No lazy binding for this object */ +#define DF_STATIC_TLS 0x00000010 /* Module uses the static TLS model */ + +/* State flags selectable in the `d_un.d_val' element of the DT_FLAGS_1 + entry in the dynamic section. */ +#define DF_1_NOW 0x00000001 /* Set RTLD_NOW for this object. */ +#define DF_1_GLOBAL 0x00000002 /* Set RTLD_GLOBAL for this object. */ +#define DF_1_GROUP 0x00000004 /* Set RTLD_GROUP for this object. */ +#define DF_1_NODELETE 0x00000008 /* Set RTLD_NODELETE for this object.*/ +#define DF_1_LOADFLTR 0x00000010 /* Trigger filtee loading at runtime.*/ +#define DF_1_INITFIRST 0x00000020 /* Set RTLD_INITFIRST for this object*/ +#define DF_1_NOOPEN 0x00000040 /* Set RTLD_NOOPEN for this object. */ +#define DF_1_ORIGIN 0x00000080 /* $ORIGIN must be handled. */ +#define DF_1_DIRECT 0x00000100 /* Direct binding enabled. */ +#define DF_1_TRANS 0x00000200 +#define DF_1_INTERPOSE 0x00000400 /* Object is used to interpose. */ +#define DF_1_NODEFLIB 0x00000800 /* Ignore default lib search path. */ +#define DF_1_NODUMP 0x00001000 /* Object can't be dldump'ed. */ +#define DF_1_CONFALT 0x00002000 /* Configuration alternative created.*/ +#define DF_1_ENDFILTEE 0x00004000 /* Filtee terminates filters search. */ +#define DF_1_DISPRELDNE 0x00008000 /* Disp reloc applied at build time. */ +#define DF_1_DISPRELPND 0x00010000 /* Disp reloc applied at run-time. */ +#define DF_1_NODIRECT 0x00020000 /* Object has no-direct binding. */ +#define DF_1_IGNMULDEF 0x00040000 +#define DF_1_NOKSYMS 0x00080000 +#define DF_1_NOHDR 0x00100000 +#define DF_1_EDITED 0x00200000 /* Object is modified after built. */ +#define DF_1_NORELOC 0x00400000 +#define DF_1_SYMINTPOSE 0x00800000 /* Object has individual interposers. */ +#define DF_1_GLOBAUDIT 0x01000000 /* Global auditing required. */ +#define DF_1_SINGLETON 0x02000000 /* Singleton symbols are used. */ +#define DF_1_STUB 0x04000000 +#define DF_1_PIE 0x08000000 +#define DF_1_KMOD 0x10000000 +#define DF_1_WEAKFILTER 0x20000000 +#define DF_1_NOCOMMON 0x40000000 + +/* Flags for the feature selection in DT_FEATURE_1. */ +#define DTF_1_PARINIT 0x00000001 +#define DTF_1_CONFEXP 0x00000002 + +/* Flags in the DT_POSFLAG_1 entry effecting only the next DT_* entry. */ +#define DF_P1_LAZYLOAD 0x00000001 /* Lazyload following object. */ +#define DF_P1_GROUPPERM \ + 0x00000002 /* Symbols from next object are not + generally available. */ + +/* Version definition sections. */ + +typedef struct { + Elf32_Half vd_version; /* Version revision */ + Elf32_Half vd_flags; /* Version information */ + Elf32_Half vd_ndx; /* Version Index */ + Elf32_Half vd_cnt; /* Number of associated aux entries */ + Elf32_Word vd_hash; /* Version name hash value */ + Elf32_Word vd_aux; /* Offset in bytes to verdaux array */ + Elf32_Word vd_next; /* Offset in bytes to next verdef + entry */ +} Elf32_Verdef; + +typedef struct { + Elf64_Half vd_version; /* Version revision */ + Elf64_Half vd_flags; /* Version information */ + Elf64_Half vd_ndx; /* Version Index */ + Elf64_Half vd_cnt; /* Number of associated aux entries */ + Elf64_Word vd_hash; /* Version name hash value */ + Elf64_Word vd_aux; /* Offset in bytes to verdaux array */ + Elf64_Word vd_next; /* Offset in bytes to next verdef + entry */ +} Elf64_Verdef; + +/* Legal values for vd_version (version revision). */ +#define VER_DEF_NONE 0 /* No version */ +#define VER_DEF_CURRENT 1 /* Current version */ +#define VER_DEF_NUM 2 /* Given version number */ + +/* Legal values for vd_flags (version information flags). */ +#define VER_FLG_BASE 0x1 /* Version definition of file itself */ +#define VER_FLG_WEAK \ + 0x2 /* Weak version identifier. Also + used by vna_flags below. */ + +/* Versym symbol index values. */ +#define VER_NDX_LOCAL 0 /* Symbol is local. */ +#define VER_NDX_GLOBAL 1 /* Symbol is global. */ +#define VER_NDX_LORESERVE 0xff00 /* Beginning of reserved entries. */ +#define VER_NDX_ELIMINATE 0xff01 /* Symbol is to be eliminated. */ + +/* Auxiliary version information. */ + +typedef struct { + Elf32_Word vda_name; /* Version or dependency names */ + Elf32_Word vda_next; /* Offset in bytes to next verdaux + entry */ +} Elf32_Verdaux; + +typedef struct { + Elf64_Word vda_name; /* Version or dependency names */ + Elf64_Word vda_next; /* Offset in bytes to next verdaux + entry */ +} Elf64_Verdaux; + +/* Version dependency section. */ + +typedef struct { + Elf32_Half vn_version; /* Version of structure */ + Elf32_Half vn_cnt; /* Number of associated aux entries */ + Elf32_Word vn_file; /* Offset of filename for this + dependency */ + Elf32_Word vn_aux; /* Offset in bytes to vernaux array */ + Elf32_Word vn_next; /* Offset in bytes to next verneed + entry */ +} Elf32_Verneed; + +typedef struct { + Elf64_Half vn_version; /* Version of structure */ + Elf64_Half vn_cnt; /* Number of associated aux entries */ + Elf64_Word vn_file; /* Offset of filename for this + dependency */ + Elf64_Word vn_aux; /* Offset in bytes to vernaux array */ + Elf64_Word vn_next; /* Offset in bytes to next verneed + entry */ +} Elf64_Verneed; + +/* Legal values for vn_version (version revision). */ +#define VER_NEED_NONE 0 /* No version */ +#define VER_NEED_CURRENT 1 /* Current version */ +#define VER_NEED_NUM 2 /* Given version number */ + +/* Auxiliary needed version information. */ + +typedef struct { + Elf32_Word vna_hash; /* Hash value of dependency name */ + Elf32_Half vna_flags; /* Dependency specific information */ + Elf32_Half vna_other; /* Unused */ + Elf32_Word vna_name; /* Dependency name string offset */ + Elf32_Word vna_next; /* Offset in bytes to next vernaux + entry */ +} Elf32_Vernaux; + +typedef struct { + Elf64_Word vna_hash; /* Hash value of dependency name */ + Elf64_Half vna_flags; /* Dependency specific information */ + Elf64_Half vna_other; /* Unused */ + Elf64_Word vna_name; /* Dependency name string offset */ + Elf64_Word vna_next; /* Offset in bytes to next vernaux + entry */ +} Elf64_Vernaux; + +/* Auxiliary vector. */ + +/* This vector is normally only used by the program interpreter. The + usual definition in an ABI supplement uses the name auxv_t. The + vector is not usually defined in a standard <elf.h> file, but it + can't hurt. We rename it to avoid conflicts. The sizes of these + types are an arrangement between the exec server and the program + interpreter, so we don't fully specify them here. */ + +typedef struct { + uint32_t a_type; /* Entry type */ + union { + uint32_t a_val; /* Integer value */ + /* We use to have pointer elements added here. We cannot do that, + though, since it does not work when using 32-bit definitions + on 64-bit platforms and vice versa. */ + } a_un; +} Elf32_auxv_t; + +typedef struct { + uint64_t a_type; /* Entry type */ + union { + uint64_t a_val; /* Integer value */ + /* We use to have pointer elements added here. We cannot do that, + though, since it does not work when using 32-bit definitions + on 64-bit platforms and vice versa. */ + } a_un; +} Elf64_auxv_t; + +/* Legal values for a_type (entry type). */ + +#define AT_NULL 0 /* End of vector */ +#define AT_IGNORE 1 /* Entry should be ignored */ +#define AT_EXECFD 2 /* File descriptor of program */ +#define AT_PHDR 3 /* Program headers for program */ +#define AT_PHENT 4 /* Size of program header entry */ +#define AT_PHNUM 5 /* Number of program headers */ +#define AT_PAGESZ 6 /* System page size */ +#define AT_BASE 7 /* Base address of interpreter */ +#define AT_FLAGS 8 /* Flags */ +#define AT_ENTRY 9 /* Entry point of program */ +#define AT_NOTELF 10 /* Program is not ELF */ +#define AT_UID 11 /* Real uid */ +#define AT_EUID 12 /* Effective uid */ +#define AT_GID 13 /* Real gid */ +#define AT_EGID 14 /* Effective gid */ +#define AT_CLKTCK 17 /* Frequency of times() */ + +/* Some more special a_type values describing the hardware. */ +#define AT_PLATFORM 15 /* String identifying platform. */ +#define AT_HWCAP \ + 16 /* Machine-dependent hints about + processor capabilities. */ + +/* This entry gives some information about the FPU initialization + performed by the kernel. */ +#define AT_FPUCW 18 /* Used FPU control word. */ + +/* Cache block sizes. */ +#define AT_DCACHEBSIZE 19 /* Data cache block size. */ +#define AT_ICACHEBSIZE 20 /* Instruction cache block size. */ +#define AT_UCACHEBSIZE 21 /* Unified cache block size. */ + +/* A special ignored value for PPC, used by the kernel to control the + interpretation of the AUXV. Must be > 16. */ +#define AT_IGNOREPPC 22 /* Entry should be ignored. */ + +#define AT_SECURE 23 /* Boolean, was exec setuid-like? */ + +#define AT_BASE_PLATFORM 24 /* String identifying real platforms.*/ + +#define AT_RANDOM 25 /* Address of 16 random bytes. */ + +#define AT_HWCAP2 \ + 26 /* More machine-dependent hints about + processor capabilities. */ + +#define AT_RSEQ_FEATURE_SIZE 27 /* rseq supported feature size. */ +#define AT_RSEQ_ALIGN 28 /* rseq allocation alignment. */ + +/* More machine-dependent hints about processor capabilities. */ +#define AT_HWCAP3 29 /* extension of AT_HWCAP. */ +#define AT_HWCAP4 30 /* extension of AT_HWCAP. */ + +#define AT_EXECFN 31 /* Filename of executable. */ + +/* Pointer to the global system page used for system calls and other + nice things. */ +#define AT_SYSINFO 32 +#define AT_SYSINFO_EHDR 33 + +/* Shapes of the caches. Bits 0-3 contains associativity; bits 4-7 contains + log2 of line size; mask those to get cache size. */ +#define AT_L1I_CACHESHAPE 34 +#define AT_L1D_CACHESHAPE 35 +#define AT_L2_CACHESHAPE 36 +#define AT_L3_CACHESHAPE 37 + +/* Shapes of the caches, with more room to describe them. + *GEOMETRY are comprised of cache line size in bytes in the bottom 16 bits + and the cache associativity in the next 16 bits. */ +#define AT_L1I_CACHESIZE 40 +#define AT_L1I_CACHEGEOMETRY 41 +#define AT_L1D_CACHESIZE 42 +#define AT_L1D_CACHEGEOMETRY 43 +#define AT_L2_CACHESIZE 44 +#define AT_L2_CACHEGEOMETRY 45 +#define AT_L3_CACHESIZE 46 +#define AT_L3_CACHEGEOMETRY 47 + +#define AT_MINSIGSTKSZ 51 /* Stack needed for signal delivery */ + +/* Note section contents. Each entry in the note section begins with + a header of a fixed form. */ + +typedef struct { + Elf32_Word n_namesz; /* Length of the note's name. */ + Elf32_Word n_descsz; /* Length of the note's descriptor. */ + Elf32_Word n_type; /* Type of the note. */ +} Elf32_Nhdr; + +typedef struct { + Elf64_Word n_namesz; /* Length of the note's name. */ + Elf64_Word n_descsz; /* Length of the note's descriptor. */ + Elf64_Word n_type; /* Type of the note. */ +} Elf64_Nhdr; + +/* Known names of notes. */ + +/* Solaris entries in the note section have this name. */ +#define ELF_NOTE_SOLARIS "SUNW Solaris" + +/* Note entries for GNU systems have this name. */ +#define ELF_NOTE_GNU "GNU" + +/* Note entries for freedesktop.org have this name. */ +#define ELF_NOTE_FDO "FDO" + +/* Defined types of notes for Solaris. */ + +/* Value of descriptor (one word) is desired pagesize for the binary. */ +#define ELF_NOTE_PAGESIZE_HINT 1 + +/* Defined note types for GNU systems. */ + +/* ABI information. The descriptor consists of words: + word 0: OS descriptor + word 1: major version of the ABI + word 2: minor version of the ABI + word 3: subminor version of the ABI +*/ +#define NT_GNU_ABI_TAG 1 +#define ELF_NOTE_ABI NT_GNU_ABI_TAG /* Old name. */ + +/* Known OSes. These values can appear in word 0 of an + NT_GNU_ABI_TAG note section entry. */ +#define ELF_NOTE_OS_LINUX 0 +#define ELF_NOTE_OS_GNU 1 +#define ELF_NOTE_OS_SOLARIS2 2 +#define ELF_NOTE_OS_FREEBSD 3 + +/* Synthetic hwcap information. The descriptor begins with two words: + word 0: number of entries + word 1: bitmask of enabled entries + Then follow variable-length entries, one byte followed by a + '\0'-terminated hwcap name string. The byte gives the bit + number to test if enabled, (1U << bit) & bitmask. */ +#define NT_GNU_HWCAP 2 + +/* Build ID bits as generated by ld --build-id. + The descriptor consists of any nonzero number of bytes. */ +#define NT_GNU_BUILD_ID 3 + +/* Version note generated by GNU gold containing a version string. */ +#define NT_GNU_GOLD_VERSION 4 + +/* Program property. */ +#define NT_GNU_PROPERTY_TYPE_0 5 + +/* Packaging metadata as defined on + https://systemd.io/ELF_PACKAGE_METADATA/ */ +#define NT_FDO_PACKAGING_METADATA 0xcafe1a7e + +/* dlopen metadata as defined on + https://systemd.io/ELF_DLOPEN_METADATA/ */ +#define NT_FDO_DLOPEN_METADATA 0x407c0c0a + +/* Note section name of program property. */ +#define NOTE_GNU_PROPERTY_SECTION_NAME ".note.gnu.property" + +/* Values used in GNU .note.gnu.property notes (NT_GNU_PROPERTY_TYPE_0). */ + +/* Stack size. */ +#define GNU_PROPERTY_STACK_SIZE 1 +/* No copy relocation on protected data symbol. */ +#define GNU_PROPERTY_NO_COPY_ON_PROTECTED 2 + +/* A 4-byte unsigned integer property: A bit is set if it is set in all + relocatable inputs. */ +#define GNU_PROPERTY_UINT32_AND_LO 0xb0000000 +#define GNU_PROPERTY_UINT32_AND_HI 0xb0007fff + +/* A 4-byte unsigned integer property: A bit is set if it is set in any + relocatable inputs. */ +#define GNU_PROPERTY_UINT32_OR_LO 0xb0008000 +#define GNU_PROPERTY_UINT32_OR_HI 0xb000ffff + +/* The needed properties by the object file. */ +#define GNU_PROPERTY_1_NEEDED GNU_PROPERTY_UINT32_OR_LO + +/* Set if the object file requires canonical function pointers and + cannot be used with copy relocation. */ +#define GNU_PROPERTY_1_NEEDED_INDIRECT_EXTERN_ACCESS (1U << 0) + +/* Processor-specific semantics, lo */ +#define GNU_PROPERTY_LOPROC 0xc0000000 +/* Processor-specific semantics, hi */ +#define GNU_PROPERTY_HIPROC 0xdfffffff +/* Application-specific semantics, lo */ +#define GNU_PROPERTY_LOUSER 0xe0000000 +/* Application-specific semantics, hi */ +#define GNU_PROPERTY_HIUSER 0xffffffff + +/* AArch64 specific GNU properties. */ +#define GNU_PROPERTY_AARCH64_FEATURE_1_AND 0xc0000000 + +#define GNU_PROPERTY_AARCH64_FEATURE_1_BTI (1U << 0) +#define GNU_PROPERTY_AARCH64_FEATURE_1_PAC (1U << 1) +#define GNU_PROPERTY_AARCH64_FEATURE_1_GCS (1U << 2) + +/* The x86 instruction sets indicated by the corresponding bits are + used in program. Their support in the hardware is optional. */ +#define GNU_PROPERTY_X86_ISA_1_USED 0xc0010002 +/* The x86 instruction sets indicated by the corresponding bits are + used in program and they must be supported by the hardware. */ +#define GNU_PROPERTY_X86_ISA_1_NEEDED 0xc0008002 +/* X86 processor-specific features used in program. */ +#define GNU_PROPERTY_X86_FEATURE_1_AND 0xc0000002 + +/* GNU_PROPERTY_X86_ISA_1_BASELINE: CMOV, CX8 (cmpxchg8b), FPU (fld), + MMX, OSFXSR (fxsave), SCE (syscall), SSE and SSE2. */ +#define GNU_PROPERTY_X86_ISA_1_BASELINE (1U << 0) +/* GNU_PROPERTY_X86_ISA_1_V2: GNU_PROPERTY_X86_ISA_1_BASELINE, + CMPXCHG16B (cmpxchg16b), LAHF-SAHF (lahf), POPCNT (popcnt), SSE3, + SSSE3, SSE4.1 and SSE4.2. */ +#define GNU_PROPERTY_X86_ISA_1_V2 (1U << 1) +/* GNU_PROPERTY_X86_ISA_1_V3: GNU_PROPERTY_X86_ISA_1_V2, AVX, AVX2, BMI1, + BMI2, F16C, FMA, LZCNT, MOVBE, XSAVE. */ +#define GNU_PROPERTY_X86_ISA_1_V3 (1U << 2) +/* GNU_PROPERTY_X86_ISA_1_V4: GNU_PROPERTY_X86_ISA_1_V3, AVX512F, + AVX512BW, AVX512CD, AVX512DQ and AVX512VL. */ +#define GNU_PROPERTY_X86_ISA_1_V4 (1U << 3) + +/* This indicates that all executable sections are compatible with + IBT. */ +#define GNU_PROPERTY_X86_FEATURE_1_IBT (1U << 0) +/* This indicates that all executable sections are compatible with + SHSTK. */ +#define GNU_PROPERTY_X86_FEATURE_1_SHSTK (1U << 1) + +/* Move records. */ +typedef struct { + Elf32_Xword m_value; /* Symbol value. */ + Elf32_Word m_info; /* Size and index. */ + Elf32_Word m_poffset; /* Symbol offset. */ + Elf32_Half m_repeat; /* Repeat count. */ + Elf32_Half m_stride; /* Stride info. */ +} Elf32_Move; + +typedef struct { + Elf64_Xword m_value; /* Symbol value. */ + Elf64_Xword m_info; /* Size and index. */ + Elf64_Xword m_poffset; /* Symbol offset. */ + Elf64_Half m_repeat; /* Repeat count. */ + Elf64_Half m_stride; /* Stride info. */ +} Elf64_Move; + +/* Macro to construct move records. */ +#define ELF32_M_SYM(info) ((info) >> 8) +#define ELF32_M_SIZE(info) ((unsigned char)(info)) +#define ELF32_M_INFO(sym, size) (((sym) << 8) + (unsigned char)(size)) + +#define ELF64_M_SYM(info) ELF32_M_SYM(info) +#define ELF64_M_SIZE(info) ELF32_M_SIZE(info) +#define ELF64_M_INFO(sym, size) ELF32_M_INFO(sym, size) + +/* Motorola 68k specific definitions. */ + +/* Values for Elf32_Ehdr.e_flags. */ +#define EF_CPU32 0x00810000 + +/* m68k relocs. */ + +#define R_68K_NONE 0 /* No reloc */ +#define R_68K_32 1 /* Direct 32 bit */ +#define R_68K_16 2 /* Direct 16 bit */ +#define R_68K_8 3 /* Direct 8 bit */ +#define R_68K_PC32 4 /* PC relative 32 bit */ +#define R_68K_PC16 5 /* PC relative 16 bit */ +#define R_68K_PC8 6 /* PC relative 8 bit */ +#define R_68K_GOT32 7 /* 32 bit PC relative GOT entry */ +#define R_68K_GOT16 8 /* 16 bit PC relative GOT entry */ +#define R_68K_GOT8 9 /* 8 bit PC relative GOT entry */ +#define R_68K_GOT32O 10 /* 32 bit GOT offset */ +#define R_68K_GOT16O 11 /* 16 bit GOT offset */ +#define R_68K_GOT8O 12 /* 8 bit GOT offset */ +#define R_68K_PLT32 13 /* 32 bit PC relative PLT address */ +#define R_68K_PLT16 14 /* 16 bit PC relative PLT address */ +#define R_68K_PLT8 15 /* 8 bit PC relative PLT address */ +#define R_68K_PLT32O 16 /* 32 bit PLT offset */ +#define R_68K_PLT16O 17 /* 16 bit PLT offset */ +#define R_68K_PLT8O 18 /* 8 bit PLT offset */ +#define R_68K_COPY 19 /* Copy symbol at runtime */ +#define R_68K_GLOB_DAT 20 /* Create GOT entry */ +#define R_68K_JMP_SLOT 21 /* Create PLT entry */ +#define R_68K_RELATIVE 22 /* Adjust by program base */ +#define R_68K_TLS_GD32 25 /* 32 bit GOT offset for GD */ +#define R_68K_TLS_GD16 26 /* 16 bit GOT offset for GD */ +#define R_68K_TLS_GD8 27 /* 8 bit GOT offset for GD */ +#define R_68K_TLS_LDM32 28 /* 32 bit GOT offset for LDM */ +#define R_68K_TLS_LDM16 29 /* 16 bit GOT offset for LDM */ +#define R_68K_TLS_LDM8 30 /* 8 bit GOT offset for LDM */ +#define R_68K_TLS_LDO32 31 /* 32 bit module-relative offset */ +#define R_68K_TLS_LDO16 32 /* 16 bit module-relative offset */ +#define R_68K_TLS_LDO8 33 /* 8 bit module-relative offset */ +#define R_68K_TLS_IE32 34 /* 32 bit GOT offset for IE */ +#define R_68K_TLS_IE16 35 /* 16 bit GOT offset for IE */ +#define R_68K_TLS_IE8 36 /* 8 bit GOT offset for IE */ +#define R_68K_TLS_LE32 \ + 37 /* 32 bit offset relative to + static TLS block */ +#define R_68K_TLS_LE16 \ + 38 /* 16 bit offset relative to + static TLS block */ +#define R_68K_TLS_LE8 \ + 39 /* 8 bit offset relative to + static TLS block */ +#define R_68K_TLS_DTPMOD32 40 /* 32 bit module number */ +#define R_68K_TLS_DTPREL32 41 /* 32 bit module-relative offset */ +#define R_68K_TLS_TPREL32 42 /* 32 bit TP-relative offset */ +/* Keep this the last entry. */ +#define R_68K_NUM 43 + +/* Intel 80386 specific definitions. */ + +/* i386 relocs. */ + +#define R_386_NONE 0 /* No reloc */ +#define R_386_32 1 /* Direct 32 bit */ +#define R_386_PC32 2 /* PC relative 32 bit */ +#define R_386_GOT32 3 /* 32 bit GOT entry */ +#define R_386_PLT32 4 /* 32 bit PLT address */ +#define R_386_COPY 5 /* Copy symbol at runtime */ +#define R_386_GLOB_DAT 6 /* Create GOT entry */ +#define R_386_JMP_SLOT 7 /* Create PLT entry */ +#define R_386_RELATIVE 8 /* Adjust by program base */ +#define R_386_GOTOFF 9 /* 32 bit offset to GOT */ +#define R_386_GOTPC 10 /* 32 bit PC relative offset to GOT */ +#define R_386_32PLT 11 +#define R_386_TLS_TPOFF 14 /* Offset in static TLS block */ +#define R_386_TLS_IE \ + 15 /* Address of GOT entry for static TLS + block offset */ +#define R_386_TLS_GOTIE \ + 16 /* GOT entry for static TLS block + offset */ +#define R_386_TLS_LE \ + 17 /* Offset relative to static TLS + block */ +#define R_386_TLS_GD \ + 18 /* Direct 32 bit for GNU version of + general dynamic thread local data */ +#define R_386_TLS_LDM \ + 19 /* Direct 32 bit for GNU version of + local dynamic thread local data + in LE code */ +#define R_386_16 20 +#define R_386_PC16 21 +#define R_386_8 22 +#define R_386_PC8 23 +#define R_386_TLS_GD_32 \ + 24 /* Direct 32 bit for general dynamic + thread local data */ +#define R_386_TLS_GD_PUSH 25 /* Tag for pushl in GD TLS code */ +#define R_386_TLS_GD_CALL \ + 26 /* Relocation for call to + __tls_get_addr() */ +#define R_386_TLS_GD_POP 27 /* Tag for popl in GD TLS code */ +#define R_386_TLS_LDM_32 \ + 28 /* Direct 32 bit for local dynamic + thread local data in LE code */ +#define R_386_TLS_LDM_PUSH 29 /* Tag for pushl in LDM TLS code */ +#define R_386_TLS_LDM_CALL \ + 30 /* Relocation for call to + __tls_get_addr() in LDM code */ +#define R_386_TLS_LDM_POP 31 /* Tag for popl in LDM TLS code */ +#define R_386_TLS_LDO_32 32 /* Offset relative to TLS block */ +#define R_386_TLS_IE_32 \ + 33 /* GOT entry for negated static TLS + block offset */ +#define R_386_TLS_LE_32 \ + 34 /* Negated offset relative to static + TLS block */ +#define R_386_TLS_DTPMOD32 35 /* ID of module containing symbol */ +#define R_386_TLS_DTPOFF32 36 /* Offset in TLS block */ +#define R_386_TLS_TPOFF32 37 /* Negated offset in static TLS block */ +#define R_386_SIZE32 38 /* 32-bit symbol size */ +#define R_386_TLS_GOTDESC 39 /* GOT offset for TLS descriptor. */ +#define R_386_TLS_DESC_CALL \ + 40 /* Marker of call through TLS + descriptor for + relaxation. */ +#define R_386_TLS_DESC \ + 41 /* TLS descriptor containing + pointer to code and to + argument, returning the TLS + offset for the symbol. */ +#define R_386_IRELATIVE 42 /* Adjust indirectly by program base */ +#define R_386_GOT32X \ + 43 /* Load from 32 bit GOT entry, + relaxable. */ +/* Keep this the last entry. */ +#define R_386_NUM 44 + +/* SUN SPARC specific definitions. */ + +/* Legal values for ST_TYPE subfield of st_info (symbol type). */ + +#define STT_SPARC_REGISTER 13 /* Global register reserved to app. */ + +/* Values for Elf64_Ehdr.e_flags. */ + +#define EF_SPARCV9_MM 3 +#define EF_SPARCV9_TSO 0 +#define EF_SPARCV9_PSO 1 +#define EF_SPARCV9_RMO 2 +#define EF_SPARC_LEDATA 0x800000 /* little endian data */ +#define EF_SPARC_EXT_MASK 0xFFFF00 +#define EF_SPARC_32PLUS 0x000100 /* generic V8+ features */ +#define EF_SPARC_SUN_US1 0x000200 /* Sun UltraSPARC1 extensions */ +#define EF_SPARC_HAL_R1 0x000400 /* HAL R1 extensions */ +#define EF_SPARC_SUN_US3 0x000800 /* Sun UltraSPARCIII extensions */ + +/* SPARC relocs. */ + +#define R_SPARC_NONE 0 /* No reloc */ +#define R_SPARC_8 1 /* Direct 8 bit */ +#define R_SPARC_16 2 /* Direct 16 bit */ +#define R_SPARC_32 3 /* Direct 32 bit */ +#define R_SPARC_DISP8 4 /* PC relative 8 bit */ +#define R_SPARC_DISP16 5 /* PC relative 16 bit */ +#define R_SPARC_DISP32 6 /* PC relative 32 bit */ +#define R_SPARC_WDISP30 7 /* PC relative 30 bit shifted */ +#define R_SPARC_WDISP22 8 /* PC relative 22 bit shifted */ +#define R_SPARC_HI22 9 /* High 22 bit */ +#define R_SPARC_22 10 /* Direct 22 bit */ +#define R_SPARC_13 11 /* Direct 13 bit */ +#define R_SPARC_LO10 12 /* Truncated 10 bit */ +#define R_SPARC_GOT10 13 /* Truncated 10 bit GOT entry */ +#define R_SPARC_GOT13 14 /* 13 bit GOT entry */ +#define R_SPARC_GOT22 15 /* 22 bit GOT entry shifted */ +#define R_SPARC_PC10 16 /* PC relative 10 bit truncated */ +#define R_SPARC_PC22 17 /* PC relative 22 bit shifted */ +#define R_SPARC_WPLT30 18 /* 30 bit PC relative PLT address */ +#define R_SPARC_COPY 19 /* Copy symbol at runtime */ +#define R_SPARC_GLOB_DAT 20 /* Create GOT entry */ +#define R_SPARC_JMP_SLOT 21 /* Create PLT entry */ +#define R_SPARC_RELATIVE 22 /* Adjust by program base */ +#define R_SPARC_UA32 23 /* Direct 32 bit unaligned */ + +/* Additional Sparc64 relocs. */ + +#define R_SPARC_PLT32 24 /* Direct 32 bit ref to PLT entry */ +#define R_SPARC_HIPLT22 25 /* High 22 bit PLT entry */ +#define R_SPARC_LOPLT10 26 /* Truncated 10 bit PLT entry */ +#define R_SPARC_PCPLT32 27 /* PC rel 32 bit ref to PLT entry */ +#define R_SPARC_PCPLT22 28 /* PC rel high 22 bit PLT entry */ +#define R_SPARC_PCPLT10 29 /* PC rel trunc 10 bit PLT entry */ +#define R_SPARC_10 30 /* Direct 10 bit */ +#define R_SPARC_11 31 /* Direct 11 bit */ +#define R_SPARC_64 32 /* Direct 64 bit */ +#define R_SPARC_OLO10 33 /* 10bit with secondary 13bit addend */ +#define R_SPARC_HH22 34 /* Top 22 bits of direct 64 bit */ +#define R_SPARC_HM10 35 /* High middle 10 bits of ... */ +#define R_SPARC_LM22 36 /* Low middle 22 bits of ... */ +#define R_SPARC_PC_HH22 37 /* Top 22 bits of pc rel 64 bit */ +#define R_SPARC_PC_HM10 38 /* High middle 10 bit of ... */ +#define R_SPARC_PC_LM22 39 /* Low miggle 22 bits of ... */ +#define R_SPARC_WDISP16 40 /* PC relative 16 bit shifted */ +#define R_SPARC_WDISP19 41 /* PC relative 19 bit shifted */ +#define R_SPARC_GLOB_JMP 42 /* was part of v9 ABI but was removed */ +#define R_SPARC_7 43 /* Direct 7 bit */ +#define R_SPARC_5 44 /* Direct 5 bit */ +#define R_SPARC_6 45 /* Direct 6 bit */ +#define R_SPARC_DISP64 46 /* PC relative 64 bit */ +#define R_SPARC_PLT64 47 /* Direct 64 bit ref to PLT entry */ +#define R_SPARC_HIX22 48 /* High 22 bit complemented */ +#define R_SPARC_LOX10 49 /* Truncated 11 bit complemented */ +#define R_SPARC_H44 50 /* Direct high 12 of 44 bit */ +#define R_SPARC_M44 51 /* Direct mid 22 of 44 bit */ +#define R_SPARC_L44 52 /* Direct low 10 of 44 bit */ +#define R_SPARC_REGISTER 53 /* Global register usage */ +#define R_SPARC_UA64 54 /* Direct 64 bit unaligned */ +#define R_SPARC_UA16 55 /* Direct 16 bit unaligned */ +#define R_SPARC_TLS_GD_HI22 56 +#define R_SPARC_TLS_GD_LO10 57 +#define R_SPARC_TLS_GD_ADD 58 +#define R_SPARC_TLS_GD_CALL 59 +#define R_SPARC_TLS_LDM_HI22 60 +#define R_SPARC_TLS_LDM_LO10 61 +#define R_SPARC_TLS_LDM_ADD 62 +#define R_SPARC_TLS_LDM_CALL 63 +#define R_SPARC_TLS_LDO_HIX22 64 +#define R_SPARC_TLS_LDO_LOX10 65 +#define R_SPARC_TLS_LDO_ADD 66 +#define R_SPARC_TLS_IE_HI22 67 +#define R_SPARC_TLS_IE_LO10 68 +#define R_SPARC_TLS_IE_LD 69 +#define R_SPARC_TLS_IE_LDX 70 +#define R_SPARC_TLS_IE_ADD 71 +#define R_SPARC_TLS_LE_HIX22 72 +#define R_SPARC_TLS_LE_LOX10 73 +#define R_SPARC_TLS_DTPMOD32 74 +#define R_SPARC_TLS_DTPMOD64 75 +#define R_SPARC_TLS_DTPOFF32 76 +#define R_SPARC_TLS_DTPOFF64 77 +#define R_SPARC_TLS_TPOFF32 78 +#define R_SPARC_TLS_TPOFF64 79 +#define R_SPARC_GOTDATA_HIX22 80 +#define R_SPARC_GOTDATA_LOX10 81 +#define R_SPARC_GOTDATA_OP_HIX22 82 +#define R_SPARC_GOTDATA_OP_LOX10 83 +#define R_SPARC_GOTDATA_OP 84 +#define R_SPARC_H34 85 +#define R_SPARC_SIZE32 86 +#define R_SPARC_SIZE64 87 +#define R_SPARC_WDISP10 88 +#define R_SPARC_JMP_IREL 248 +#define R_SPARC_IRELATIVE 249 +#define R_SPARC_GNU_VTINHERIT 250 +#define R_SPARC_GNU_VTENTRY 251 +#define R_SPARC_REV32 252 +/* Keep this the last entry. */ +#define R_SPARC_NUM 253 + +/* For Sparc64, legal values for d_tag of Elf64_Dyn. */ + +#define DT_SPARC_REGISTER 0x70000001 +#define DT_SPARC_NUM 2 + +/* MIPS R3000 specific definitions. */ + +/* Legal values for e_flags field of Elf32_Ehdr. */ + +#define EF_MIPS_NOREORDER 1 /* A .noreorder directive was used. */ +#define EF_MIPS_PIC 2 /* Contains PIC code. */ +#define EF_MIPS_CPIC 4 /* Uses PIC calling sequence. */ +#define EF_MIPS_XGOT 8 +#define EF_MIPS_UCODE 16 +#define EF_MIPS_ABI2 32 +#define EF_MIPS_ABI_ON32 64 +#define EF_MIPS_OPTIONS_FIRST \ + 0x00000080 /* Process the .MIPS.options + section first by ld. */ +#define EF_MIPS_32BITMODE \ + 0x00000100 /* Indicates code compiled for + a 64-bit machine in 32-bit + mode (regs are 32-bits + wide). */ +#define EF_MIPS_FP64 512 /* Uses FP64 (12 callee-saved). */ +#define EF_MIPS_NAN2008 1024 /* Uses IEEE 754-2008 NaN encoding. */ +#define EF_MIPS_ARCH_ASE \ + 0x0f000000 /* Architectural Extensions + used by this file. */ +#define EF_MIPS_ARCH_ASE_MDMX \ + 0x08000000 /* Use MDMX multimedia + extensions. */ +#define EF_MIPS_ARCH_ASE_M16 \ + 0x04000000 /* Use MIPS-16 ISA + extensions. */ +#define EF_MIPS_ARCH_ASE_MICROMIPS \ + 0x02000000 /* Use MICROMIPS ISA + extensions. */ +#define EF_MIPS_ARCH 0xf0000000 /* MIPS architecture level. */ + +/* Legal values for MIPS architecture level. */ + +#define EF_MIPS_ARCH_1 0x00000000 /* -mips1 code. */ +#define EF_MIPS_ARCH_2 0x10000000 /* -mips2 code. */ +#define EF_MIPS_ARCH_3 0x20000000 /* -mips3 code. */ +#define EF_MIPS_ARCH_4 0x30000000 /* -mips4 code. */ +#define EF_MIPS_ARCH_5 0x40000000 /* -mips5 code. */ +#define EF_MIPS_ARCH_32 0x50000000 /* MIPS32 code. */ +#define EF_MIPS_ARCH_64 0x60000000 /* MIPS64 code. */ +#define EF_MIPS_ARCH_32R2 0x70000000 /* MIPS32r2 code. */ +#define EF_MIPS_ARCH_64R2 0x80000000 /* MIPS64r2 code. */ +#define EF_MIPS_ARCH_32R6 0x90000000 /* MIPS32r6 code. */ +#define EF_MIPS_ARCH_64R6 0xa0000000 /* MIPS64r6 code. */ +#define EF_MIPS_ABI \ + 0x0000F000 /* The ABI of the file. Also + see EF_MIPS_ABI2 above. */ +#define EF_MIPS_ABI_O32 0x00001000 /* The original o32 abi. */ +#define EF_MIPS_ABI_O64 \ + 0x00002000 /* O32 extended to work on + 64 bit architectures. */ +#define EF_MIPS_ABI_EABI32 0x00003000 /* EABI in 32 bit mode. */ +#define EF_MIPS_ABI_EABI64 0x00004000 /* EABI in 64 bit mode. */ +#define EF_MIPS_MACH 0x00FF0000 +#define EF_MIPS_MACH_3900 0x00810000 +#define EF_MIPS_MACH_4010 0x00820000 +#define EF_MIPS_MACH_4100 0x00830000 +#define EF_MIPS_MACH_ALLEGREX 0x00840000 +#define EF_MIPS_MACH_4650 0x00850000 +#define EF_MIPS_MACH_4120 0x00870000 +#define EF_MIPS_MACH_4111 0x00880000 +#define EF_MIPS_MACH_SB1 0x008a0000 +#define EF_MIPS_MACH_OCTEON 0x008b0000 +#define EF_MIPS_MACH_XLR 0x008c0000 +#define EF_MIPS_MACH_OCTEON2 0x008d0000 +#define EF_MIPS_MACH_OCTEON3 0x008e0000 +#define EF_MIPS_MACH_5400 0x00910000 +#define EF_MIPS_MACH_5900 0x00920000 +#define EF_MIPS_MACH_IAMR2 0x00930000 +#define EF_MIPS_MACH_5500 0x00980000 +#define EF_MIPS_MACH_9000 0x00990000 +#define EF_MIPS_MACH_LS2E 0x00A00000 +#define EF_MIPS_MACH_LS2F 0x00A10000 +#define EF_MIPS_MACH_GS464 0x00A20000 +#define EF_MIPS_MACH_GS464E 0x00A30000 +#define EF_MIPS_MACH_GS264E 0x00A40000 + +/* The following are unofficial names and should not be used. */ + +#define E_MIPS_ARCH_1 EF_MIPS_ARCH_1 +#define E_MIPS_ARCH_2 EF_MIPS_ARCH_2 +#define E_MIPS_ARCH_3 EF_MIPS_ARCH_3 +#define E_MIPS_ARCH_4 EF_MIPS_ARCH_4 +#define E_MIPS_ARCH_5 EF_MIPS_ARCH_5 +#define E_MIPS_ARCH_32 EF_MIPS_ARCH_32 +#define E_MIPS_ARCH_64 EF_MIPS_ARCH_64 + +/* Special section indices. */ + +#define SHN_MIPS_ACOMMON 0xff00 /* Allocated common symbols. */ +#define SHN_MIPS_TEXT 0xff01 /* Allocated test symbols. */ +#define SHN_MIPS_DATA 0xff02 /* Allocated data symbols. */ +#define SHN_MIPS_SCOMMON 0xff03 /* Small common symbols. */ +#define SHN_MIPS_SUNDEFINED 0xff04 /* Small undefined symbols. */ + +/* Legal values for sh_type field of Elf32_Shdr. */ + +#define SHT_MIPS_LIBLIST 0x70000000 /* Shared objects used in link. */ +#define SHT_MIPS_MSYM 0x70000001 +#define SHT_MIPS_CONFLICT 0x70000002 /* Conflicting symbols. */ +#define SHT_MIPS_GPTAB 0x70000003 /* Global data area sizes. */ +#define SHT_MIPS_UCODE 0x70000004 /* Reserved for SGI/MIPS compilers */ +#define SHT_MIPS_DEBUG 0x70000005 /* MIPS ECOFF debugging info. */ +#define SHT_MIPS_REGINFO 0x70000006 /* Register usage information. */ +#define SHT_MIPS_PACKAGE 0x70000007 +#define SHT_MIPS_PACKSYM 0x70000008 +#define SHT_MIPS_RELD 0x70000009 +#define SHT_MIPS_IFACE 0x7000000b +#define SHT_MIPS_CONTENT 0x7000000c +#define SHT_MIPS_OPTIONS 0x7000000d /* Miscellaneous options. */ +#define SHT_MIPS_SHDR 0x70000010 +#define SHT_MIPS_FDESC 0x70000011 +#define SHT_MIPS_EXTSYM 0x70000012 +#define SHT_MIPS_DENSE 0x70000013 +#define SHT_MIPS_PDESC 0x70000014 +#define SHT_MIPS_LOCSYM 0x70000015 +#define SHT_MIPS_AUXSYM 0x70000016 +#define SHT_MIPS_OPTSYM 0x70000017 +#define SHT_MIPS_LOCSTR 0x70000018 +#define SHT_MIPS_LINE 0x70000019 +#define SHT_MIPS_RFDESC 0x7000001a +#define SHT_MIPS_DELTASYM 0x7000001b +#define SHT_MIPS_DELTAINST 0x7000001c +#define SHT_MIPS_DELTACLASS 0x7000001d +#define SHT_MIPS_DWARF 0x7000001e /* DWARF debugging information. */ +#define SHT_MIPS_DELTADECL 0x7000001f +#define SHT_MIPS_SYMBOL_LIB 0x70000020 +#define SHT_MIPS_EVENTS 0x70000021 /* Event section. */ +#define SHT_MIPS_TRANSLATE 0x70000022 +#define SHT_MIPS_PIXIE 0x70000023 +#define SHT_MIPS_XLATE 0x70000024 +#define SHT_MIPS_XLATE_DEBUG 0x70000025 +#define SHT_MIPS_WHIRL 0x70000026 +#define SHT_MIPS_EH_REGION 0x70000027 +#define SHT_MIPS_XLATE_OLD 0x70000028 +#define SHT_MIPS_PDR_EXCEPTION 0x70000029 +#define SHT_MIPS_ABIFLAGS 0x7000002a +#define SHT_MIPS_XHASH 0x7000002b + +/* Legal values for sh_flags field of Elf32_Shdr. */ + +#define SHF_MIPS_GPREL 0x10000000 /* Must be in global data area. */ +#define SHF_MIPS_MERGE 0x20000000 +#define SHF_MIPS_ADDR 0x40000000 +#define SHF_MIPS_STRINGS 0x80000000 +#define SHF_MIPS_NOSTRIP 0x08000000 +#define SHF_MIPS_LOCAL 0x04000000 +#define SHF_MIPS_NAMES 0x02000000 +#define SHF_MIPS_NODUPE 0x01000000 + +/* Symbol tables. */ + +/* MIPS specific values for `st_other'. */ +#define STO_MIPS_DEFAULT 0x0 +#define STO_MIPS_INTERNAL 0x1 +#define STO_MIPS_HIDDEN 0x2 +#define STO_MIPS_PROTECTED 0x3 +#define STO_MIPS_PLT 0x8 +#define STO_MIPS_SC_ALIGN_UNUSED 0xff + +/* MIPS specific values for `st_info'. */ +#define STB_MIPS_SPLIT_COMMON 13 + +/* Entries found in sections of type SHT_MIPS_GPTAB. */ + +typedef union { + struct { + Elf32_Word gt_current_g_value; /* -G value used for compilation. */ + Elf32_Word gt_unused; /* Not used. */ + } gt_header; /* First entry in section. */ + struct { + Elf32_Word gt_g_value; /* If this value were used for -G. */ + Elf32_Word gt_bytes; /* This many bytes would be used. */ + } gt_entry; /* Subsequent entries in section. */ +} Elf32_gptab; + +/* Entry found in sections of type SHT_MIPS_REGINFO. */ + +typedef struct { + Elf32_Word ri_gprmask; /* General registers used. */ + Elf32_Word ri_cprmask[4]; /* Coprocessor registers used. */ + Elf32_Sword ri_gp_value; /* $gp register value. */ +} Elf32_RegInfo; + +/* Entries found in sections of type SHT_MIPS_OPTIONS. */ + +typedef struct { + unsigned char kind; /* Determines interpretation of the + variable part of descriptor. */ + unsigned char size; /* Size of descriptor, including header. */ + Elf32_Section section; /* Section header index of section affected, + 0 for global options. */ + Elf32_Word info; /* Kind-specific information. */ +} Elf_Options; + +/* Values for `kind' field in Elf_Options. */ + +#define ODK_NULL 0 /* Undefined. */ +#define ODK_REGINFO 1 /* Register usage information. */ +#define ODK_EXCEPTIONS 2 /* Exception processing options. */ +#define ODK_PAD 3 /* Section padding options. */ +#define ODK_HWPATCH 4 /* Hardware workarounds performed */ +#define ODK_FILL 5 /* record the fill value used by the linker. */ +#define ODK_TAGS 6 /* reserve space for desktop tools to write. */ +#define ODK_HWAND 7 /* HW workarounds. 'AND' bits when merging. */ +#define ODK_HWOR 8 /* HW workarounds. 'OR' bits when merging. */ + +/* Values for `info' in Elf_Options for ODK_EXCEPTIONS entries. */ + +#define OEX_FPU_MIN 0x1f /* FPE's which MUST be enabled. */ +#define OEX_FPU_MAX 0x1f00 /* FPE's which MAY be enabled. */ +#define OEX_PAGE0 0x10000 /* page zero must be mapped. */ +#define OEX_SMM 0x20000 /* Force sequential memory mode? */ +#define OEX_FPDBUG 0x40000 /* Force floating point debug mode? */ +#define OEX_PRECISEFP OEX_FPDBUG +#define OEX_DISMISS 0x80000 /* Dismiss invalid address faults? */ + +#define OEX_FPU_INVAL 0x10 +#define OEX_FPU_DIV0 0x08 +#define OEX_FPU_OFLO 0x04 +#define OEX_FPU_UFLO 0x02 +#define OEX_FPU_INEX 0x01 + +/* Masks for `info' in Elf_Options for an ODK_HWPATCH entry. */ + +#define OHW_R4KEOP 0x1 /* R4000 end-of-page patch. */ +#define OHW_R8KPFETCH 0x2 /* may need R8000 prefetch patch. */ +#define OHW_R5KEOP 0x4 /* R5000 end-of-page patch. */ +#define OHW_R5KCVTL 0x8 /* R5000 cvt.[ds].l bug. clean=1. */ + +#define OPAD_PREFIX 0x1 +#define OPAD_POSTFIX 0x2 +#define OPAD_SYMBOL 0x4 + +/* Entry found in `.options' section. */ + +typedef struct { + Elf32_Word hwp_flags1; /* Extra flags. */ + Elf32_Word hwp_flags2; /* Extra flags. */ +} Elf_Options_Hw; + +/* Masks for `info' in ElfOptions for ODK_HWAND and ODK_HWOR entries. */ + +#define OHWA0_R4KEOP_CHECKED 0x00000001 +#define OHWA1_R4KEOP_CLEAN 0x00000002 + +/* MIPS relocs. */ + +#define R_MIPS_NONE 0 /* No reloc */ +#define R_MIPS_16 1 /* Direct 16 bit */ +#define R_MIPS_32 2 /* Direct 32 bit */ +#define R_MIPS_REL32 3 /* PC relative 32 bit */ +#define R_MIPS_26 4 /* Direct 26 bit shifted */ +#define R_MIPS_HI16 5 /* High 16 bit */ +#define R_MIPS_LO16 6 /* Low 16 bit */ +#define R_MIPS_GPREL16 7 /* GP relative 16 bit */ +#define R_MIPS_LITERAL 8 /* 16 bit literal entry */ +#define R_MIPS_GOT16 9 /* 16 bit GOT entry */ +#define R_MIPS_PC16 10 /* PC relative 16 bit */ +#define R_MIPS_CALL16 11 /* 16 bit GOT entry for function */ +#define R_MIPS_GPREL32 12 /* GP relative 32 bit */ + +#define R_MIPS_SHIFT5 16 +#define R_MIPS_SHIFT6 17 +#define R_MIPS_64 18 +#define R_MIPS_GOT_DISP 19 +#define R_MIPS_GOT_PAGE 20 +#define R_MIPS_GOT_OFST 21 +#define R_MIPS_GOT_HI16 22 +#define R_MIPS_GOT_LO16 23 +#define R_MIPS_SUB 24 +#define R_MIPS_INSERT_A 25 +#define R_MIPS_INSERT_B 26 +#define R_MIPS_DELETE 27 +#define R_MIPS_HIGHER 28 +#define R_MIPS_HIGHEST 29 +#define R_MIPS_CALL_HI16 30 +#define R_MIPS_CALL_LO16 31 +#define R_MIPS_SCN_DISP 32 +#define R_MIPS_REL16 33 +#define R_MIPS_ADD_IMMEDIATE 34 +#define R_MIPS_PJUMP 35 +#define R_MIPS_RELGOT 36 +#define R_MIPS_JALR 37 +#define R_MIPS_TLS_DTPMOD32 38 /* Module number 32 bit */ +#define R_MIPS_TLS_DTPREL32 39 /* Module-relative offset 32 bit */ +#define R_MIPS_TLS_DTPMOD64 40 /* Module number 64 bit */ +#define R_MIPS_TLS_DTPREL64 41 /* Module-relative offset 64 bit */ +#define R_MIPS_TLS_GD 42 /* 16 bit GOT offset for GD */ +#define R_MIPS_TLS_LDM 43 /* 16 bit GOT offset for LDM */ +#define R_MIPS_TLS_DTPREL_HI16 44 /* Module-relative offset, high 16 bits */ +#define R_MIPS_TLS_DTPREL_LO16 45 /* Module-relative offset, low 16 bits */ +#define R_MIPS_TLS_GOTTPREL 46 /* 16 bit GOT offset for IE */ +#define R_MIPS_TLS_TPREL32 47 /* TP-relative offset, 32 bit */ +#define R_MIPS_TLS_TPREL64 48 /* TP-relative offset, 64 bit */ +#define R_MIPS_TLS_TPREL_HI16 49 /* TP-relative offset, high 16 bits */ +#define R_MIPS_TLS_TPREL_LO16 50 /* TP-relative offset, low 16 bits */ +#define R_MIPS_GLOB_DAT 51 +#define R_MIPS_PC21_S2 60 +#define R_MIPS_PC26_S2 61 +#define R_MIPS_PC18_S3 62 +#define R_MIPS_PC19_S2 63 +#define R_MIPS_PCHI16 64 +#define R_MIPS_PCLO16 65 +#define R_MIPS16_26 100 +#define R_MIPS16_GPREL 101 +#define R_MIPS16_GOT16 102 +#define R_MIPS16_CALL16 103 +#define R_MIPS16_HI16 104 +#define R_MIPS16_LO16 105 +#define R_MIPS16_TLS_GD 106 +#define R_MIPS16_TLS_LDM 107 +#define R_MIPS16_TLS_DTPREL_HI16 108 +#define R_MIPS16_TLS_DTPREL_LO16 109 +#define R_MIPS16_TLS_GOTTPREL 110 +#define R_MIPS16_TLS_TPREL_HI16 111 +#define R_MIPS16_TLS_TPREL_LO16 112 +#define R_MIPS16_PC16_S1 113 +#define R_MIPS_COPY 126 +#define R_MIPS_JUMP_SLOT 127 +#define R_MIPS_RELATIVE 128 +#define R_MICROMIPS_26_S1 133 +#define R_MICROMIPS_HI16 134 +#define R_MICROMIPS_LO16 135 +#define R_MICROMIPS_GPREL16 136 +#define R_MICROMIPS_LITERAL 137 +#define R_MICROMIPS_GOT16 138 +#define R_MICROMIPS_PC7_S1 139 +#define R_MICROMIPS_PC10_S1 140 +#define R_MICROMIPS_PC16_S1 141 +#define R_MICROMIPS_CALL16 142 +#define R_MICROMIPS_GOT_DISP 145 +#define R_MICROMIPS_GOT_PAGE 146 +#define R_MICROMIPS_GOT_OFST 147 +#define R_MICROMIPS_GOT_HI16 148 +#define R_MICROMIPS_GOT_LO16 149 +#define R_MICROMIPS_SUB 150 +#define R_MICROMIPS_HIGHER 151 +#define R_MICROMIPS_HIGHEST 152 +#define R_MICROMIPS_CALL_HI16 153 +#define R_MICROMIPS_CALL_LO16 154 +#define R_MICROMIPS_SCN_DISP 155 +#define R_MICROMIPS_JALR 156 +#define R_MICROMIPS_HI0_LO16 157 +#define R_MICROMIPS_TLS_GD 162 +#define R_MICROMIPS_TLS_LDM 163 +#define R_MICROMIPS_TLS_DTPREL_HI16 164 +#define R_MICROMIPS_TLS_DTPREL_LO16 165 +#define R_MICROMIPS_TLS_GOTTPREL 166 +#define R_MICROMIPS_TLS_TPREL_HI16 169 +#define R_MICROMIPS_TLS_TPREL_LO16 170 +#define R_MICROMIPS_GPREL7_S2 172 +#define R_MICROMIPS_PC23_S2 173 +#define R_MIPS_PC32 248 +#define R_MIPS_EH 249 +#define R_MIPS_GNU_REL16_S2 250 +#define R_MIPS_GNU_VTINHERIT 253 +#define R_MIPS_GNU_VTENTRY 254 +/* Keep this the last entry. */ +#define R_MIPS_NUM 255 + +/* Legal values for p_type field of Elf32_Phdr. */ + +#define PT_MIPS_REGINFO 0x70000000 /* Register usage information. */ +#define PT_MIPS_RTPROC 0x70000001 /* Runtime procedure table. */ +#define PT_MIPS_OPTIONS 0x70000002 +#define PT_MIPS_ABIFLAGS 0x70000003 /* FP mode requirement. */ + +/* Special program header types. */ + +#define PF_MIPS_LOCAL 0x10000000 + +/* Legal values for d_tag field of Elf32_Dyn. */ + +#define DT_MIPS_RLD_VERSION 0x70000001 /* Runtime linker interface version */ +#define DT_MIPS_TIME_STAMP 0x70000002 /* Timestamp */ +#define DT_MIPS_ICHECKSUM 0x70000003 /* Checksum */ +#define DT_MIPS_IVERSION 0x70000004 /* Version string (string tbl index) */ +#define DT_MIPS_FLAGS 0x70000005 /* Flags */ +#define DT_MIPS_BASE_ADDRESS 0x70000006 /* Base address */ +#define DT_MIPS_MSYM 0x70000007 +#define DT_MIPS_CONFLICT 0x70000008 /* Address of CONFLICT section */ +#define DT_MIPS_LIBLIST 0x70000009 /* Address of LIBLIST section */ +#define DT_MIPS_LOCAL_GOTNO 0x7000000a /* Number of local GOT entries */ +#define DT_MIPS_CONFLICTNO 0x7000000b /* Number of CONFLICT entries */ +#define DT_MIPS_LIBLISTNO 0x70000010 /* Number of LIBLIST entries */ +#define DT_MIPS_SYMTABNO 0x70000011 /* Number of DYNSYM entries */ +#define DT_MIPS_UNREFEXTNO 0x70000012 /* First external DYNSYM */ +#define DT_MIPS_GOTSYM 0x70000013 /* First GOT entry in DYNSYM */ +#define DT_MIPS_HIPAGENO 0x70000014 /* Number of GOT page table entries */ +#define DT_MIPS_RLD_MAP 0x70000016 /* Address of run time loader map. */ +#define DT_MIPS_DELTA_CLASS 0x70000017 /* Delta C++ class definition. */ +#define DT_MIPS_DELTA_CLASS_NO \ + 0x70000018 /* Number of entries in + DT_MIPS_DELTA_CLASS. */ +#define DT_MIPS_DELTA_INSTANCE 0x70000019 /* Delta C++ class instances. */ +#define DT_MIPS_DELTA_INSTANCE_NO \ + 0x7000001a /* Number of entries in + DT_MIPS_DELTA_INSTANCE. */ +#define DT_MIPS_DELTA_RELOC 0x7000001b /* Delta relocations. */ +#define DT_MIPS_DELTA_RELOC_NO \ + 0x7000001c /* Number of entries in + DT_MIPS_DELTA_RELOC. */ +#define DT_MIPS_DELTA_SYM \ + 0x7000001d /* Delta symbols that Delta + relocations refer to. */ +#define DT_MIPS_DELTA_SYM_NO \ + 0x7000001e /* Number of entries in + DT_MIPS_DELTA_SYM. */ +#define DT_MIPS_DELTA_CLASSSYM \ + 0x70000020 /* Delta symbols that hold the + class declaration. */ +#define DT_MIPS_DELTA_CLASSSYM_NO \ + 0x70000021 /* Number of entries in + DT_MIPS_DELTA_CLASSSYM. */ +#define DT_MIPS_CXX_FLAGS 0x70000022 /* Flags indicating for C++ flavor. */ +#define DT_MIPS_PIXIE_INIT 0x70000023 +#define DT_MIPS_SYMBOL_LIB 0x70000024 +#define DT_MIPS_LOCALPAGE_GOTIDX 0x70000025 +#define DT_MIPS_LOCAL_GOTIDX 0x70000026 +#define DT_MIPS_HIDDEN_GOTIDX 0x70000027 +#define DT_MIPS_PROTECTED_GOTIDX 0x70000028 +#define DT_MIPS_OPTIONS 0x70000029 /* Address of .options. */ +#define DT_MIPS_INTERFACE 0x7000002a /* Address of .interface. */ +#define DT_MIPS_DYNSTR_ALIGN 0x7000002b +#define DT_MIPS_INTERFACE_SIZE 0x7000002c /* Size of the .interface section. */ +#define DT_MIPS_RLD_TEXT_RESOLVE_ADDR \ + 0x7000002d /* Address of rld_text_rsolve + function stored in GOT. */ +#define DT_MIPS_PERF_SUFFIX \ + 0x7000002e /* Default suffix of dso to be added + by rld on dlopen() calls. */ +#define DT_MIPS_COMPACT_SIZE 0x7000002f /* (O32)Size of compact rel section. */ +#define DT_MIPS_GP_VALUE 0x70000030 /* GP value for aux GOTs. */ +#define DT_MIPS_AUX_DYNAMIC 0x70000031 /* Address of aux .dynamic. */ +/* The address of .got.plt in an executable using the new non-PIC ABI. */ +#define DT_MIPS_PLTGOT 0x70000032 +/* The base of the PLT in an executable using the new non-PIC ABI if that + PLT is writable. For a non-writable PLT, this is omitted or has a zero + value. */ +#define DT_MIPS_RWPLT 0x70000034 +/* An alternative description of the classic MIPS RLD_MAP that is usable + in a PIE as it stores a relative offset from the address of the tag + rather than an absolute address. */ +#define DT_MIPS_RLD_MAP_REL 0x70000035 +/* GNU-style hash table with xlat. */ +#define DT_MIPS_XHASH 0x70000036 +#define DT_MIPS_NUM 0x37 + +/* Legal values for DT_MIPS_FLAGS Elf32_Dyn entry. */ + +#define RHF_NONE 0 /* No flags */ +#define RHF_QUICKSTART (1 << 0) /* Use quickstart */ +#define RHF_NOTPOT (1 << 1) /* Hash size not power of 2 */ +#define RHF_NO_LIBRARY_REPLACEMENT (1 << 2) /* Ignore LD_LIBRARY_PATH */ +#define RHF_NO_MOVE (1 << 3) +#define RHF_SGI_ONLY (1 << 4) +#define RHF_GUARANTEE_INIT (1 << 5) +#define RHF_DELTA_C_PLUS_PLUS (1 << 6) +#define RHF_GUARANTEE_START_INIT (1 << 7) +#define RHF_PIXIE (1 << 8) +#define RHF_DEFAULT_DELAY_LOAD (1 << 9) +#define RHF_REQUICKSTART (1 << 10) +#define RHF_REQUICKSTARTED (1 << 11) +#define RHF_CORD (1 << 12) +#define RHF_NO_UNRES_UNDEF (1 << 13) +#define RHF_RLD_ORDER_SAFE (1 << 14) + +/* Entries found in sections of type SHT_MIPS_LIBLIST. */ + +typedef struct { + Elf32_Word l_name; /* Name (string table index) */ + Elf32_Word l_time_stamp; /* Timestamp */ + Elf32_Word l_checksum; /* Checksum */ + Elf32_Word l_version; /* Interface version */ + Elf32_Word l_flags; /* Flags */ +} Elf32_Lib; + +typedef struct { + Elf64_Word l_name; /* Name (string table index) */ + Elf64_Word l_time_stamp; /* Timestamp */ + Elf64_Word l_checksum; /* Checksum */ + Elf64_Word l_version; /* Interface version */ + Elf64_Word l_flags; /* Flags */ +} Elf64_Lib; + +/* Legal values for l_flags. */ + +#define LL_NONE 0 +#define LL_EXACT_MATCH (1 << 0) /* Require exact match */ +#define LL_IGNORE_INT_VER (1 << 1) /* Ignore interface version */ +#define LL_REQUIRE_MINOR (1 << 2) +#define LL_EXPORTS (1 << 3) +#define LL_DELAY_LOAD (1 << 4) +#define LL_DELTA (1 << 5) + +/* Entries found in sections of type SHT_MIPS_CONFLICT. */ + +typedef Elf32_Addr Elf32_Conflict; + +typedef struct { + /* Version of flags structure. */ + Elf32_Half version; + /* The level of the ISA: 1-5, 32, 64. */ + unsigned char isa_level; + /* The revision of ISA: 0 for MIPS V and below, 1-n otherwise. */ + unsigned char isa_rev; + /* The size of general purpose registers. */ + unsigned char gpr_size; + /* The size of co-processor 1 registers. */ + unsigned char cpr1_size; + /* The size of co-processor 2 registers. */ + unsigned char cpr2_size; + /* The floating-point ABI. */ + unsigned char fp_abi; + /* Processor-specific extension. */ + Elf32_Word isa_ext; + /* Mask of ASEs used. */ + Elf32_Word ases; + /* Mask of general flags. */ + Elf32_Word flags1; + Elf32_Word flags2; +} Elf_MIPS_ABIFlags_v0; + +/* Values for the register size bytes of an abi flags structure. */ + +#define MIPS_AFL_REG_NONE 0x00 /* No registers. */ +#define MIPS_AFL_REG_32 0x01 /* 32-bit registers. */ +#define MIPS_AFL_REG_64 0x02 /* 64-bit registers. */ +#define MIPS_AFL_REG_128 0x03 /* 128-bit registers. */ + +/* Masks for the ases word of an ABI flags structure. */ + +#define MIPS_AFL_ASE_DSP 0x00000001 /* DSP ASE. */ +#define MIPS_AFL_ASE_DSPR2 0x00000002 /* DSP R2 ASE. */ +#define MIPS_AFL_ASE_EVA 0x00000004 /* Enhanced VA Scheme. */ +#define MIPS_AFL_ASE_MCU 0x00000008 /* MCU (MicroController) ASE. */ +#define MIPS_AFL_ASE_MDMX 0x00000010 /* MDMX ASE. */ +#define MIPS_AFL_ASE_MIPS3D 0x00000020 /* MIPS-3D ASE. */ +#define MIPS_AFL_ASE_MT 0x00000040 /* MT ASE. */ +#define MIPS_AFL_ASE_SMARTMIPS 0x00000080 /* SmartMIPS ASE. */ +#define MIPS_AFL_ASE_VIRT 0x00000100 /* VZ ASE. */ +#define MIPS_AFL_ASE_MSA 0x00000200 /* MSA ASE. */ +#define MIPS_AFL_ASE_MIPS16 0x00000400 /* MIPS16 ASE. */ +#define MIPS_AFL_ASE_MICROMIPS 0x00000800 /* MICROMIPS ASE. */ +#define MIPS_AFL_ASE_XPA 0x00001000 /* XPA ASE. */ +#define MIPS_AFL_ASE_MASK 0x00001fff /* All ASEs. */ + +/* Values for the isa_ext word of an ABI flags structure. */ + +#define MIPS_AFL_EXT_XLR 1 /* RMI Xlr instruction. */ +#define MIPS_AFL_EXT_OCTEON2 2 /* Cavium Networks Octeon2. */ +#define MIPS_AFL_EXT_OCTEONP 3 /* Cavium Networks OcteonP. */ +#define MIPS_AFL_EXT_LOONGSON_3A 4 /* Loongson 3A. */ +#define MIPS_AFL_EXT_OCTEON 5 /* Cavium Networks Octeon. */ +#define MIPS_AFL_EXT_5900 6 /* MIPS R5900 instruction. */ +#define MIPS_AFL_EXT_4650 7 /* MIPS R4650 instruction. */ +#define MIPS_AFL_EXT_4010 8 /* LSI R4010 instruction. */ +#define MIPS_AFL_EXT_4100 9 /* NEC VR4100 instruction. */ +#define MIPS_AFL_EXT_3900 10 /* Toshiba R3900 instruction. */ +#define MIPS_AFL_EXT_10000 11 /* MIPS R10000 instruction. */ +#define MIPS_AFL_EXT_SB1 12 /* Broadcom SB-1 instruction. */ +#define MIPS_AFL_EXT_4111 13 /* NEC VR4111/VR4181 instruction. */ +#define MIPS_AFL_EXT_4120 14 /* NEC VR4120 instruction. */ +#define MIPS_AFL_EXT_5400 15 /* NEC VR5400 instruction. */ +#define MIPS_AFL_EXT_5500 16 /* NEC VR5500 instruction. */ +#define MIPS_AFL_EXT_LOONGSON_2E 17 /* ST Microelectronics Loongson 2E. */ +#define MIPS_AFL_EXT_LOONGSON_2F 18 /* ST Microelectronics Loongson 2F. */ + +/* Masks for the flags1 word of an ABI flags structure. */ +#define MIPS_AFL_FLAGS1_ODDSPREG 1 /* Uses odd single-precision registers. */ + +/* Object attribute values. */ +enum { + /* Not tagged or not using any ABIs affected by the differences. */ + Val_GNU_MIPS_ABI_FP_ANY = 0, + /* Using hard-float -mdouble-float. */ + Val_GNU_MIPS_ABI_FP_DOUBLE = 1, + /* Using hard-float -msingle-float. */ + Val_GNU_MIPS_ABI_FP_SINGLE = 2, + /* Using soft-float. */ + Val_GNU_MIPS_ABI_FP_SOFT = 3, + /* Using -mips32r2 -mfp64. */ + Val_GNU_MIPS_ABI_FP_OLD_64 = 4, + /* Using -mfpxx. */ + Val_GNU_MIPS_ABI_FP_XX = 5, + /* Using -mips32r2 -mfp64. */ + Val_GNU_MIPS_ABI_FP_64 = 6, + /* Using -mips32r2 -mfp64 -mno-odd-spreg. */ + Val_GNU_MIPS_ABI_FP_64A = 7, + /* Maximum allocated FP ABI value. */ + Val_GNU_MIPS_ABI_FP_MAX = 7 +}; + +/* HPPA specific definitions. */ + +/* Legal values for e_flags field of Elf32_Ehdr. */ + +#define EF_PARISC_TRAPNIL 0x00010000 /* Trap nil pointer dereference. */ +#define EF_PARISC_EXT 0x00020000 /* Program uses arch. extensions. */ +#define EF_PARISC_LSB 0x00040000 /* Program expects little endian. */ +#define EF_PARISC_WIDE 0x00080000 /* Program expects wide mode. */ +#define EF_PARISC_NO_KABP \ + 0x00100000 /* No kernel assisted branch + prediction. */ +#define EF_PARISC_LAZYSWAP 0x00400000 /* Allow lazy swapping. */ +#define EF_PARISC_ARCH 0x0000ffff /* Architecture version. */ + +/* Defined values for `e_flags & EF_PARISC_ARCH' are: */ + +#define EFA_PARISC_1_0 0x020b /* PA-RISC 1.0 big-endian. */ +#define EFA_PARISC_1_1 0x0210 /* PA-RISC 1.1 big-endian. */ +#define EFA_PARISC_2_0 0x0214 /* PA-RISC 2.0 big-endian. */ + +/* Additional section indices. */ + +#define SHN_PARISC_ANSI_COMMON \ + 0xff00 /* Section for tentatively declared + symbols in ANSI C. */ +#define SHN_PARISC_HUGE_COMMON 0xff01 /* Common blocks in huge model. */ + +/* Legal values for sh_type field of Elf32_Shdr. */ + +#define SHT_PARISC_EXT 0x70000000 /* Contains product specific ext. */ +#define SHT_PARISC_UNWIND 0x70000001 /* Unwind information. */ +#define SHT_PARISC_DOC 0x70000002 /* Debug info for optimized code. */ + +/* Legal values for sh_flags field of Elf32_Shdr. */ + +#define SHF_PARISC_SHORT 0x20000000 /* Section with short addressing. */ +#define SHF_PARISC_HUGE 0x40000000 /* Section far from gp. */ +#define SHF_PARISC_SBP 0x80000000 /* Static branch prediction code. */ + +/* Legal values for ST_TYPE subfield of st_info (symbol type). */ + +#define STT_PARISC_MILLICODE 13 /* Millicode function entry point. */ + +#define STT_HP_OPAQUE (STT_LOOS + 0x1) +#define STT_HP_STUB (STT_LOOS + 0x2) + +/* HPPA relocs. */ + +#define R_PARISC_NONE 0 /* No reloc. */ +#define R_PARISC_DIR32 1 /* Direct 32-bit reference. */ +#define R_PARISC_DIR21L 2 /* Left 21 bits of eff. address. */ +#define R_PARISC_DIR17R 3 /* Right 17 bits of eff. address. */ +#define R_PARISC_DIR17F 4 /* 17 bits of eff. address. */ +#define R_PARISC_DIR14R 6 /* Right 14 bits of eff. address. */ +#define R_PARISC_PCREL32 9 /* 32-bit rel. address. */ +#define R_PARISC_PCREL21L 10 /* Left 21 bits of rel. address. */ +#define R_PARISC_PCREL17R 11 /* Right 17 bits of rel. address. */ +#define R_PARISC_PCREL17F 12 /* 17 bits of rel. address. */ +#define R_PARISC_PCREL14R 14 /* Right 14 bits of rel. address. */ +#define R_PARISC_DPREL21L 18 /* Left 21 bits of rel. address. */ +#define R_PARISC_DPREL14R 22 /* Right 14 bits of rel. address. */ +#define R_PARISC_GPREL21L 26 /* GP-relative, left 21 bits. */ +#define R_PARISC_GPREL14R 30 /* GP-relative, right 14 bits. */ +#define R_PARISC_LTOFF21L 34 /* LT-relative, left 21 bits. */ +#define R_PARISC_LTOFF14R 38 /* LT-relative, right 14 bits. */ +#define R_PARISC_SECREL32 41 /* 32 bits section rel. address. */ +#define R_PARISC_SEGBASE 48 /* No relocation, set segment base. */ +#define R_PARISC_SEGREL32 49 /* 32 bits segment rel. address. */ +#define R_PARISC_PLTOFF21L 50 /* PLT rel. address, left 21 bits. */ +#define R_PARISC_PLTOFF14R 54 /* PLT rel. address, right 14 bits. */ +#define R_PARISC_LTOFF_FPTR32 57 /* 32 bits LT-rel. function pointer. */ +#define R_PARISC_LTOFF_FPTR21L 58 /* LT-rel. fct ptr, left 21 bits. */ +#define R_PARISC_LTOFF_FPTR14R 62 /* LT-rel. fct ptr, right 14 bits. */ +#define R_PARISC_FPTR64 64 /* 64 bits function address. */ +#define R_PARISC_PLABEL32 65 /* 32 bits function address. */ +#define R_PARISC_PLABEL21L 66 /* Left 21 bits of fdesc address. */ +#define R_PARISC_PLABEL14R 70 /* Right 14 bits of fdesc address. */ +#define R_PARISC_PCREL64 72 /* 64 bits PC-rel. address. */ +#define R_PARISC_PCREL22F 74 /* 22 bits PC-rel. address. */ +#define R_PARISC_PCREL14WR 75 /* PC-rel. address, right 14 bits. */ +#define R_PARISC_PCREL14DR 76 /* PC rel. address, right 14 bits. */ +#define R_PARISC_PCREL16F 77 /* 16 bits PC-rel. address. */ +#define R_PARISC_PCREL16WF 78 /* 16 bits PC-rel. address. */ +#define R_PARISC_PCREL16DF 79 /* 16 bits PC-rel. address. */ +#define R_PARISC_DIR64 80 /* 64 bits of eff. address. */ +#define R_PARISC_DIR14WR 83 /* 14 bits of eff. address. */ +#define R_PARISC_DIR14DR 84 /* 14 bits of eff. address. */ +#define R_PARISC_DIR16F 85 /* 16 bits of eff. address. */ +#define R_PARISC_DIR16WF 86 /* 16 bits of eff. address. */ +#define R_PARISC_DIR16DF 87 /* 16 bits of eff. address. */ +#define R_PARISC_GPREL64 88 /* 64 bits of GP-rel. address. */ +#define R_PARISC_GPREL14WR 91 /* GP-rel. address, right 14 bits. */ +#define R_PARISC_GPREL14DR 92 /* GP-rel. address, right 14 bits. */ +#define R_PARISC_GPREL16F 93 /* 16 bits GP-rel. address. */ +#define R_PARISC_GPREL16WF 94 /* 16 bits GP-rel. address. */ +#define R_PARISC_GPREL16DF 95 /* 16 bits GP-rel. address. */ +#define R_PARISC_LTOFF64 96 /* 64 bits LT-rel. address. */ +#define R_PARISC_LTOFF14WR 99 /* LT-rel. address, right 14 bits. */ +#define R_PARISC_LTOFF14DR 100 /* LT-rel. address, right 14 bits. */ +#define R_PARISC_LTOFF16F 101 /* 16 bits LT-rel. address. */ +#define R_PARISC_LTOFF16WF 102 /* 16 bits LT-rel. address. */ +#define R_PARISC_LTOFF16DF 103 /* 16 bits LT-rel. address. */ +#define R_PARISC_SECREL64 104 /* 64 bits section rel. address. */ +#define R_PARISC_SEGREL64 112 /* 64 bits segment rel. address. */ +#define R_PARISC_PLTOFF14WR 115 /* PLT-rel. address, right 14 bits. */ +#define R_PARISC_PLTOFF14DR 116 /* PLT-rel. address, right 14 bits. */ +#define R_PARISC_PLTOFF16F 117 /* 16 bits LT-rel. address. */ +#define R_PARISC_PLTOFF16WF 118 /* 16 bits PLT-rel. address. */ +#define R_PARISC_PLTOFF16DF 119 /* 16 bits PLT-rel. address. */ +#define R_PARISC_LTOFF_FPTR64 120 /* 64 bits LT-rel. function ptr. */ +#define R_PARISC_LTOFF_FPTR14WR 123 /* LT-rel. fct. ptr., right 14 bits. */ +#define R_PARISC_LTOFF_FPTR14DR 124 /* LT-rel. fct. ptr., right 14 bits. */ +#define R_PARISC_LTOFF_FPTR16F 125 /* 16 bits LT-rel. function ptr. */ +#define R_PARISC_LTOFF_FPTR16WF 126 /* 16 bits LT-rel. function ptr. */ +#define R_PARISC_LTOFF_FPTR16DF 127 /* 16 bits LT-rel. function ptr. */ +#define R_PARISC_LORESERVE 128 +#define R_PARISC_COPY 128 /* Copy relocation. */ +#define R_PARISC_IPLT 129 /* Dynamic reloc, imported PLT */ +#define R_PARISC_EPLT 130 /* Dynamic reloc, exported PLT */ +#define R_PARISC_TPREL32 153 /* 32 bits TP-rel. address. */ +#define R_PARISC_TPREL21L 154 /* TP-rel. address, left 21 bits. */ +#define R_PARISC_TPREL14R 158 /* TP-rel. address, right 14 bits. */ +#define R_PARISC_LTOFF_TP21L 162 /* LT-TP-rel. address, left 21 bits. */ +#define R_PARISC_LTOFF_TP14R 166 /* LT-TP-rel. address, right 14 bits.*/ +#define R_PARISC_LTOFF_TP14F 167 /* 14 bits LT-TP-rel. address. */ +#define R_PARISC_TPREL64 216 /* 64 bits TP-rel. address. */ +#define R_PARISC_TPREL14WR 219 /* TP-rel. address, right 14 bits. */ +#define R_PARISC_TPREL14DR 220 /* TP-rel. address, right 14 bits. */ +#define R_PARISC_TPREL16F 221 /* 16 bits TP-rel. address. */ +#define R_PARISC_TPREL16WF 222 /* 16 bits TP-rel. address. */ +#define R_PARISC_TPREL16DF 223 /* 16 bits TP-rel. address. */ +#define R_PARISC_LTOFF_TP64 224 /* 64 bits LT-TP-rel. address. */ +#define R_PARISC_LTOFF_TP14WR 227 /* LT-TP-rel. address, right 14 bits.*/ +#define R_PARISC_LTOFF_TP14DR 228 /* LT-TP-rel. address, right 14 bits.*/ +#define R_PARISC_LTOFF_TP16F 229 /* 16 bits LT-TP-rel. address. */ +#define R_PARISC_LTOFF_TP16WF 230 /* 16 bits LT-TP-rel. address. */ +#define R_PARISC_LTOFF_TP16DF 231 /* 16 bits LT-TP-rel. address. */ +#define R_PARISC_GNU_VTENTRY 232 +#define R_PARISC_GNU_VTINHERIT 233 +#define R_PARISC_TLS_GD21L 234 /* GD 21-bit left. */ +#define R_PARISC_TLS_GD14R 235 /* GD 14-bit right. */ +#define R_PARISC_TLS_GDCALL 236 /* GD call to __t_g_a. */ +#define R_PARISC_TLS_LDM21L 237 /* LD module 21-bit left. */ +#define R_PARISC_TLS_LDM14R 238 /* LD module 14-bit right. */ +#define R_PARISC_TLS_LDMCALL 239 /* LD module call to __t_g_a. */ +#define R_PARISC_TLS_LDO21L 240 /* LD offset 21-bit left. */ +#define R_PARISC_TLS_LDO14R 241 /* LD offset 14-bit right. */ +#define R_PARISC_TLS_DTPMOD32 242 /* DTP module 32-bit. */ +#define R_PARISC_TLS_DTPMOD64 243 /* DTP module 64-bit. */ +#define R_PARISC_TLS_DTPOFF32 244 /* DTP offset 32-bit. */ +#define R_PARISC_TLS_DTPOFF64 245 /* DTP offset 32-bit. */ +#define R_PARISC_TLS_LE21L R_PARISC_TPREL21L +#define R_PARISC_TLS_LE14R R_PARISC_TPREL14R +#define R_PARISC_TLS_IE21L R_PARISC_LTOFF_TP21L +#define R_PARISC_TLS_IE14R R_PARISC_LTOFF_TP14R +#define R_PARISC_TLS_TPREL32 R_PARISC_TPREL32 +#define R_PARISC_TLS_TPREL64 R_PARISC_TPREL64 +#define R_PARISC_HIRESERVE 255 + +/* Legal values for p_type field of Elf32_Phdr/Elf64_Phdr. */ + +#define PT_HP_TLS (PT_LOOS + 0x0) +#define PT_HP_CORE_NONE (PT_LOOS + 0x1) +#define PT_HP_CORE_VERSION (PT_LOOS + 0x2) +#define PT_HP_CORE_KERNEL (PT_LOOS + 0x3) +#define PT_HP_CORE_COMM (PT_LOOS + 0x4) +#define PT_HP_CORE_PROC (PT_LOOS + 0x5) +#define PT_HP_CORE_LOADABLE (PT_LOOS + 0x6) +#define PT_HP_CORE_STACK (PT_LOOS + 0x7) +#define PT_HP_CORE_SHM (PT_LOOS + 0x8) +#define PT_HP_CORE_MMF (PT_LOOS + 0x9) +#define PT_HP_PARALLEL (PT_LOOS + 0x10) +#define PT_HP_FASTBIND (PT_LOOS + 0x11) +#define PT_HP_OPT_ANNOT (PT_LOOS + 0x12) +#define PT_HP_HSL_ANNOT (PT_LOOS + 0x13) +#define PT_HP_STACK (PT_LOOS + 0x14) + +#define PT_PARISC_ARCHEXT 0x70000000 +#define PT_PARISC_UNWIND 0x70000001 + +/* Legal values for p_flags field of Elf32_Phdr/Elf64_Phdr. */ + +#define PF_PARISC_SBP 0x08000000 + +#define PF_HP_PAGE_SIZE 0x00100000 +#define PF_HP_FAR_SHARED 0x00200000 +#define PF_HP_NEAR_SHARED 0x00400000 +#define PF_HP_CODE 0x01000000 +#define PF_HP_MODIFY 0x02000000 +#define PF_HP_LAZYSWAP 0x04000000 +#define PF_HP_SBP 0x08000000 + +/* Alpha specific definitions. */ + +/* Legal values for e_flags field of Elf64_Ehdr. */ + +#define EF_ALPHA_32BIT 1 /* All addresses must be < 2GB. */ +#define EF_ALPHA_CANRELAX 2 /* Relocations for relaxing exist. */ + +/* Legal values for sh_type field of Elf64_Shdr. */ + +/* These two are primerily concerned with ECOFF debugging info. */ +#define SHT_ALPHA_DEBUG 0x70000001 +#define SHT_ALPHA_REGINFO 0x70000002 + +/* Legal values for sh_flags field of Elf64_Shdr. */ + +#define SHF_ALPHA_GPREL 0x10000000 + +/* Legal values for st_other field of Elf64_Sym. */ +#define STO_ALPHA_NOPV 0x80 /* No PV required. */ +#define STO_ALPHA_STD_GPLOAD 0x88 /* PV only used for initial ldgp. */ + +/* Alpha relocs. */ + +#define R_ALPHA_NONE 0 /* No reloc */ +#define R_ALPHA_REFLONG 1 /* Direct 32 bit */ +#define R_ALPHA_REFQUAD 2 /* Direct 64 bit */ +#define R_ALPHA_GPREL32 3 /* GP relative 32 bit */ +#define R_ALPHA_LITERAL 4 /* GP relative 16 bit w/optimization */ +#define R_ALPHA_LITUSE 5 /* Optimization hint for LITERAL */ +#define R_ALPHA_GPDISP 6 /* Add displacement to GP */ +#define R_ALPHA_BRADDR 7 /* PC+4 relative 23 bit shifted */ +#define R_ALPHA_HINT 8 /* PC+4 relative 16 bit shifted */ +#define R_ALPHA_SREL16 9 /* PC relative 16 bit */ +#define R_ALPHA_SREL32 10 /* PC relative 32 bit */ +#define R_ALPHA_SREL64 11 /* PC relative 64 bit */ +#define R_ALPHA_GPRELHIGH 17 /* GP relative 32 bit, high 16 bits */ +#define R_ALPHA_GPRELLOW 18 /* GP relative 32 bit, low 16 bits */ +#define R_ALPHA_GPREL16 19 /* GP relative 16 bit */ +#define R_ALPHA_COPY 24 /* Copy symbol at runtime */ +#define R_ALPHA_GLOB_DAT 25 /* Create GOT entry */ +#define R_ALPHA_JMP_SLOT 26 /* Create PLT entry */ +#define R_ALPHA_RELATIVE 27 /* Adjust by program base */ +#define R_ALPHA_TLS_GD_HI 28 +#define R_ALPHA_TLSGD 29 +#define R_ALPHA_TLS_LDM 30 +#define R_ALPHA_DTPMOD64 31 +#define R_ALPHA_GOTDTPREL 32 +#define R_ALPHA_DTPREL64 33 +#define R_ALPHA_DTPRELHI 34 +#define R_ALPHA_DTPRELLO 35 +#define R_ALPHA_DTPREL16 36 +#define R_ALPHA_GOTTPREL 37 +#define R_ALPHA_TPREL64 38 +#define R_ALPHA_TPRELHI 39 +#define R_ALPHA_TPRELLO 40 +#define R_ALPHA_TPREL16 41 +/* Keep this the last entry. */ +#define R_ALPHA_NUM 46 + +/* Magic values of the LITUSE relocation addend. */ +#define LITUSE_ALPHA_ADDR 0 +#define LITUSE_ALPHA_BASE 1 +#define LITUSE_ALPHA_BYTOFF 2 +#define LITUSE_ALPHA_JSR 3 +#define LITUSE_ALPHA_TLS_GD 4 +#define LITUSE_ALPHA_TLS_LDM 5 + +/* Legal values for d_tag of Elf64_Dyn. */ +#define DT_ALPHA_PLTRO (DT_LOPROC + 0) +#define DT_ALPHA_NUM 1 + +/* PowerPC specific declarations */ + +/* Values for Elf32/64_Ehdr.e_flags. */ +#define EF_PPC_EMB 0x80000000 /* PowerPC embedded flag */ + +/* Cygnus local bits below */ +#define EF_PPC_RELOCATABLE 0x00010000 /* PowerPC -mrelocatable flag*/ +#define EF_PPC_RELOCATABLE_LIB \ + 0x00008000 /* PowerPC -mrelocatable-lib + flag */ + +/* PowerPC relocations defined by the ABIs */ +#define R_PPC_NONE 0 +#define R_PPC_ADDR32 1 /* 32bit absolute address */ +#define R_PPC_ADDR24 2 /* 26bit address, 2 bits ignored. */ +#define R_PPC_ADDR16 3 /* 16bit absolute address */ +#define R_PPC_ADDR16_LO 4 /* lower 16bit of absolute address */ +#define R_PPC_ADDR16_HI 5 /* high 16bit of absolute address */ +#define R_PPC_ADDR16_HA 6 /* adjusted high 16bit */ +#define R_PPC_ADDR14 7 /* 16bit address, 2 bits ignored */ +#define R_PPC_ADDR14_BRTAKEN 8 +#define R_PPC_ADDR14_BRNTAKEN 9 +#define R_PPC_REL24 10 /* PC relative 26 bit */ +#define R_PPC_REL14 11 /* PC relative 16 bit */ +#define R_PPC_REL14_BRTAKEN 12 +#define R_PPC_REL14_BRNTAKEN 13 +#define R_PPC_GOT16 14 +#define R_PPC_GOT16_LO 15 +#define R_PPC_GOT16_HI 16 +#define R_PPC_GOT16_HA 17 +#define R_PPC_PLTREL24 18 +#define R_PPC_COPY 19 +#define R_PPC_GLOB_DAT 20 +#define R_PPC_JMP_SLOT 21 +#define R_PPC_RELATIVE 22 +#define R_PPC_LOCAL24PC 23 +#define R_PPC_UADDR32 24 +#define R_PPC_UADDR16 25 +#define R_PPC_REL32 26 +#define R_PPC_PLT32 27 +#define R_PPC_PLTREL32 28 +#define R_PPC_PLT16_LO 29 +#define R_PPC_PLT16_HI 30 +#define R_PPC_PLT16_HA 31 +#define R_PPC_SDAREL16 32 +#define R_PPC_SECTOFF 33 +#define R_PPC_SECTOFF_LO 34 +#define R_PPC_SECTOFF_HI 35 +#define R_PPC_SECTOFF_HA 36 + +/* PowerPC relocations defined for the TLS access ABI. */ +#define R_PPC_TLS 67 /* none (sym+add)@tls */ +#define R_PPC_DTPMOD32 68 /* word32 (sym+add)@dtpmod */ +#define R_PPC_TPREL16 69 /* half16* (sym+add)@tprel */ +#define R_PPC_TPREL16_LO 70 /* half16 (sym+add)@tprel@l */ +#define R_PPC_TPREL16_HI 71 /* half16 (sym+add)@tprel@h */ +#define R_PPC_TPREL16_HA 72 /* half16 (sym+add)@tprel@ha */ +#define R_PPC_TPREL32 73 /* word32 (sym+add)@tprel */ +#define R_PPC_DTPREL16 74 /* half16* (sym+add)@dtprel */ +#define R_PPC_DTPREL16_LO 75 /* half16 (sym+add)@dtprel@l */ +#define R_PPC_DTPREL16_HI 76 /* half16 (sym+add)@dtprel@h */ +#define R_PPC_DTPREL16_HA 77 /* half16 (sym+add)@dtprel@ha */ +#define R_PPC_DTPREL32 78 /* word32 (sym+add)@dtprel */ +#define R_PPC_GOT_TLSGD16 79 /* half16* (sym+add)@got@tlsgd */ +#define R_PPC_GOT_TLSGD16_LO 80 /* half16 (sym+add)@got@tlsgd@l */ +#define R_PPC_GOT_TLSGD16_HI 81 /* half16 (sym+add)@got@tlsgd@h */ +#define R_PPC_GOT_TLSGD16_HA 82 /* half16 (sym+add)@got@tlsgd@ha */ +#define R_PPC_GOT_TLSLD16 83 /* half16* (sym+add)@got@tlsld */ +#define R_PPC_GOT_TLSLD16_LO 84 /* half16 (sym+add)@got@tlsld@l */ +#define R_PPC_GOT_TLSLD16_HI 85 /* half16 (sym+add)@got@tlsld@h */ +#define R_PPC_GOT_TLSLD16_HA 86 /* half16 (sym+add)@got@tlsld@ha */ +#define R_PPC_GOT_TPREL16 87 /* half16* (sym+add)@got@tprel */ +#define R_PPC_GOT_TPREL16_LO 88 /* half16 (sym+add)@got@tprel@l */ +#define R_PPC_GOT_TPREL16_HI 89 /* half16 (sym+add)@got@tprel@h */ +#define R_PPC_GOT_TPREL16_HA 90 /* half16 (sym+add)@got@tprel@ha */ +#define R_PPC_GOT_DTPREL16 91 /* half16* (sym+add)@got@dtprel */ +#define R_PPC_GOT_DTPREL16_LO 92 /* half16* (sym+add)@got@dtprel@l */ +#define R_PPC_GOT_DTPREL16_HI 93 /* half16* (sym+add)@got@dtprel@h */ +#define R_PPC_GOT_DTPREL16_HA 94 /* half16* (sym+add)@got@dtprel@ha */ +#define R_PPC_TLSGD 95 /* none (sym+add)@tlsgd */ +#define R_PPC_TLSLD 96 /* none (sym+add)@tlsld */ + +/* The remaining relocs are from the Embedded ELF ABI, and are not + in the SVR4 ELF ABI. */ +#define R_PPC_EMB_NADDR32 101 +#define R_PPC_EMB_NADDR16 102 +#define R_PPC_EMB_NADDR16_LO 103 +#define R_PPC_EMB_NADDR16_HI 104 +#define R_PPC_EMB_NADDR16_HA 105 +#define R_PPC_EMB_SDAI16 106 +#define R_PPC_EMB_SDA2I16 107 +#define R_PPC_EMB_SDA2REL 108 +#define R_PPC_EMB_SDA21 109 /* 16 bit offset in SDA */ +#define R_PPC_EMB_MRKREF 110 +#define R_PPC_EMB_RELSEC16 111 +#define R_PPC_EMB_RELST_LO 112 +#define R_PPC_EMB_RELST_HI 113 +#define R_PPC_EMB_RELST_HA 114 +#define R_PPC_EMB_BIT_FLD 115 +#define R_PPC_EMB_RELSDA 116 /* 16 bit relative offset in SDA */ + +/* Diab tool relocations. */ +#define R_PPC_DIAB_SDA21_LO 180 /* like EMB_SDA21, but lower 16 bit */ +#define R_PPC_DIAB_SDA21_HI 181 /* like EMB_SDA21, but high 16 bit */ +#define R_PPC_DIAB_SDA21_HA 182 /* like EMB_SDA21, adjusted high 16 */ +#define R_PPC_DIAB_RELSDA_LO 183 /* like EMB_RELSDA, but lower 16 bit */ +#define R_PPC_DIAB_RELSDA_HI 184 /* like EMB_RELSDA, but high 16 bit */ +#define R_PPC_DIAB_RELSDA_HA 185 /* like EMB_RELSDA, adjusted high 16 */ + +/* GNU extension to support local ifunc. */ +#define R_PPC_IRELATIVE 248 + +/* GNU relocs used in PIC code sequences. */ +#define R_PPC_REL16 249 /* half16 (sym+add-.) */ +#define R_PPC_REL16_LO 250 /* half16 (sym+add-.)@l */ +#define R_PPC_REL16_HI 251 /* half16 (sym+add-.)@h */ +#define R_PPC_REL16_HA 252 /* half16 (sym+add-.)@ha */ + +/* This is a phony reloc to handle any old fashioned TOC16 references + that may still be in object files. */ +#define R_PPC_TOC16 255 + +/* PowerPC specific values for the Dyn d_tag field. */ +#define DT_PPC_GOT (DT_LOPROC + 0) +#define DT_PPC_OPT (DT_LOPROC + 1) +#define DT_PPC_NUM 2 + +/* PowerPC specific values for the DT_PPC_OPT Dyn entry. */ +#define PPC_OPT_TLS 1 + +/* PowerPC64 relocations defined by the ABIs */ +#define R_PPC64_NONE R_PPC_NONE +#define R_PPC64_ADDR32 R_PPC_ADDR32 /* 32bit absolute address */ +#define R_PPC64_ADDR24 R_PPC_ADDR24 /* 26bit address, word aligned */ +#define R_PPC64_ADDR16 R_PPC_ADDR16 /* 16bit absolute address */ +#define R_PPC64_ADDR16_LO R_PPC_ADDR16_LO /* lower 16bits of address */ +#define R_PPC64_ADDR16_HI R_PPC_ADDR16_HI /* high 16bits of address. */ +#define R_PPC64_ADDR16_HA R_PPC_ADDR16_HA /* adjusted high 16bits. */ +#define R_PPC64_ADDR14 R_PPC_ADDR14 /* 16bit address, word aligned */ +#define R_PPC64_ADDR14_BRTAKEN R_PPC_ADDR14_BRTAKEN +#define R_PPC64_ADDR14_BRNTAKEN R_PPC_ADDR14_BRNTAKEN +#define R_PPC64_REL24 R_PPC_REL24 /* PC-rel. 26 bit, word aligned */ +#define R_PPC64_REL14 R_PPC_REL14 /* PC relative 16 bit */ +#define R_PPC64_REL14_BRTAKEN R_PPC_REL14_BRTAKEN +#define R_PPC64_REL14_BRNTAKEN R_PPC_REL14_BRNTAKEN +#define R_PPC64_GOT16 R_PPC_GOT16 +#define R_PPC64_GOT16_LO R_PPC_GOT16_LO +#define R_PPC64_GOT16_HI R_PPC_GOT16_HI +#define R_PPC64_GOT16_HA R_PPC_GOT16_HA + +#define R_PPC64_COPY R_PPC_COPY +#define R_PPC64_GLOB_DAT R_PPC_GLOB_DAT +#define R_PPC64_JMP_SLOT R_PPC_JMP_SLOT +#define R_PPC64_RELATIVE R_PPC_RELATIVE + +#define R_PPC64_UADDR32 R_PPC_UADDR32 +#define R_PPC64_UADDR16 R_PPC_UADDR16 +#define R_PPC64_REL32 R_PPC_REL32 +#define R_PPC64_PLT32 R_PPC_PLT32 +#define R_PPC64_PLTREL32 R_PPC_PLTREL32 +#define R_PPC64_PLT16_LO R_PPC_PLT16_LO +#define R_PPC64_PLT16_HI R_PPC_PLT16_HI +#define R_PPC64_PLT16_HA R_PPC_PLT16_HA + +#define R_PPC64_SECTOFF R_PPC_SECTOFF +#define R_PPC64_SECTOFF_LO R_PPC_SECTOFF_LO +#define R_PPC64_SECTOFF_HI R_PPC_SECTOFF_HI +#define R_PPC64_SECTOFF_HA R_PPC_SECTOFF_HA +#define R_PPC64_ADDR30 37 /* word30 (S + A - P) >> 2 */ +#define R_PPC64_ADDR64 38 /* doubleword64 S + A */ +#define R_PPC64_ADDR16_HIGHER 39 /* half16 #higher(S + A) */ +#define R_PPC64_ADDR16_HIGHERA 40 /* half16 #highera(S + A) */ +#define R_PPC64_ADDR16_HIGHEST 41 /* half16 #highest(S + A) */ +#define R_PPC64_ADDR16_HIGHESTA 42 /* half16 #highesta(S + A) */ +#define R_PPC64_UADDR64 43 /* doubleword64 S + A */ +#define R_PPC64_REL64 44 /* doubleword64 S + A - P */ +#define R_PPC64_PLT64 45 /* doubleword64 L + A */ +#define R_PPC64_PLTREL64 46 /* doubleword64 L + A - P */ +#define R_PPC64_TOC16 47 /* half16* S + A - .TOC */ +#define R_PPC64_TOC16_LO 48 /* half16 #lo(S + A - .TOC.) */ +#define R_PPC64_TOC16_HI 49 /* half16 #hi(S + A - .TOC.) */ +#define R_PPC64_TOC16_HA 50 /* half16 #ha(S + A - .TOC.) */ +#define R_PPC64_TOC 51 /* doubleword64 .TOC */ +#define R_PPC64_PLTGOT16 52 /* half16* M + A */ +#define R_PPC64_PLTGOT16_LO 53 /* half16 #lo(M + A) */ +#define R_PPC64_PLTGOT16_HI 54 /* half16 #hi(M + A) */ +#define R_PPC64_PLTGOT16_HA 55 /* half16 #ha(M + A) */ + +#define R_PPC64_ADDR16_DS 56 /* half16ds* (S + A) >> 2 */ +#define R_PPC64_ADDR16_LO_DS 57 /* half16ds #lo(S + A) >> 2 */ +#define R_PPC64_GOT16_DS 58 /* half16ds* (G + A) >> 2 */ +#define R_PPC64_GOT16_LO_DS 59 /* half16ds #lo(G + A) >> 2 */ +#define R_PPC64_PLT16_LO_DS 60 /* half16ds #lo(L + A) >> 2 */ +#define R_PPC64_SECTOFF_DS 61 /* half16ds* (R + A) >> 2 */ +#define R_PPC64_SECTOFF_LO_DS 62 /* half16ds #lo(R + A) >> 2 */ +#define R_PPC64_TOC16_DS 63 /* half16ds* (S + A - .TOC.) >> 2 */ +#define R_PPC64_TOC16_LO_DS 64 /* half16ds #lo(S + A - .TOC.) >> 2 */ +#define R_PPC64_PLTGOT16_DS 65 /* half16ds* (M + A) >> 2 */ +#define R_PPC64_PLTGOT16_LO_DS 66 /* half16ds #lo(M + A) >> 2 */ + +/* PowerPC64 relocations defined for the TLS access ABI. */ +#define R_PPC64_TLS 67 /* none (sym+add)@tls */ +#define R_PPC64_DTPMOD64 68 /* doubleword64 (sym+add)@dtpmod */ +#define R_PPC64_TPREL16 69 /* half16* (sym+add)@tprel */ +#define R_PPC64_TPREL16_LO 70 /* half16 (sym+add)@tprel@l */ +#define R_PPC64_TPREL16_HI 71 /* half16 (sym+add)@tprel@h */ +#define R_PPC64_TPREL16_HA 72 /* half16 (sym+add)@tprel@ha */ +#define R_PPC64_TPREL64 73 /* doubleword64 (sym+add)@tprel */ +#define R_PPC64_DTPREL16 74 /* half16* (sym+add)@dtprel */ +#define R_PPC64_DTPREL16_LO 75 /* half16 (sym+add)@dtprel@l */ +#define R_PPC64_DTPREL16_HI 76 /* half16 (sym+add)@dtprel@h */ +#define R_PPC64_DTPREL16_HA 77 /* half16 (sym+add)@dtprel@ha */ +#define R_PPC64_DTPREL64 78 /* doubleword64 (sym+add)@dtprel */ +#define R_PPC64_GOT_TLSGD16 79 /* half16* (sym+add)@got@tlsgd */ +#define R_PPC64_GOT_TLSGD16_LO 80 /* half16 (sym+add)@got@tlsgd@l */ +#define R_PPC64_GOT_TLSGD16_HI 81 /* half16 (sym+add)@got@tlsgd@h */ +#define R_PPC64_GOT_TLSGD16_HA 82 /* half16 (sym+add)@got@tlsgd@ha */ +#define R_PPC64_GOT_TLSLD16 83 /* half16* (sym+add)@got@tlsld */ +#define R_PPC64_GOT_TLSLD16_LO 84 /* half16 (sym+add)@got@tlsld@l */ +#define R_PPC64_GOT_TLSLD16_HI 85 /* half16 (sym+add)@got@tlsld@h */ +#define R_PPC64_GOT_TLSLD16_HA 86 /* half16 (sym+add)@got@tlsld@ha */ +#define R_PPC64_GOT_TPREL16_DS 87 /* half16ds* (sym+add)@got@tprel */ +#define R_PPC64_GOT_TPREL16_LO_DS 88 /* half16ds (sym+add)@got@tprel@l */ +#define R_PPC64_GOT_TPREL16_HI 89 /* half16 (sym+add)@got@tprel@h */ +#define R_PPC64_GOT_TPREL16_HA 90 /* half16 (sym+add)@got@tprel@ha */ +#define R_PPC64_GOT_DTPREL16_DS 91 /* half16ds* (sym+add)@got@dtprel */ +#define R_PPC64_GOT_DTPREL16_LO_DS 92 /* half16ds (sym+add)@got@dtprel@l */ +#define R_PPC64_GOT_DTPREL16_HI 93 /* half16 (sym+add)@got@dtprel@h */ +#define R_PPC64_GOT_DTPREL16_HA 94 /* half16 (sym+add)@got@dtprel@ha */ +#define R_PPC64_TPREL16_DS 95 /* half16ds* (sym+add)@tprel */ +#define R_PPC64_TPREL16_LO_DS 96 /* half16ds (sym+add)@tprel@l */ +#define R_PPC64_TPREL16_HIGHER 97 /* half16 (sym+add)@tprel@higher */ +#define R_PPC64_TPREL16_HIGHERA 98 /* half16 (sym+add)@tprel@highera */ +#define R_PPC64_TPREL16_HIGHEST 99 /* half16 (sym+add)@tprel@highest */ +#define R_PPC64_TPREL16_HIGHESTA 100 /* half16 (sym+add)@tprel@highesta */ +#define R_PPC64_DTPREL16_DS 101 /* half16ds* (sym+add)@dtprel */ +#define R_PPC64_DTPREL16_LO_DS 102 /* half16ds (sym+add)@dtprel@l */ +#define R_PPC64_DTPREL16_HIGHER 103 /* half16 (sym+add)@dtprel@higher */ +#define R_PPC64_DTPREL16_HIGHERA 104 /* half16 (sym+add)@dtprel@highera */ +#define R_PPC64_DTPREL16_HIGHEST 105 /* half16 (sym+add)@dtprel@highest */ +#define R_PPC64_DTPREL16_HIGHESTA 106 /* half16 (sym+add)@dtprel@highesta */ +#define R_PPC64_TLSGD 107 /* none (sym+add)@tlsgd */ +#define R_PPC64_TLSLD 108 /* none (sym+add)@tlsld */ +#define R_PPC64_TOCSAVE 109 /* none */ + +/* Added when HA and HI relocs were changed to report overflows. */ +#define R_PPC64_ADDR16_HIGH 110 +#define R_PPC64_ADDR16_HIGHA 111 +#define R_PPC64_TPREL16_HIGH 112 +#define R_PPC64_TPREL16_HIGHA 113 +#define R_PPC64_DTPREL16_HIGH 114 +#define R_PPC64_DTPREL16_HIGHA 115 + +/* GNU extension to support local ifunc. */ +#define R_PPC64_JMP_IREL 247 +#define R_PPC64_IRELATIVE 248 +#define R_PPC64_REL16 249 /* half16 (sym+add-.) */ +#define R_PPC64_REL16_LO 250 /* half16 (sym+add-.)@l */ +#define R_PPC64_REL16_HI 251 /* half16 (sym+add-.)@h */ +#define R_PPC64_REL16_HA 252 /* half16 (sym+add-.)@ha */ + +/* e_flags bits specifying ABI. + 1 for original function descriptor using ABI, + 2 for revised ABI without function descriptors, + 0 for unspecified or not using any features affected by the differences. */ +#define EF_PPC64_ABI 3 + +/* PowerPC64 specific values for the Dyn d_tag field. */ +#define DT_PPC64_GLINK (DT_LOPROC + 0) +#define DT_PPC64_OPD (DT_LOPROC + 1) +#define DT_PPC64_OPDSZ (DT_LOPROC + 2) +#define DT_PPC64_OPT (DT_LOPROC + 3) +#define DT_PPC64_NUM 4 + +/* PowerPC64 specific bits in the DT_PPC64_OPT Dyn entry. */ +#define PPC64_OPT_TLS 1 +#define PPC64_OPT_MULTI_TOC 2 +#define PPC64_OPT_LOCALENTRY 4 + +/* PowerPC64 specific values for the Elf64_Sym st_other field. */ +#define STO_PPC64_LOCAL_BIT 5 +#define STO_PPC64_LOCAL_MASK (7 << STO_PPC64_LOCAL_BIT) +#define PPC64_LOCAL_ENTRY_OFFSET(other) \ + (((1 << (((other) & STO_PPC64_LOCAL_MASK) >> STO_PPC64_LOCAL_BIT)) >> 2) \ + << 2) + +/* ARM specific declarations */ + +/* Processor specific flags for the ELF header e_flags field. */ +#define EF_ARM_RELEXEC 0x01 +#define EF_ARM_HASENTRY 0x02 +#define EF_ARM_INTERWORK 0x04 +#define EF_ARM_APCS_26 0x08 +#define EF_ARM_APCS_FLOAT 0x10 +#define EF_ARM_PIC 0x20 +#define EF_ARM_ALIGN8 0x40 /* 8-bit structure alignment is in use */ +#define EF_ARM_NEW_ABI 0x80 +#define EF_ARM_OLD_ABI 0x100 +#define EF_ARM_SOFT_FLOAT 0x200 +#define EF_ARM_VFP_FLOAT 0x400 +#define EF_ARM_MAVERICK_FLOAT 0x800 + +#define EF_ARM_ABI_FLOAT_SOFT 0x200 /* NB conflicts with EF_ARM_SOFT_FLOAT */ +#define EF_ARM_ABI_FLOAT_HARD 0x400 /* NB conflicts with EF_ARM_VFP_FLOAT */ + +/* Other constants defined in the ARM ELF spec. version B-01. */ +/* NB. These conflict with values defined above. */ +#define EF_ARM_SYMSARESORTED 0x04 +#define EF_ARM_DYNSYMSUSESEGIDX 0x08 +#define EF_ARM_MAPSYMSFIRST 0x10 +#define EF_ARM_EABIMASK 0XFF000000 + +/* Constants defined in AAELF. */ +#define EF_ARM_BE8 0x00800000 +#define EF_ARM_LE8 0x00400000 + +#define EF_ARM_EABI_VERSION(flags) ((flags) & EF_ARM_EABIMASK) +#define EF_ARM_EABI_UNKNOWN 0x00000000 +#define EF_ARM_EABI_VER1 0x01000000 +#define EF_ARM_EABI_VER2 0x02000000 +#define EF_ARM_EABI_VER3 0x03000000 +#define EF_ARM_EABI_VER4 0x04000000 +#define EF_ARM_EABI_VER5 0x05000000 + +/* Additional symbol types for Thumb. */ +#define STT_ARM_TFUNC STT_LOPROC /* A Thumb function. */ +#define STT_ARM_16BIT STT_HIPROC /* A Thumb label. */ + +/* ARM-specific values for sh_flags */ +#define SHF_ARM_ENTRYSECT 0x10000000 /* Section contains an entry point */ +#define SHF_ARM_COMDEF \ + 0x80000000 /* Section may be multiply defined + in the input to a link step. */ + +/* ARM-specific program header flags */ +#define PF_ARM_SB \ + 0x10000000 /* Segment contains the location + addressed by the static base. */ +#define PF_ARM_PI 0x20000000 /* Position-independent segment. */ +#define PF_ARM_ABS 0x40000000 /* Absolute segment. */ + +/* Processor specific values for the Phdr p_type field. */ +#define PT_ARM_EXIDX (PT_LOPROC + 1) /* ARM unwind segment. */ + +/* Processor specific values for the Shdr sh_type field. */ +#define SHT_ARM_EXIDX (SHT_LOPROC + 1) /* ARM unwind section. */ +#define SHT_ARM_PREEMPTMAP (SHT_LOPROC + 2) /* Preemption details. */ +#define SHT_ARM_ATTRIBUTES (SHT_LOPROC + 3) /* ARM attributes section. */ + +/* AArch64 relocs. */ + +#define R_AARCH64_NONE 0 /* No relocation. */ + +/* ILP32 AArch64 relocs. */ +#define R_AARCH64_P32_ABS32 1 /* Direct 32 bit. */ +#define R_AARCH64_P32_COPY 180 /* Copy symbol at runtime. */ +#define R_AARCH64_P32_GLOB_DAT 181 /* Create GOT entry. */ +#define R_AARCH64_P32_JUMP_SLOT 182 /* Create PLT entry. */ +#define R_AARCH64_P32_RELATIVE 183 /* Adjust by program base. */ +#define R_AARCH64_P32_TLS_DTPMOD 184 /* Module number, 32 bit. */ +#define R_AARCH64_P32_TLS_DTPREL 185 /* Module-relative offset, 32 bit. */ +#define R_AARCH64_P32_TLS_TPREL 186 /* TP-relative offset, 32 bit. */ +#define R_AARCH64_P32_TLSDESC 187 /* TLS Descriptor. */ +#define R_AARCH64_P32_IRELATIVE 188 /* STT_GNU_IFUNC relocation. */ + +/* LP64 AArch64 relocs. */ +#define R_AARCH64_ABS64 257 /* Direct 64 bit. */ +#define R_AARCH64_ABS32 258 /* Direct 32 bit. */ +#define R_AARCH64_ABS16 259 /* Direct 16-bit. */ +#define R_AARCH64_PREL64 260 /* PC-relative 64-bit. */ +#define R_AARCH64_PREL32 261 /* PC-relative 32-bit. */ +#define R_AARCH64_PREL16 262 /* PC-relative 16-bit. */ +#define R_AARCH64_MOVW_UABS_G0 263 /* Dir. MOVZ imm. from bits 15:0. */ +#define R_AARCH64_MOVW_UABS_G0_NC 264 /* Likewise for MOVK; no check. */ +#define R_AARCH64_MOVW_UABS_G1 265 /* Dir. MOVZ imm. from bits 31:16. */ +#define R_AARCH64_MOVW_UABS_G1_NC 266 /* Likewise for MOVK; no check. */ +#define R_AARCH64_MOVW_UABS_G2 267 /* Dir. MOVZ imm. from bits 47:32. */ +#define R_AARCH64_MOVW_UABS_G2_NC 268 /* Likewise for MOVK; no check. */ +#define R_AARCH64_MOVW_UABS_G3 269 /* Dir. MOV{K,Z} imm. from 63:48. */ +#define R_AARCH64_MOVW_SABS_G0 270 /* Dir. MOV{N,Z} imm. from 15:0. */ +#define R_AARCH64_MOVW_SABS_G1 271 /* Dir. MOV{N,Z} imm. from 31:16. */ +#define R_AARCH64_MOVW_SABS_G2 272 /* Dir. MOV{N,Z} imm. from 47:32. */ +#define R_AARCH64_LD_PREL_LO19 273 /* PC-rel. LD imm. from bits 20:2. */ +#define R_AARCH64_ADR_PREL_LO21 274 /* PC-rel. ADR imm. from bits 20:0. */ +#define R_AARCH64_ADR_PREL_PG_HI21 275 /* Page-rel. ADRP imm. from 32:12. */ +#define R_AARCH64_ADR_PREL_PG_HI21_NC 276 /* Likewise; no overflow check. */ +#define R_AARCH64_ADD_ABS_LO12_NC 277 /* Dir. ADD imm. from bits 11:0. */ +#define R_AARCH64_LDST8_ABS_LO12_NC 278 /* Likewise for LD/ST; no check. */ +#define R_AARCH64_TSTBR14 279 /* PC-rel. TBZ/TBNZ imm. from 15:2. */ +#define R_AARCH64_CONDBR19 280 /* PC-rel. cond. br. imm. from 20:2. */ +#define R_AARCH64_JUMP26 282 /* PC-rel. B imm. from bits 27:2. */ +#define R_AARCH64_CALL26 283 /* Likewise for CALL. */ +#define R_AARCH64_LDST16_ABS_LO12_NC 284 /* Dir. ADD imm. from bits 11:1. */ +#define R_AARCH64_LDST32_ABS_LO12_NC 285 /* Likewise for bits 11:2. */ +#define R_AARCH64_LDST64_ABS_LO12_NC 286 /* Likewise for bits 11:3. */ +#define R_AARCH64_MOVW_PREL_G0 287 /* PC-rel. MOV{N,Z} imm. from 15:0. */ +#define R_AARCH64_MOVW_PREL_G0_NC 288 /* Likewise for MOVK; no check. */ +#define R_AARCH64_MOVW_PREL_G1 289 /* PC-rel. MOV{N,Z} imm. from 31:16. */ +#define R_AARCH64_MOVW_PREL_G1_NC 290 /* Likewise for MOVK; no check. */ +#define R_AARCH64_MOVW_PREL_G2 291 /* PC-rel. MOV{N,Z} imm. from 47:32. */ +#define R_AARCH64_MOVW_PREL_G2_NC 292 /* Likewise for MOVK; no check. */ +#define R_AARCH64_MOVW_PREL_G3 293 /* PC-rel. MOV{N,Z} imm. from 63:48. */ +#define R_AARCH64_LDST128_ABS_LO12_NC 299 /* Dir. ADD imm. from bits 11:4. */ +#define R_AARCH64_MOVW_GOTOFF_G0 300 /* GOT-rel. off. MOV{N,Z} imm. 15:0. */ +#define R_AARCH64_MOVW_GOTOFF_G0_NC 301 /* Likewise for MOVK; no check. */ +#define R_AARCH64_MOVW_GOTOFF_G1 302 /* GOT-rel. o. MOV{N,Z} imm. 31:16. */ +#define R_AARCH64_MOVW_GOTOFF_G1_NC 303 /* Likewise for MOVK; no check. */ +#define R_AARCH64_MOVW_GOTOFF_G2 304 /* GOT-rel. o. MOV{N,Z} imm. 47:32. */ +#define R_AARCH64_MOVW_GOTOFF_G2_NC 305 /* Likewise for MOVK; no check. */ +#define R_AARCH64_MOVW_GOTOFF_G3 306 /* GOT-rel. o. MOV{N,Z} imm. 63:48. */ +#define R_AARCH64_GOTREL64 307 /* GOT-relative 64-bit. */ +#define R_AARCH64_GOTREL32 308 /* GOT-relative 32-bit. */ +#define R_AARCH64_GOT_LD_PREL19 309 /* PC-rel. GOT off. load imm. 20:2. */ +#define R_AARCH64_LD64_GOTOFF_LO15 310 /* GOT-rel. off. LD/ST imm. 14:3. */ +#define R_AARCH64_ADR_GOT_PAGE 311 /* P-page-rel. GOT off. ADRP 32:12. */ +#define R_AARCH64_LD64_GOT_LO12_NC 312 /* Dir. GOT off. LD/ST imm. 11:3. */ +#define R_AARCH64_LD64_GOTPAGE_LO15 313 /* GOT-page-rel. GOT off. LD/ST 14:3 */ +#define R_AARCH64_TLSGD_ADR_PREL21 512 /* PC-relative ADR imm. 20:0. */ +#define R_AARCH64_TLSGD_ADR_PAGE21 513 /* page-rel. ADRP imm. 32:12. */ +#define R_AARCH64_TLSGD_ADD_LO12_NC 514 /* direct ADD imm. from 11:0. */ +#define R_AARCH64_TLSGD_MOVW_G1 515 /* GOT-rel. MOV{N,Z} 31:16. */ +#define R_AARCH64_TLSGD_MOVW_G0_NC 516 /* GOT-rel. MOVK imm. 15:0. */ +#define R_AARCH64_TLSLD_ADR_PREL21 517 /* Like 512; local dynamic model. */ +#define R_AARCH64_TLSLD_ADR_PAGE21 518 /* Like 513; local dynamic model. */ +#define R_AARCH64_TLSLD_ADD_LO12_NC 519 /* Like 514; local dynamic model. */ +#define R_AARCH64_TLSLD_MOVW_G1 520 /* Like 515; local dynamic model. */ +#define R_AARCH64_TLSLD_MOVW_G0_NC 521 /* Like 516; local dynamic model. */ +#define R_AARCH64_TLSLD_LD_PREL19 522 /* TLS PC-rel. load imm. 20:2. */ +#define R_AARCH64_TLSLD_MOVW_DTPREL_G2 523 /* TLS DTP-rel. MOV{N,Z} 47:32. */ +#define R_AARCH64_TLSLD_MOVW_DTPREL_G1 524 /* TLS DTP-rel. MOV{N,Z} 31:16. */ +#define R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC 525 /* Likewise; MOVK; no check. */ +#define R_AARCH64_TLSLD_MOVW_DTPREL_G0 526 /* TLS DTP-rel. MOV{N,Z} 15:0. */ +#define R_AARCH64_TLSLD_MOVW_DTPREL_G0_NC 527 /* Likewise; MOVK; no check. */ +#define R_AARCH64_TLSLD_ADD_DTPREL_HI12 528 /* DTP-rel. ADD imm. from 23:12. */ +#define R_AARCH64_TLSLD_ADD_DTPREL_LO12 529 /* DTP-rel. ADD imm. from 11:0. */ +#define R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC 530 /* Likewise; no ovfl. check. */ +#define R_AARCH64_TLSLD_LDST8_DTPREL_LO12 531 /* DTP-rel. LD/ST imm. 11:0. */ +#define R_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC 532 /* Likewise; no check. */ +#define R_AARCH64_TLSLD_LDST16_DTPREL_LO12 533 /* DTP-rel. LD/ST imm. 11:1. */ +#define R_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC 534 /* Likewise; no check. */ +#define R_AARCH64_TLSLD_LDST32_DTPREL_LO12 535 /* DTP-rel. LD/ST imm. 11:2. */ +#define R_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC 536 /* Likewise; no check. */ +#define R_AARCH64_TLSLD_LDST64_DTPREL_LO12 537 /* DTP-rel. LD/ST imm. 11:3. */ +#define R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC 538 /* Likewise; no check. */ +#define R_AARCH64_TLSIE_MOVW_GOTTPREL_G1 539 /* GOT-rel. MOV{N,Z} 31:16. */ +#define R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC 540 /* GOT-rel. MOVK 15:0. */ +#define R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 541 /* Page-rel. ADRP 32:12. */ +#define R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC 542 /* Direct LD off. 11:3. */ +#define R_AARCH64_TLSIE_LD_GOTTPREL_PREL19 543 /* PC-rel. load imm. 20:2. */ +#define R_AARCH64_TLSLE_MOVW_TPREL_G2 544 /* TLS TP-rel. MOV{N,Z} 47:32. */ +#define R_AARCH64_TLSLE_MOVW_TPREL_G1 545 /* TLS TP-rel. MOV{N,Z} 31:16. */ +#define R_AARCH64_TLSLE_MOVW_TPREL_G1_NC 546 /* Likewise; MOVK; no check. */ +#define R_AARCH64_TLSLE_MOVW_TPREL_G0 547 /* TLS TP-rel. MOV{N,Z} 15:0. */ +#define R_AARCH64_TLSLE_MOVW_TPREL_G0_NC 548 /* Likewise; MOVK; no check. */ +#define R_AARCH64_TLSLE_ADD_TPREL_HI12 549 /* TP-rel. ADD imm. 23:12. */ +#define R_AARCH64_TLSLE_ADD_TPREL_LO12 550 /* TP-rel. ADD imm. 11:0. */ +#define R_AARCH64_TLSLE_ADD_TPREL_LO12_NC 551 /* Likewise; no ovfl. check. */ +#define R_AARCH64_TLSLE_LDST8_TPREL_LO12 552 /* TP-rel. LD/ST off. 11:0. */ +#define R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC 553 /* Likewise; no ovfl. check. */ +#define R_AARCH64_TLSLE_LDST16_TPREL_LO12 554 /* TP-rel. LD/ST off. 11:1. */ +#define R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC 555 /* Likewise; no check. */ +#define R_AARCH64_TLSLE_LDST32_TPREL_LO12 556 /* TP-rel. LD/ST off. 11:2. */ +#define R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC 557 /* Likewise; no check. */ +#define R_AARCH64_TLSLE_LDST64_TPREL_LO12 558 /* TP-rel. LD/ST off. 11:3. */ +#define R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC 559 /* Likewise; no check. */ +#define R_AARCH64_TLSDESC_LD_PREL19 560 /* PC-rel. load immediate 20:2. */ +#define R_AARCH64_TLSDESC_ADR_PREL21 561 /* PC-rel. ADR immediate 20:0. */ +#define R_AARCH64_TLSDESC_ADR_PAGE21 562 /* Page-rel. ADRP imm. 32:12. */ +#define R_AARCH64_TLSDESC_LD64_LO12 563 /* Direct LD off. from 11:3. */ +#define R_AARCH64_TLSDESC_ADD_LO12 564 /* Direct ADD imm. from 11:0. */ +#define R_AARCH64_TLSDESC_OFF_G1 565 /* GOT-rel. MOV{N,Z} imm. 31:16. */ +#define R_AARCH64_TLSDESC_OFF_G0_NC 566 /* GOT-rel. MOVK imm. 15:0; no ck. */ +#define R_AARCH64_TLSDESC_LDR 567 /* Relax LDR. */ +#define R_AARCH64_TLSDESC_ADD 568 /* Relax ADD. */ +#define R_AARCH64_TLSDESC_CALL 569 /* Relax BLR. */ +#define R_AARCH64_TLSLE_LDST128_TPREL_LO12 570 /* TP-rel. LD/ST off. 11:4. */ +#define R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC 571 /* Likewise; no check. */ +#define R_AARCH64_TLSLD_LDST128_DTPREL_LO12 572 /* DTP-rel. LD/ST imm. 11:4. */ +#define R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC 573 /* Likewise; no check. */ +#define R_AARCH64_COPY 1024 /* Copy symbol at runtime. */ +#define R_AARCH64_GLOB_DAT 1025 /* Create GOT entry. */ +#define R_AARCH64_JUMP_SLOT 1026 /* Create PLT entry. */ +#define R_AARCH64_RELATIVE 1027 /* Adjust by program base. */ +#define R_AARCH64_TLS_DTPMOD 1028 /* Module number, 64 bit. */ +#define R_AARCH64_TLS_DTPREL 1029 /* Module-relative offset, 64 bit. */ +#define R_AARCH64_TLS_TPREL 1030 /* TP-relative offset, 64 bit. */ +#define R_AARCH64_TLSDESC 1031 /* TLS Descriptor. */ +#define R_AARCH64_IRELATIVE 1032 /* STT_GNU_IFUNC relocation. */ + +/* MTE memory tag segment type. */ +#define PT_AARCH64_MEMTAG_MTE (PT_LOPROC + 2) + +/* AArch64 specific values for the Dyn d_tag field. */ +#define DT_AARCH64_BTI_PLT (DT_LOPROC + 1) +#define DT_AARCH64_PAC_PLT (DT_LOPROC + 3) +#define DT_AARCH64_VARIANT_PCS (DT_LOPROC + 5) +#define DT_AARCH64_NUM 6 + +/* AArch64 specific values for the st_other field. */ +#define STO_AARCH64_VARIANT_PCS 0x80 + +/* ARM relocs. */ + +#define R_ARM_NONE 0 /* No reloc */ +#define R_ARM_PC24 \ + 1 /* Deprecated PC relative 26 + bit branch. */ +#define R_ARM_ABS32 2 /* Direct 32 bit */ +#define R_ARM_REL32 3 /* PC relative 32 bit */ +#define R_ARM_PC13 4 +#define R_ARM_ABS16 5 /* Direct 16 bit */ +#define R_ARM_ABS12 6 /* Direct 12 bit */ +#define R_ARM_THM_ABS5 7 /* Direct & 0x7C (LDR, STR). */ +#define R_ARM_ABS8 8 /* Direct 8 bit */ +#define R_ARM_SBREL32 9 +#define R_ARM_THM_PC22 10 /* PC relative 24 bit (Thumb32 BL). */ +#define R_ARM_THM_PC8 \ + 11 /* PC relative & 0x3FC + (Thumb16 LDR, ADD, ADR). */ +#define R_ARM_AMP_VCALL9 12 +#define R_ARM_SWI24 13 /* Obsolete static relocation. */ +#define R_ARM_TLS_DESC 13 /* Dynamic relocation. */ +#define R_ARM_THM_SWI8 14 /* Reserved. */ +#define R_ARM_XPC25 15 /* Reserved. */ +#define R_ARM_THM_XPC22 16 /* Reserved. */ +#define R_ARM_TLS_DTPMOD32 17 /* ID of module containing symbol */ +#define R_ARM_TLS_DTPOFF32 18 /* Offset in TLS block */ +#define R_ARM_TLS_TPOFF32 19 /* Offset in static TLS block */ +#define R_ARM_COPY 20 /* Copy symbol at runtime */ +#define R_ARM_GLOB_DAT 21 /* Create GOT entry */ +#define R_ARM_JUMP_SLOT 22 /* Create PLT entry */ +#define R_ARM_RELATIVE 23 /* Adjust by program base */ +#define R_ARM_GOTOFF 24 /* 32 bit offset to GOT */ +#define R_ARM_GOTPC 25 /* 32 bit PC relative offset to GOT */ +#define R_ARM_GOT32 26 /* 32 bit GOT entry */ +#define R_ARM_PLT32 27 /* Deprecated, 32 bit PLT address. */ +#define R_ARM_CALL 28 /* PC relative 24 bit (BL, BLX). */ +#define R_ARM_JUMP24 \ + 29 /* PC relative 24 bit + (B, BL<cond>). */ +#define R_ARM_THM_JUMP24 30 /* PC relative 24 bit (Thumb32 B.W). */ +#define R_ARM_BASE_ABS 31 /* Adjust by program base. */ +#define R_ARM_ALU_PCREL_7_0 32 /* Obsolete. */ +#define R_ARM_ALU_PCREL_15_8 33 /* Obsolete. */ +#define R_ARM_ALU_PCREL_23_15 34 /* Obsolete. */ +#define R_ARM_LDR_SBREL_11_0 35 /* Deprecated, prog. base relative. */ +#define R_ARM_ALU_SBREL_19_12 36 /* Deprecated, prog. base relative. */ +#define R_ARM_ALU_SBREL_27_20 37 /* Deprecated, prog. base relative. */ +#define R_ARM_TARGET1 38 +#define R_ARM_SBREL31 39 /* Program base relative. */ +#define R_ARM_V4BX 40 +#define R_ARM_TARGET2 41 +#define R_ARM_PREL31 42 /* 32 bit PC relative. */ +#define R_ARM_MOVW_ABS_NC 43 /* Direct 16-bit (MOVW). */ +#define R_ARM_MOVT_ABS 44 /* Direct high 16-bit (MOVT). */ +#define R_ARM_MOVW_PREL_NC 45 /* PC relative 16-bit (MOVW). */ +#define R_ARM_MOVT_PREL 46 /* PC relative (MOVT). */ +#define R_ARM_THM_MOVW_ABS_NC 47 /* Direct 16 bit (Thumb32 MOVW). */ +#define R_ARM_THM_MOVT_ABS \ + 48 /* Direct high 16 bit + (Thumb32 MOVT). */ +#define R_ARM_THM_MOVW_PREL_NC \ + 49 /* PC relative 16 bit + (Thumb32 MOVW). */ +#define R_ARM_THM_MOVT_PREL \ + 50 /* PC relative high 16 bit + (Thumb32 MOVT). */ +#define R_ARM_THM_JUMP19 \ + 51 /* PC relative 20 bit + (Thumb32 B<cond>.W). */ +#define R_ARM_THM_JUMP6 \ + 52 /* PC relative X & 0x7E + (Thumb16 CBZ, CBNZ). */ +#define R_ARM_THM_ALU_PREL_11_0 \ + 53 /* PC relative 12 bit + (Thumb32 ADR.W). */ +#define R_ARM_THM_PC12 \ + 54 /* PC relative 12 bit + (Thumb32 LDR{D,SB,H,SH}). */ +#define R_ARM_ABS32_NOI 55 /* Direct 32-bit. */ +#define R_ARM_REL32_NOI 56 /* PC relative 32-bit. */ +#define R_ARM_ALU_PC_G0_NC 57 /* PC relative (ADD, SUB). */ +#define R_ARM_ALU_PC_G0 58 /* PC relative (ADD, SUB). */ +#define R_ARM_ALU_PC_G1_NC 59 /* PC relative (ADD, SUB). */ +#define R_ARM_ALU_PC_G1 60 /* PC relative (ADD, SUB). */ +#define R_ARM_ALU_PC_G2 61 /* PC relative (ADD, SUB). */ +#define R_ARM_LDR_PC_G1 62 /* PC relative (LDR,STR,LDRB,STRB). */ +#define R_ARM_LDR_PC_G2 63 /* PC relative (LDR,STR,LDRB,STRB). */ +#define R_ARM_LDRS_PC_G0 \ + 64 /* PC relative (STR{D,H}, + LDR{D,SB,H,SH}). */ +#define R_ARM_LDRS_PC_G1 \ + 65 /* PC relative (STR{D,H}, + LDR{D,SB,H,SH}). */ +#define R_ARM_LDRS_PC_G2 \ + 66 /* PC relative (STR{D,H}, + LDR{D,SB,H,SH}). */ +#define R_ARM_LDC_PC_G0 67 /* PC relative (LDC, STC). */ +#define R_ARM_LDC_PC_G1 68 /* PC relative (LDC, STC). */ +#define R_ARM_LDC_PC_G2 69 /* PC relative (LDC, STC). */ +#define R_ARM_ALU_SB_G0_NC 70 /* Program base relative (ADD,SUB). */ +#define R_ARM_ALU_SB_G0 71 /* Program base relative (ADD,SUB). */ +#define R_ARM_ALU_SB_G1_NC 72 /* Program base relative (ADD,SUB). */ +#define R_ARM_ALU_SB_G1 73 /* Program base relative (ADD,SUB). */ +#define R_ARM_ALU_SB_G2 74 /* Program base relative (ADD,SUB). */ +#define R_ARM_LDR_SB_G0 \ + 75 /* Program base relative (LDR, + STR, LDRB, STRB). */ +#define R_ARM_LDR_SB_G1 \ + 76 /* Program base relative + (LDR, STR, LDRB, STRB). */ +#define R_ARM_LDR_SB_G2 \ + 77 /* Program base relative + (LDR, STR, LDRB, STRB). */ +#define R_ARM_LDRS_SB_G0 \ + 78 /* Program base relative + (LDR, STR, LDRB, STRB). */ +#define R_ARM_LDRS_SB_G1 \ + 79 /* Program base relative + (LDR, STR, LDRB, STRB). */ +#define R_ARM_LDRS_SB_G2 \ + 80 /* Program base relative + (LDR, STR, LDRB, STRB). */ +#define R_ARM_LDC_SB_G0 81 /* Program base relative (LDC,STC). */ +#define R_ARM_LDC_SB_G1 82 /* Program base relative (LDC,STC). */ +#define R_ARM_LDC_SB_G2 83 /* Program base relative (LDC,STC). */ +#define R_ARM_MOVW_BREL_NC \ + 84 /* Program base relative 16 + bit (MOVW). */ +#define R_ARM_MOVT_BREL \ + 85 /* Program base relative high + 16 bit (MOVT). */ +#define R_ARM_MOVW_BREL \ + 86 /* Program base relative 16 + bit (MOVW). */ +#define R_ARM_THM_MOVW_BREL_NC \ + 87 /* Program base relative 16 + bit (Thumb32 MOVW). */ +#define R_ARM_THM_MOVT_BREL \ + 88 /* Program base relative high + 16 bit (Thumb32 MOVT). */ +#define R_ARM_THM_MOVW_BREL \ + 89 /* Program base relative 16 + bit (Thumb32 MOVW). */ +#define R_ARM_TLS_GOTDESC 90 +#define R_ARM_TLS_CALL 91 +#define R_ARM_TLS_DESCSEQ 92 /* TLS relaxation. */ +#define R_ARM_THM_TLS_CALL 93 +#define R_ARM_PLT32_ABS 94 +#define R_ARM_GOT_ABS 95 /* GOT entry. */ +#define R_ARM_GOT_PREL 96 /* PC relative GOT entry. */ +#define R_ARM_GOT_BREL12 \ + 97 /* GOT entry relative to GOT + origin (LDR). */ +#define R_ARM_GOTOFF12 \ + 98 /* 12 bit, GOT entry relative + to GOT origin (LDR, STR). */ +#define R_ARM_GOTRELAX 99 +#define R_ARM_GNU_VTENTRY 100 +#define R_ARM_GNU_VTINHERIT 101 +#define R_ARM_THM_PC11 102 /* PC relative & 0xFFE (Thumb16 B). */ +#define R_ARM_THM_PC9 \ + 103 /* PC relative & 0x1FE + (Thumb16 B/B<cond>). */ +#define R_ARM_TLS_GD32 \ + 104 /* PC-rel 32 bit for global dynamic + thread local data */ +#define R_ARM_TLS_LDM32 \ + 105 /* PC-rel 32 bit for local dynamic + thread local data */ +#define R_ARM_TLS_LDO32 \ + 106 /* 32 bit offset relative to TLS + block */ +#define R_ARM_TLS_IE32 \ + 107 /* PC-rel 32 bit for GOT entry of + static TLS block offset */ +#define R_ARM_TLS_LE32 \ + 108 /* 32 bit offset relative to static + TLS block */ +#define R_ARM_TLS_LDO12 \ + 109 /* 12 bit relative to TLS + block (LDR, STR). */ +#define R_ARM_TLS_LE12 \ + 110 /* 12 bit relative to static + TLS block (LDR, STR). */ +#define R_ARM_TLS_IE12GP \ + 111 /* 12 bit GOT entry relative + to GOT origin (LDR). */ +#define R_ARM_ME_TOO 128 /* Obsolete. */ +#define R_ARM_THM_TLS_DESCSEQ 129 +#define R_ARM_THM_TLS_DESCSEQ16 129 +#define R_ARM_THM_TLS_DESCSEQ32 130 +#define R_ARM_THM_GOT_BREL12 \ + 131 /* GOT entry relative to GOT + origin, 12 bit (Thumb32 LDR). */ +#define R_ARM_IRELATIVE 160 +#define R_ARM_RXPC25 249 +#define R_ARM_RSBREL32 250 +#define R_ARM_THM_RPC22 251 +#define R_ARM_RREL32 252 +#define R_ARM_RABS22 253 +#define R_ARM_RPC24 254 +#define R_ARM_RBASE 255 +/* Keep this the last entry. */ +#define R_ARM_NUM 256 + +/* C-SKY */ +#define R_CKCORE_NONE 0 /* no reloc */ +#define R_CKCORE_ADDR32 1 /* direct 32 bit (S + A) */ +#define R_CKCORE_PCRELIMM8BY4 2 /* disp ((S + A - P) >> 2) & 0xff */ +#define R_CKCORE_PCRELIMM11BY2 3 /* disp ((S + A - P) >> 1) & 0x7ff */ +#define R_CKCORE_PCREL32 5 /* 32-bit rel (S + A - P) */ +#define R_CKCORE_PCRELJSR_IMM11BY2 6 /* disp ((S + A - P) >>1) & 0x7ff */ +#define R_CKCORE_RELATIVE 9 /* 32 bit adjust program base(B + A)*/ +#define R_CKCORE_COPY 10 /* 32 bit adjust by program base */ +#define R_CKCORE_GLOB_DAT 11 /* off between got and sym (S) */ +#define R_CKCORE_JUMP_SLOT 12 /* PLT entry (S) */ +#define R_CKCORE_GOTOFF 13 /* offset to GOT (S + A - GOT) */ +#define R_CKCORE_GOTPC 14 /* PC offset to GOT (GOT + A - P) */ +#define R_CKCORE_GOT32 15 /* 32 bit GOT entry (G) */ +#define R_CKCORE_PLT32 16 /* 32 bit PLT entry (G) */ +#define R_CKCORE_ADDRGOT 17 /* GOT entry in GLOB_DAT (GOT + G) */ +#define R_CKCORE_ADDRPLT 18 /* PLT entry in GLOB_DAT (GOT + G) */ +#define R_CKCORE_PCREL_IMM26BY2 19 /* ((S + A - P) >> 1) & 0x3ffffff */ +#define R_CKCORE_PCREL_IMM16BY2 20 /* disp ((S + A - P) >> 1) & 0xffff */ +#define R_CKCORE_PCREL_IMM16BY4 21 /* disp ((S + A - P) >> 2) & 0xffff */ +#define R_CKCORE_PCREL_IMM10BY2 22 /* disp ((S + A - P) >> 1) & 0x3ff */ +#define R_CKCORE_PCREL_IMM10BY4 23 /* disp ((S + A - P) >> 2) & 0x3ff */ +#define R_CKCORE_ADDR_HI16 24 /* high & low 16 bit ADDR */ +/* ((S + A) >> 16) & 0xffff */ +#define R_CKCORE_ADDR_LO16 25 /* (S + A) & 0xffff */ +#define R_CKCORE_GOTPC_HI16 26 /* high & low 16 bit GOTPC */ +/* ((GOT + A - P) >> 16) & 0xffff */ +#define R_CKCORE_GOTPC_LO16 27 /* (GOT + A - P) & 0xffff */ +#define R_CKCORE_GOTOFF_HI16 28 /* high & low 16 bit GOTOFF */ +/* ((S + A - GOT) >> 16) & 0xffff */ +#define R_CKCORE_GOTOFF_LO16 29 /* (S + A - GOT) & 0xffff */ +#define R_CKCORE_GOT12 30 /* 12 bit disp GOT entry (G) */ +#define R_CKCORE_GOT_HI16 31 /* high & low 16 bit GOT */ +/* (G >> 16) & 0xffff */ +#define R_CKCORE_GOT_LO16 32 /* (G & 0xffff) */ +#define R_CKCORE_PLT12 33 /* 12 bit disp PLT entry (G) */ +#define R_CKCORE_PLT_HI16 34 /* high & low 16 bit PLT */ +/* (G >> 16) & 0xffff */ +#define R_CKCORE_PLT_LO16 35 /* G & 0xffff */ +#define R_CKCORE_ADDRGOT_HI16 36 /* high & low 16 bit ADDRGOT */ +/* (GOT + G * 4) & 0xffff */ +#define R_CKCORE_ADDRGOT_LO16 37 /* (GOT + G * 4) & 0xffff */ +#define R_CKCORE_ADDRPLT_HI16 38 /* high & low 16 bit ADDRPLT */ +/* ((GOT + G * 4) >> 16) & 0xFFFF */ +#define R_CKCORE_ADDRPLT_LO16 39 /* (GOT+G*4) & 0xffff */ +#define R_CKCORE_PCREL_JSR_IMM26BY2 40 /* disp ((S+A-P) >>1) & x3ffffff */ +#define R_CKCORE_TOFFSET_LO16 41 /* (S+A-BTEXT) & 0xffff */ +#define R_CKCORE_DOFFSET_LO16 42 /* (S+A-BTEXT) & 0xffff */ +#define R_CKCORE_PCREL_IMM18BY2 43 /* disp ((S+A-P) >>1) & 0x3ffff */ +#define R_CKCORE_DOFFSET_IMM18 44 /* disp (S+A-BDATA) & 0x3ffff */ +#define R_CKCORE_DOFFSET_IMM18BY2 45 /* disp ((S+A-BDATA)>>1) & 0x3ffff */ +#define R_CKCORE_DOFFSET_IMM18BY4 46 /* disp ((S+A-BDATA)>>2) & 0x3ffff */ +#define R_CKCORE_GOT_IMM18BY4 48 /* disp (G >> 2) */ +#define R_CKCORE_PLT_IMM18BY4 49 /* disp (G >> 2) */ +#define R_CKCORE_PCREL_IMM7BY4 50 /* disp ((S+A-P) >>2) & 0x7f */ +#define R_CKCORE_TLS_LE32 51 /* 32 bit offset to TLS block */ +#define R_CKCORE_TLS_IE32 52 +#define R_CKCORE_TLS_GD32 53 +#define R_CKCORE_TLS_LDM32 54 +#define R_CKCORE_TLS_LDO32 55 +#define R_CKCORE_TLS_DTPMOD32 56 +#define R_CKCORE_TLS_DTPOFF32 57 +#define R_CKCORE_TLS_TPOFF32 58 + +/* C-SKY elf header definition. */ +#define EF_CSKY_ABIMASK 0XF0000000 +#define EF_CSKY_OTHER 0X0FFF0000 +#define EF_CSKY_PROCESSOR 0X0000FFFF + +#define EF_CSKY_ABIV1 0X10000000 +#define EF_CSKY_ABIV2 0X20000000 + +/* C-SKY attributes section. */ +#define SHT_CSKY_ATTRIBUTES (SHT_LOPROC + 1) + +/* IA-64 specific declarations. */ + +/* Processor specific flags for the Ehdr e_flags field. */ +#define EF_IA_64_MASKOS 0x0000000f /* os-specific flags */ +#define EF_IA_64_ABI64 0x00000010 /* 64-bit ABI */ +#define EF_IA_64_ARCH 0xff000000 /* arch. version mask */ + +/* Processor specific values for the Phdr p_type field. */ +#define PT_IA_64_ARCHEXT (PT_LOPROC + 0) /* arch extension bits */ +#define PT_IA_64_UNWIND (PT_LOPROC + 1) /* ia64 unwind bits */ +#define PT_IA_64_HP_OPT_ANOT (PT_LOOS + 0x12) +#define PT_IA_64_HP_HSL_ANOT (PT_LOOS + 0x13) +#define PT_IA_64_HP_STACK (PT_LOOS + 0x14) + +/* Processor specific flags for the Phdr p_flags field. */ +#define PF_IA_64_NORECOV 0x80000000 /* spec insns w/o recovery */ + +/* Processor specific values for the Shdr sh_type field. */ +#define SHT_IA_64_EXT (SHT_LOPROC + 0) /* extension bits */ +#define SHT_IA_64_UNWIND (SHT_LOPROC + 1) /* unwind bits */ + +/* Processor specific flags for the Shdr sh_flags field. */ +#define SHF_IA_64_SHORT 0x10000000 /* section near gp */ +#define SHF_IA_64_NORECOV 0x20000000 /* spec insns w/o recovery */ + +/* Processor specific values for the Dyn d_tag field. */ +#define DT_IA_64_PLT_RESERVE (DT_LOPROC + 0) +#define DT_IA_64_NUM 1 + +/* IA-64 relocations. */ +#define R_IA64_NONE 0x00 /* none */ +#define R_IA64_IMM14 0x21 /* symbol + addend, add imm14 */ +#define R_IA64_IMM22 0x22 /* symbol + addend, add imm22 */ +#define R_IA64_IMM64 0x23 /* symbol + addend, mov imm64 */ +#define R_IA64_DIR32MSB 0x24 /* symbol + addend, data4 MSB */ +#define R_IA64_DIR32LSB 0x25 /* symbol + addend, data4 LSB */ +#define R_IA64_DIR64MSB 0x26 /* symbol + addend, data8 MSB */ +#define R_IA64_DIR64LSB 0x27 /* symbol + addend, data8 LSB */ +#define R_IA64_GPREL22 0x2a /* @gprel(sym + add), add imm22 */ +#define R_IA64_GPREL64I 0x2b /* @gprel(sym + add), mov imm64 */ +#define R_IA64_GPREL32MSB 0x2c /* @gprel(sym + add), data4 MSB */ +#define R_IA64_GPREL32LSB 0x2d /* @gprel(sym + add), data4 LSB */ +#define R_IA64_GPREL64MSB 0x2e /* @gprel(sym + add), data8 MSB */ +#define R_IA64_GPREL64LSB 0x2f /* @gprel(sym + add), data8 LSB */ +#define R_IA64_LTOFF22 0x32 /* @ltoff(sym + add), add imm22 */ +#define R_IA64_LTOFF64I 0x33 /* @ltoff(sym + add), mov imm64 */ +#define R_IA64_PLTOFF22 0x3a /* @pltoff(sym + add), add imm22 */ +#define R_IA64_PLTOFF64I 0x3b /* @pltoff(sym + add), mov imm64 */ +#define R_IA64_PLTOFF64MSB 0x3e /* @pltoff(sym + add), data8 MSB */ +#define R_IA64_PLTOFF64LSB 0x3f /* @pltoff(sym + add), data8 LSB */ +#define R_IA64_FPTR64I 0x43 /* @fptr(sym + add), mov imm64 */ +#define R_IA64_FPTR32MSB 0x44 /* @fptr(sym + add), data4 MSB */ +#define R_IA64_FPTR32LSB 0x45 /* @fptr(sym + add), data4 LSB */ +#define R_IA64_FPTR64MSB 0x46 /* @fptr(sym + add), data8 MSB */ +#define R_IA64_FPTR64LSB 0x47 /* @fptr(sym + add), data8 LSB */ +#define R_IA64_PCREL60B 0x48 /* @pcrel(sym + add), brl */ +#define R_IA64_PCREL21B 0x49 /* @pcrel(sym + add), ptb, call */ +#define R_IA64_PCREL21M 0x4a /* @pcrel(sym + add), chk.s */ +#define R_IA64_PCREL21F 0x4b /* @pcrel(sym + add), fchkf */ +#define R_IA64_PCREL32MSB 0x4c /* @pcrel(sym + add), data4 MSB */ +#define R_IA64_PCREL32LSB 0x4d /* @pcrel(sym + add), data4 LSB */ +#define R_IA64_PCREL64MSB 0x4e /* @pcrel(sym + add), data8 MSB */ +#define R_IA64_PCREL64LSB 0x4f /* @pcrel(sym + add), data8 LSB */ +#define R_IA64_LTOFF_FPTR22 0x52 /* @ltoff(@fptr(s+a)), imm22 */ +#define R_IA64_LTOFF_FPTR64I 0x53 /* @ltoff(@fptr(s+a)), imm64 */ +#define R_IA64_LTOFF_FPTR32MSB 0x54 /* @ltoff(@fptr(s+a)), data4 MSB */ +#define R_IA64_LTOFF_FPTR32LSB 0x55 /* @ltoff(@fptr(s+a)), data4 LSB */ +#define R_IA64_LTOFF_FPTR64MSB 0x56 /* @ltoff(@fptr(s+a)), data8 MSB */ +#define R_IA64_LTOFF_FPTR64LSB 0x57 /* @ltoff(@fptr(s+a)), data8 LSB */ +#define R_IA64_SEGREL32MSB 0x5c /* @segrel(sym + add), data4 MSB */ +#define R_IA64_SEGREL32LSB 0x5d /* @segrel(sym + add), data4 LSB */ +#define R_IA64_SEGREL64MSB 0x5e /* @segrel(sym + add), data8 MSB */ +#define R_IA64_SEGREL64LSB 0x5f /* @segrel(sym + add), data8 LSB */ +#define R_IA64_SECREL32MSB 0x64 /* @secrel(sym + add), data4 MSB */ +#define R_IA64_SECREL32LSB 0x65 /* @secrel(sym + add), data4 LSB */ +#define R_IA64_SECREL64MSB 0x66 /* @secrel(sym + add), data8 MSB */ +#define R_IA64_SECREL64LSB 0x67 /* @secrel(sym + add), data8 LSB */ +#define R_IA64_REL32MSB 0x6c /* data 4 + REL */ +#define R_IA64_REL32LSB 0x6d /* data 4 + REL */ +#define R_IA64_REL64MSB 0x6e /* data 8 + REL */ +#define R_IA64_REL64LSB 0x6f /* data 8 + REL */ +#define R_IA64_LTV32MSB 0x74 /* symbol + addend, data4 MSB */ +#define R_IA64_LTV32LSB 0x75 /* symbol + addend, data4 LSB */ +#define R_IA64_LTV64MSB 0x76 /* symbol + addend, data8 MSB */ +#define R_IA64_LTV64LSB 0x77 /* symbol + addend, data8 LSB */ +#define R_IA64_PCREL21BI 0x79 /* @pcrel(sym + add), 21bit inst */ +#define R_IA64_PCREL22 0x7a /* @pcrel(sym + add), 22bit inst */ +#define R_IA64_PCREL64I 0x7b /* @pcrel(sym + add), 64bit inst */ +#define R_IA64_IPLTMSB 0x80 /* dynamic reloc, imported PLT, MSB */ +#define R_IA64_IPLTLSB 0x81 /* dynamic reloc, imported PLT, LSB */ +#define R_IA64_COPY 0x84 /* copy relocation */ +#define R_IA64_SUB 0x85 /* Addend and symbol difference */ +#define R_IA64_LTOFF22X 0x86 /* LTOFF22, relaxable. */ +#define R_IA64_LDXMOV 0x87 /* Use of LTOFF22X. */ +#define R_IA64_TPREL14 0x91 /* @tprel(sym + add), imm14 */ +#define R_IA64_TPREL22 0x92 /* @tprel(sym + add), imm22 */ +#define R_IA64_TPREL64I 0x93 /* @tprel(sym + add), imm64 */ +#define R_IA64_TPREL64MSB 0x96 /* @tprel(sym + add), data8 MSB */ +#define R_IA64_TPREL64LSB 0x97 /* @tprel(sym + add), data8 LSB */ +#define R_IA64_LTOFF_TPREL22 0x9a /* @ltoff(@tprel(s+a)), imm2 */ +#define R_IA64_DTPMOD64MSB 0xa6 /* @dtpmod(sym + add), data8 MSB */ +#define R_IA64_DTPMOD64LSB 0xa7 /* @dtpmod(sym + add), data8 LSB */ +#define R_IA64_LTOFF_DTPMOD22 0xaa /* @ltoff(@dtpmod(sym + add)), imm22 */ +#define R_IA64_DTPREL14 0xb1 /* @dtprel(sym + add), imm14 */ +#define R_IA64_DTPREL22 0xb2 /* @dtprel(sym + add), imm22 */ +#define R_IA64_DTPREL64I 0xb3 /* @dtprel(sym + add), imm64 */ +#define R_IA64_DTPREL32MSB 0xb4 /* @dtprel(sym + add), data4 MSB */ +#define R_IA64_DTPREL32LSB 0xb5 /* @dtprel(sym + add), data4 LSB */ +#define R_IA64_DTPREL64MSB 0xb6 /* @dtprel(sym + add), data8 MSB */ +#define R_IA64_DTPREL64LSB 0xb7 /* @dtprel(sym + add), data8 LSB */ +#define R_IA64_LTOFF_DTPREL22 0xba /* @ltoff(@dtprel(s+a)), imm22 */ + +/* SH specific declarations */ + +/* Processor specific flags for the ELF header e_flags field. */ +#define EF_SH_MACH_MASK 0x1f +#define EF_SH_UNKNOWN 0x0 +#define EF_SH1 0x1 +#define EF_SH2 0x2 +#define EF_SH3 0x3 +#define EF_SH_DSP 0x4 +#define EF_SH3_DSP 0x5 +#define EF_SH4AL_DSP 0x6 +#define EF_SH3E 0x8 +#define EF_SH4 0x9 +#define EF_SH2E 0xb +#define EF_SH4A 0xc +#define EF_SH2A 0xd +#define EF_SH4_NOFPU 0x10 +#define EF_SH4A_NOFPU 0x11 +#define EF_SH4_NOMMU_NOFPU 0x12 +#define EF_SH2A_NOFPU 0x13 +#define EF_SH3_NOMMU 0x14 +#define EF_SH2A_SH4_NOFPU 0x15 +#define EF_SH2A_SH3_NOFPU 0x16 +#define EF_SH2A_SH4 0x17 +#define EF_SH2A_SH3E 0x18 + +/* SH relocs. */ +#define R_SH_NONE 0 +#define R_SH_DIR32 1 +#define R_SH_REL32 2 +#define R_SH_DIR8WPN 3 +#define R_SH_IND12W 4 +#define R_SH_DIR8WPL 5 +#define R_SH_DIR8WPZ 6 +#define R_SH_DIR8BP 7 +#define R_SH_DIR8W 8 +#define R_SH_DIR8L 9 +#define R_SH_SWITCH16 25 +#define R_SH_SWITCH32 26 +#define R_SH_USES 27 +#define R_SH_COUNT 28 +#define R_SH_ALIGN 29 +#define R_SH_CODE 30 +#define R_SH_DATA 31 +#define R_SH_LABEL 32 +#define R_SH_SWITCH8 33 +#define R_SH_GNU_VTINHERIT 34 +#define R_SH_GNU_VTENTRY 35 +#define R_SH_TLS_GD_32 144 +#define R_SH_TLS_LD_32 145 +#define R_SH_TLS_LDO_32 146 +#define R_SH_TLS_IE_32 147 +#define R_SH_TLS_LE_32 148 +#define R_SH_TLS_DTPMOD32 149 +#define R_SH_TLS_DTPOFF32 150 +#define R_SH_TLS_TPOFF32 151 +#define R_SH_GOT32 160 +#define R_SH_PLT32 161 +#define R_SH_COPY 162 +#define R_SH_GLOB_DAT 163 +#define R_SH_JMP_SLOT 164 +#define R_SH_RELATIVE 165 +#define R_SH_GOTOFF 166 +#define R_SH_GOTPC 167 +/* Keep this the last entry. */ +#define R_SH_NUM 256 + +/* S/390 specific definitions. */ + +/* Valid values for the e_flags field. */ + +#define EF_S390_HIGH_GPRS 0x00000001 /* High GPRs kernel facility needed. */ + +/* Additional s390 relocs */ + +#define R_390_NONE 0 /* No reloc. */ +#define R_390_8 1 /* Direct 8 bit. */ +#define R_390_12 2 /* Direct 12 bit. */ +#define R_390_16 3 /* Direct 16 bit. */ +#define R_390_32 4 /* Direct 32 bit. */ +#define R_390_PC32 5 /* PC relative 32 bit. */ +#define R_390_GOT12 6 /* 12 bit GOT offset. */ +#define R_390_GOT32 7 /* 32 bit GOT offset. */ +#define R_390_PLT32 8 /* 32 bit PC relative PLT address. */ +#define R_390_COPY 9 /* Copy symbol at runtime. */ +#define R_390_GLOB_DAT 10 /* Create GOT entry. */ +#define R_390_JMP_SLOT 11 /* Create PLT entry. */ +#define R_390_RELATIVE 12 /* Adjust by program base. */ +#define R_390_GOTOFF32 13 /* 32 bit offset to GOT. */ +#define R_390_GOTPC 14 /* 32 bit PC relative offset to GOT. */ +#define R_390_GOT16 15 /* 16 bit GOT offset. */ +#define R_390_PC16 16 /* PC relative 16 bit. */ +#define R_390_PC16DBL 17 /* PC relative 16 bit shifted by 1. */ +#define R_390_PLT16DBL 18 /* 16 bit PC rel. PLT shifted by 1. */ +#define R_390_PC32DBL 19 /* PC relative 32 bit shifted by 1. */ +#define R_390_PLT32DBL 20 /* 32 bit PC rel. PLT shifted by 1. */ +#define R_390_GOTPCDBL 21 /* 32 bit PC rel. GOT shifted by 1. */ +#define R_390_64 22 /* Direct 64 bit. */ +#define R_390_PC64 23 /* PC relative 64 bit. */ +#define R_390_GOT64 24 /* 64 bit GOT offset. */ +#define R_390_PLT64 25 /* 64 bit PC relative PLT address. */ +#define R_390_GOTENT 26 /* 32 bit PC rel. to GOT entry >> 1. */ +#define R_390_GOTOFF16 27 /* 16 bit offset to GOT. */ +#define R_390_GOTOFF64 28 /* 64 bit offset to GOT. */ +#define R_390_GOTPLT12 29 /* 12 bit offset to jump slot. */ +#define R_390_GOTPLT16 30 /* 16 bit offset to jump slot. */ +#define R_390_GOTPLT32 31 /* 32 bit offset to jump slot. */ +#define R_390_GOTPLT64 32 /* 64 bit offset to jump slot. */ +#define R_390_GOTPLTENT 33 /* 32 bit rel. offset to jump slot. */ +#define R_390_PLTOFF16 34 /* 16 bit offset from GOT to PLT. */ +#define R_390_PLTOFF32 35 /* 32 bit offset from GOT to PLT. */ +#define R_390_PLTOFF64 36 /* 16 bit offset from GOT to PLT. */ +#define R_390_TLS_LOAD 37 /* Tag for load insn in TLS code. */ +#define R_390_TLS_GDCALL \ + 38 /* Tag for function call in general + dynamic TLS code. */ +#define R_390_TLS_LDCALL \ + 39 /* Tag for function call in local + dynamic TLS code. */ +#define R_390_TLS_GD32 \ + 40 /* Direct 32 bit for general dynamic + thread local data. */ +#define R_390_TLS_GD64 \ + 41 /* Direct 64 bit for general dynamic + thread local data. */ +#define R_390_TLS_GOTIE12 \ + 42 /* 12 bit GOT offset for static TLS + block offset. */ +#define R_390_TLS_GOTIE32 \ + 43 /* 32 bit GOT offset for static TLS + block offset. */ +#define R_390_TLS_GOTIE64 \ + 44 /* 64 bit GOT offset for static TLS + block offset. */ +#define R_390_TLS_LDM32 \ + 45 /* Direct 32 bit for local dynamic + thread local data in LE code. */ +#define R_390_TLS_LDM64 \ + 46 /* Direct 64 bit for local dynamic + thread local data in LE code. */ +#define R_390_TLS_IE32 \ + 47 /* 32 bit address of GOT entry for + negated static TLS block offset. */ +#define R_390_TLS_IE64 \ + 48 /* 64 bit address of GOT entry for + negated static TLS block offset. */ +#define R_390_TLS_IEENT \ + 49 /* 32 bit rel. offset to GOT entry for + negated static TLS block offset. */ +#define R_390_TLS_LE32 \ + 50 /* 32 bit negated offset relative to + static TLS block. */ +#define R_390_TLS_LE64 \ + 51 /* 64 bit negated offset relative to + static TLS block. */ +#define R_390_TLS_LDO32 \ + 52 /* 32 bit offset relative to TLS + block. */ +#define R_390_TLS_LDO64 \ + 53 /* 64 bit offset relative to TLS + block. */ +#define R_390_TLS_DTPMOD 54 /* ID of module containing symbol. */ +#define R_390_TLS_DTPOFF 55 /* Offset in TLS block. */ +#define R_390_TLS_TPOFF \ + 56 /* Negated offset in static TLS + block. */ +#define R_390_20 57 /* Direct 20 bit. */ +#define R_390_GOT20 58 /* 20 bit GOT offset. */ +#define R_390_GOTPLT20 59 /* 20 bit offset to jump slot. */ +#define R_390_TLS_GOTIE20 \ + 60 /* 20 bit GOT offset for static TLS + block offset. */ +#define R_390_IRELATIVE 61 /* STT_GNU_IFUNC relocation. */ +/* Keep this the last entry. */ +#define R_390_NUM 62 + +/* CRIS relocations. */ +#define R_CRIS_NONE 0 +#define R_CRIS_8 1 +#define R_CRIS_16 2 +#define R_CRIS_32 3 +#define R_CRIS_8_PCREL 4 +#define R_CRIS_16_PCREL 5 +#define R_CRIS_32_PCREL 6 +#define R_CRIS_GNU_VTINHERIT 7 +#define R_CRIS_GNU_VTENTRY 8 +#define R_CRIS_COPY 9 +#define R_CRIS_GLOB_DAT 10 +#define R_CRIS_JUMP_SLOT 11 +#define R_CRIS_RELATIVE 12 +#define R_CRIS_16_GOT 13 +#define R_CRIS_32_GOT 14 +#define R_CRIS_16_GOTPLT 15 +#define R_CRIS_32_GOTPLT 16 +#define R_CRIS_32_GOTREL 17 +#define R_CRIS_32_PLT_GOTREL 18 +#define R_CRIS_32_PLT_PCREL 19 + +#define R_CRIS_NUM 20 + +/* AMD x86-64 relocations. */ +#define R_X86_64_NONE 0 /* No reloc */ +#define R_X86_64_64 1 /* Direct 64 bit */ +#define R_X86_64_PC32 2 /* PC relative 32 bit signed */ +#define R_X86_64_GOT32 3 /* 32 bit GOT entry */ +#define R_X86_64_PLT32 4 /* 32 bit PLT address */ +#define R_X86_64_COPY 5 /* Copy symbol at runtime */ +#define R_X86_64_GLOB_DAT 6 /* Create GOT entry */ +#define R_X86_64_JUMP_SLOT 7 /* Create PLT entry */ +#define R_X86_64_RELATIVE 8 /* Adjust by program base */ +#define R_X86_64_GOTPCREL \ + 9 /* 32 bit signed PC relative + offset to GOT */ +#define R_X86_64_32 10 /* Direct 32 bit zero extended */ +#define R_X86_64_32S 11 /* Direct 32 bit sign extended */ +#define R_X86_64_16 12 /* Direct 16 bit zero extended */ +#define R_X86_64_PC16 13 /* 16 bit sign extended pc relative */ +#define R_X86_64_8 14 /* Direct 8 bit sign extended */ +#define R_X86_64_PC8 15 /* 8 bit sign extended pc relative */ +#define R_X86_64_DTPMOD64 16 /* ID of module containing symbol */ +#define R_X86_64_DTPOFF64 17 /* Offset in module's TLS block */ +#define R_X86_64_TPOFF64 18 /* Offset in initial TLS block */ +#define R_X86_64_TLSGD \ + 19 /* 32 bit signed PC relative offset + to two GOT entries for GD symbol */ +#define R_X86_64_TLSLD \ + 20 /* 32 bit signed PC relative offset + to two GOT entries for LD symbol */ +#define R_X86_64_DTPOFF32 21 /* Offset in TLS block */ +#define R_X86_64_GOTTPOFF \ + 22 /* 32 bit signed PC relative offset + to GOT entry for IE symbol */ +#define R_X86_64_TPOFF32 23 /* Offset in initial TLS block */ +#define R_X86_64_PC64 24 /* PC relative 64 bit */ +#define R_X86_64_GOTOFF64 25 /* 64 bit offset to GOT */ +#define R_X86_64_GOTPC32 \ + 26 /* 32 bit signed pc relative + offset to GOT */ +#define R_X86_64_GOT64 27 /* 64-bit GOT entry offset */ +#define R_X86_64_GOTPCREL64 \ + 28 /* 64-bit PC relative offset + to GOT entry */ +#define R_X86_64_GOTPC64 29 /* 64-bit PC relative offset to GOT */ +#define R_X86_64_GOTPLT64 30 /* like GOT64, says PLT entry needed */ +#define R_X86_64_PLTOFF64 \ + 31 /* 64-bit GOT relative offset + to PLT entry */ +#define R_X86_64_SIZE32 32 /* Size of symbol plus 32-bit addend */ +#define R_X86_64_SIZE64 33 /* Size of symbol plus 64-bit addend */ +#define R_X86_64_GOTPC32_TLSDESC 34 /* GOT offset for TLS descriptor. */ +#define R_X86_64_TLSDESC_CALL \ + 35 /* Marker for call through TLS + descriptor. */ +#define R_X86_64_TLSDESC 36 /* TLS descriptor. */ +#define R_X86_64_IRELATIVE 37 /* Adjust indirectly by program base */ +#define R_X86_64_RELATIVE64 38 /* 64-bit adjust by program base */ +/* 39 Reserved was R_X86_64_PC32_BND */ +/* 40 Reserved was R_X86_64_PLT32_BND */ +#define R_X86_64_GOTPCRELX \ + 41 /* Load from 32 bit signed pc relative + offset to GOT entry without REX + prefix, relaxable. */ +#define R_X86_64_REX_GOTPCRELX \ + 42 /* Load from 32 bit signed pc relative + offset to GOT entry with REX prefix, + relaxable. */ +#define R_X86_64_NUM 43 + +/* x86-64 sh_type values. */ +#define SHT_X86_64_UNWIND 0x70000001 /* Unwind information. */ + +/* x86-64 d_tag values. */ +#define DT_X86_64_PLT (DT_LOPROC + 0) +#define DT_X86_64_PLTSZ (DT_LOPROC + 1) +#define DT_X86_64_PLTENT (DT_LOPROC + 3) +#define DT_X86_64_NUM 4 + +/* AM33 relocations. */ +#define R_MN10300_NONE 0 /* No reloc. */ +#define R_MN10300_32 1 /* Direct 32 bit. */ +#define R_MN10300_16 2 /* Direct 16 bit. */ +#define R_MN10300_8 3 /* Direct 8 bit. */ +#define R_MN10300_PCREL32 4 /* PC-relative 32-bit. */ +#define R_MN10300_PCREL16 5 /* PC-relative 16-bit signed. */ +#define R_MN10300_PCREL8 6 /* PC-relative 8-bit signed. */ +#define R_MN10300_GNU_VTINHERIT 7 /* Ancient C++ vtable garbage... */ +#define R_MN10300_GNU_VTENTRY 8 /* ... collection annotation. */ +#define R_MN10300_24 9 /* Direct 24 bit. */ +#define R_MN10300_GOTPC32 10 /* 32-bit PCrel offset to GOT. */ +#define R_MN10300_GOTPC16 11 /* 16-bit PCrel offset to GOT. */ +#define R_MN10300_GOTOFF32 12 /* 32-bit offset from GOT. */ +#define R_MN10300_GOTOFF24 13 /* 24-bit offset from GOT. */ +#define R_MN10300_GOTOFF16 14 /* 16-bit offset from GOT. */ +#define R_MN10300_PLT32 15 /* 32-bit PCrel to PLT entry. */ +#define R_MN10300_PLT16 16 /* 16-bit PCrel to PLT entry. */ +#define R_MN10300_GOT32 17 /* 32-bit offset to GOT entry. */ +#define R_MN10300_GOT24 18 /* 24-bit offset to GOT entry. */ +#define R_MN10300_GOT16 19 /* 16-bit offset to GOT entry. */ +#define R_MN10300_COPY 20 /* Copy symbol at runtime. */ +#define R_MN10300_GLOB_DAT 21 /* Create GOT entry. */ +#define R_MN10300_JMP_SLOT 22 /* Create PLT entry. */ +#define R_MN10300_RELATIVE 23 /* Adjust by program base. */ +#define R_MN10300_TLS_GD 24 /* 32-bit offset for global dynamic. */ +#define R_MN10300_TLS_LD 25 /* 32-bit offset for local dynamic. */ +#define R_MN10300_TLS_LDO 26 /* Module-relative offset. */ +#define R_MN10300_TLS_GOTIE \ + 27 /* GOT offset for static TLS block + offset. */ +#define R_MN10300_TLS_IE \ + 28 /* GOT address for static TLS block + offset. */ +#define R_MN10300_TLS_LE \ + 29 /* Offset relative to static TLS + block. */ +#define R_MN10300_TLS_DTPMOD 30 /* ID of module containing symbol. */ +#define R_MN10300_TLS_DTPOFF 31 /* Offset in module TLS block. */ +#define R_MN10300_TLS_TPOFF 32 /* Offset in static TLS block. */ +#define R_MN10300_SYM_DIFF \ + 33 /* Adjustment for next reloc as needed + by linker relaxation. */ +#define R_MN10300_ALIGN \ + 34 /* Alignment requirement for linker + relaxation. */ +#define R_MN10300_NUM 35 + +/* M32R relocs. */ +#define R_M32R_NONE 0 /* No reloc. */ +#define R_M32R_16 1 /* Direct 16 bit. */ +#define R_M32R_32 2 /* Direct 32 bit. */ +#define R_M32R_24 3 /* Direct 24 bit. */ +#define R_M32R_10_PCREL 4 /* PC relative 10 bit shifted. */ +#define R_M32R_18_PCREL 5 /* PC relative 18 bit shifted. */ +#define R_M32R_26_PCREL 6 /* PC relative 26 bit shifted. */ +#define R_M32R_HI16_ULO 7 /* High 16 bit with unsigned low. */ +#define R_M32R_HI16_SLO 8 /* High 16 bit with signed low. */ +#define R_M32R_LO16 9 /* Low 16 bit. */ +#define R_M32R_SDA16 10 /* 16 bit offset in SDA. */ +#define R_M32R_GNU_VTINHERIT 11 +#define R_M32R_GNU_VTENTRY 12 +/* M32R relocs use SHT_RELA. */ +#define R_M32R_16_RELA 33 /* Direct 16 bit. */ +#define R_M32R_32_RELA 34 /* Direct 32 bit. */ +#define R_M32R_24_RELA 35 /* Direct 24 bit. */ +#define R_M32R_10_PCREL_RELA 36 /* PC relative 10 bit shifted. */ +#define R_M32R_18_PCREL_RELA 37 /* PC relative 18 bit shifted. */ +#define R_M32R_26_PCREL_RELA 38 /* PC relative 26 bit shifted. */ +#define R_M32R_HI16_ULO_RELA 39 /* High 16 bit with unsigned low */ +#define R_M32R_HI16_SLO_RELA 40 /* High 16 bit with signed low */ +#define R_M32R_LO16_RELA 41 /* Low 16 bit */ +#define R_M32R_SDA16_RELA 42 /* 16 bit offset in SDA */ +#define R_M32R_RELA_GNU_VTINHERIT 43 +#define R_M32R_RELA_GNU_VTENTRY 44 +#define R_M32R_REL32 45 /* PC relative 32 bit. */ + +#define R_M32R_GOT24 48 /* 24 bit GOT entry */ +#define R_M32R_26_PLTREL 49 /* 26 bit PC relative to PLT shifted */ +#define R_M32R_COPY 50 /* Copy symbol at runtime */ +#define R_M32R_GLOB_DAT 51 /* Create GOT entry */ +#define R_M32R_JMP_SLOT 52 /* Create PLT entry */ +#define R_M32R_RELATIVE 53 /* Adjust by program base */ +#define R_M32R_GOTOFF 54 /* 24 bit offset to GOT */ +#define R_M32R_GOTPC24 55 /* 24 bit PC relative offset to GOT */ +#define R_M32R_GOT16_HI_ULO \ + 56 /* High 16 bit GOT entry with unsigned + low */ +#define R_M32R_GOT16_HI_SLO \ + 57 /* High 16 bit GOT entry with signed + low */ +#define R_M32R_GOT16_LO 58 /* Low 16 bit GOT entry */ +#define R_M32R_GOTPC_HI_ULO \ + 59 /* High 16 bit PC relative offset to + GOT with unsigned low */ +#define R_M32R_GOTPC_HI_SLO \ + 60 /* High 16 bit PC relative offset to + GOT with signed low */ +#define R_M32R_GOTPC_LO \ + 61 /* Low 16 bit PC relative offset to + GOT */ +#define R_M32R_GOTOFF_HI_ULO \ + 62 /* High 16 bit offset to GOT + with unsigned low */ +#define R_M32R_GOTOFF_HI_SLO \ + 63 /* High 16 bit offset to GOT + with signed low */ +#define R_M32R_GOTOFF_LO 64 /* Low 16 bit offset to GOT */ +#define R_M32R_NUM 256 /* Keep this the last entry. */ + +/* MicroBlaze relocations */ +#define R_MICROBLAZE_NONE 0 /* No reloc. */ +#define R_MICROBLAZE_32 1 /* Direct 32 bit. */ +#define R_MICROBLAZE_32_PCREL 2 /* PC relative 32 bit. */ +#define R_MICROBLAZE_64_PCREL 3 /* PC relative 64 bit. */ +#define R_MICROBLAZE_32_PCREL_LO 4 /* Low 16 bits of PCREL32. */ +#define R_MICROBLAZE_64 5 /* Direct 64 bit. */ +#define R_MICROBLAZE_32_LO 6 /* Low 16 bit. */ +#define R_MICROBLAZE_SRO32 7 /* Read-only small data area. */ +#define R_MICROBLAZE_SRW32 8 /* Read-write small data area. */ +#define R_MICROBLAZE_64_NONE 9 /* No reloc. */ +#define R_MICROBLAZE_32_SYM_OP_SYM 10 /* Symbol Op Symbol relocation. */ +#define R_MICROBLAZE_GNU_VTINHERIT 11 /* GNU C++ vtable hierarchy. */ +#define R_MICROBLAZE_GNU_VTENTRY 12 /* GNU C++ vtable member usage. */ +#define R_MICROBLAZE_GOTPC_64 13 /* PC-relative GOT offset. */ +#define R_MICROBLAZE_GOT_64 14 /* GOT entry offset. */ +#define R_MICROBLAZE_PLT_64 15 /* PLT offset (PC-relative). */ +#define R_MICROBLAZE_REL 16 /* Adjust by program base. */ +#define R_MICROBLAZE_JUMP_SLOT 17 /* Create PLT entry. */ +#define R_MICROBLAZE_GLOB_DAT 18 /* Create GOT entry. */ +#define R_MICROBLAZE_GOTOFF_64 19 /* 64 bit offset to GOT. */ +#define R_MICROBLAZE_GOTOFF_32 20 /* 32 bit offset to GOT. */ +#define R_MICROBLAZE_COPY 21 /* Runtime copy. */ +#define R_MICROBLAZE_TLS 22 /* TLS Reloc. */ +#define R_MICROBLAZE_TLSGD 23 /* TLS General Dynamic. */ +#define R_MICROBLAZE_TLSLD 24 /* TLS Local Dynamic. */ +#define R_MICROBLAZE_TLSDTPMOD32 25 /* TLS Module ID. */ +#define R_MICROBLAZE_TLSDTPREL32 26 /* TLS Offset Within TLS Block. */ +#define R_MICROBLAZE_TLSDTPREL64 27 /* TLS Offset Within TLS Block. */ +#define R_MICROBLAZE_TLSGOTTPREL32 28 /* TLS Offset From Thread Pointer. */ +#define R_MICROBLAZE_TLSTPREL32 29 /* TLS Offset From Thread Pointer. */ + +/* Legal values for d_tag (dynamic entry type). */ +#define DT_NIOS2_GP 0x70000002 /* Address of _gp. */ + +/* Nios II relocations. */ +#define R_NIOS2_NONE 0 /* No reloc. */ +#define R_NIOS2_S16 1 /* Direct signed 16 bit. */ +#define R_NIOS2_U16 2 /* Direct unsigned 16 bit. */ +#define R_NIOS2_PCREL16 3 /* PC relative 16 bit. */ +#define R_NIOS2_CALL26 4 /* Direct call. */ +#define R_NIOS2_IMM5 5 /* 5 bit constant expression. */ +#define R_NIOS2_CACHE_OPX 6 /* 5 bit expression, shift 22. */ +#define R_NIOS2_IMM6 7 /* 6 bit constant expression. */ +#define R_NIOS2_IMM8 8 /* 8 bit constant expression. */ +#define R_NIOS2_HI16 9 /* High 16 bit. */ +#define R_NIOS2_LO16 10 /* Low 16 bit. */ +#define R_NIOS2_HIADJ16 11 /* High 16 bit, adjusted. */ +#define R_NIOS2_BFD_RELOC_32 12 /* 32 bit symbol value + addend. */ +#define R_NIOS2_BFD_RELOC_16 13 /* 16 bit symbol value + addend. */ +#define R_NIOS2_BFD_RELOC_8 14 /* 8 bit symbol value + addend. */ +#define R_NIOS2_GPREL 15 /* 16 bit GP pointer offset. */ +#define R_NIOS2_GNU_VTINHERIT 16 /* GNU C++ vtable hierarchy. */ +#define R_NIOS2_GNU_VTENTRY 17 /* GNU C++ vtable member usage. */ +#define R_NIOS2_UJMP 18 /* Unconditional branch. */ +#define R_NIOS2_CJMP 19 /* Conditional branch. */ +#define R_NIOS2_CALLR 20 /* Indirect call through register. */ +#define R_NIOS2_ALIGN \ + 21 /* Alignment requirement for + linker relaxation. */ +#define R_NIOS2_GOT16 22 /* 16 bit GOT entry. */ +#define R_NIOS2_CALL16 23 /* 16 bit GOT entry for function. */ +#define R_NIOS2_GOTOFF_LO 24 /* %lo of offset to GOT pointer. */ +#define R_NIOS2_GOTOFF_HA 25 /* %hiadj of offset to GOT pointer. */ +#define R_NIOS2_PCREL_LO 26 /* %lo of PC relative offset. */ +#define R_NIOS2_PCREL_HA 27 /* %hiadj of PC relative offset. */ +#define R_NIOS2_TLS_GD16 28 /* 16 bit GOT offset for TLS GD. */ +#define R_NIOS2_TLS_LDM16 29 /* 16 bit GOT offset for TLS LDM. */ +#define R_NIOS2_TLS_LDO16 30 /* 16 bit module relative offset. */ +#define R_NIOS2_TLS_IE16 31 /* 16 bit GOT offset for TLS IE. */ +#define R_NIOS2_TLS_LE16 32 /* 16 bit LE TP-relative offset. */ +#define R_NIOS2_TLS_DTPMOD 33 /* Module number. */ +#define R_NIOS2_TLS_DTPREL 34 /* Module-relative offset. */ +#define R_NIOS2_TLS_TPREL 35 /* TP-relative offset. */ +#define R_NIOS2_COPY 36 /* Copy symbol at runtime. */ +#define R_NIOS2_GLOB_DAT 37 /* Create GOT entry. */ +#define R_NIOS2_JUMP_SLOT 38 /* Create PLT entry. */ +#define R_NIOS2_RELATIVE 39 /* Adjust by program base. */ +#define R_NIOS2_GOTOFF 40 /* 16 bit offset to GOT pointer. */ +#define R_NIOS2_CALL26_NOAT 41 /* Direct call in .noat section. */ +#define R_NIOS2_GOT_LO 42 /* %lo() of GOT entry. */ +#define R_NIOS2_GOT_HA 43 /* %hiadj() of GOT entry. */ +#define R_NIOS2_CALL_LO 44 /* %lo() of function GOT entry. */ +#define R_NIOS2_CALL_HA 45 /* %hiadj() of function GOT entry. */ + +/* TILEPro relocations. */ +#define R_TILEPRO_NONE 0 /* No reloc */ +#define R_TILEPRO_32 1 /* Direct 32 bit */ +#define R_TILEPRO_16 2 /* Direct 16 bit */ +#define R_TILEPRO_8 3 /* Direct 8 bit */ +#define R_TILEPRO_32_PCREL 4 /* PC relative 32 bit */ +#define R_TILEPRO_16_PCREL 5 /* PC relative 16 bit */ +#define R_TILEPRO_8_PCREL 6 /* PC relative 8 bit */ +#define R_TILEPRO_LO16 7 /* Low 16 bit */ +#define R_TILEPRO_HI16 8 /* High 16 bit */ +#define R_TILEPRO_HA16 9 /* High 16 bit, adjusted */ +#define R_TILEPRO_COPY 10 /* Copy relocation */ +#define R_TILEPRO_GLOB_DAT 11 /* Create GOT entry */ +#define R_TILEPRO_JMP_SLOT 12 /* Create PLT entry */ +#define R_TILEPRO_RELATIVE 13 /* Adjust by program base */ +#define R_TILEPRO_BROFF_X1 14 /* X1 pipe branch offset */ +#define R_TILEPRO_JOFFLONG_X1 15 /* X1 pipe jump offset */ +#define R_TILEPRO_JOFFLONG_X1_PLT 16 /* X1 pipe jump offset to PLT */ +#define R_TILEPRO_IMM8_X0 17 /* X0 pipe 8-bit */ +#define R_TILEPRO_IMM8_Y0 18 /* Y0 pipe 8-bit */ +#define R_TILEPRO_IMM8_X1 19 /* X1 pipe 8-bit */ +#define R_TILEPRO_IMM8_Y1 20 /* Y1 pipe 8-bit */ +#define R_TILEPRO_MT_IMM15_X1 21 /* X1 pipe mtspr */ +#define R_TILEPRO_MF_IMM15_X1 22 /* X1 pipe mfspr */ +#define R_TILEPRO_IMM16_X0 23 /* X0 pipe 16-bit */ +#define R_TILEPRO_IMM16_X1 24 /* X1 pipe 16-bit */ +#define R_TILEPRO_IMM16_X0_LO 25 /* X0 pipe low 16-bit */ +#define R_TILEPRO_IMM16_X1_LO 26 /* X1 pipe low 16-bit */ +#define R_TILEPRO_IMM16_X0_HI 27 /* X0 pipe high 16-bit */ +#define R_TILEPRO_IMM16_X1_HI 28 /* X1 pipe high 16-bit */ +#define R_TILEPRO_IMM16_X0_HA 29 /* X0 pipe high 16-bit, adjusted */ +#define R_TILEPRO_IMM16_X1_HA 30 /* X1 pipe high 16-bit, adjusted */ +#define R_TILEPRO_IMM16_X0_PCREL 31 /* X0 pipe PC relative 16 bit */ +#define R_TILEPRO_IMM16_X1_PCREL 32 /* X1 pipe PC relative 16 bit */ +#define R_TILEPRO_IMM16_X0_LO_PCREL 33 /* X0 pipe PC relative low 16 bit */ +#define R_TILEPRO_IMM16_X1_LO_PCREL 34 /* X1 pipe PC relative low 16 bit */ +#define R_TILEPRO_IMM16_X0_HI_PCREL 35 /* X0 pipe PC relative high 16 bit */ +#define R_TILEPRO_IMM16_X1_HI_PCREL 36 /* X1 pipe PC relative high 16 bit */ +#define R_TILEPRO_IMM16_X0_HA_PCREL 37 /* X0 pipe PC relative ha() 16 bit */ +#define R_TILEPRO_IMM16_X1_HA_PCREL 38 /* X1 pipe PC relative ha() 16 bit */ +#define R_TILEPRO_IMM16_X0_GOT 39 /* X0 pipe 16-bit GOT offset */ +#define R_TILEPRO_IMM16_X1_GOT 40 /* X1 pipe 16-bit GOT offset */ +#define R_TILEPRO_IMM16_X0_GOT_LO 41 /* X0 pipe low 16-bit GOT offset */ +#define R_TILEPRO_IMM16_X1_GOT_LO 42 /* X1 pipe low 16-bit GOT offset */ +#define R_TILEPRO_IMM16_X0_GOT_HI 43 /* X0 pipe high 16-bit GOT offset */ +#define R_TILEPRO_IMM16_X1_GOT_HI 44 /* X1 pipe high 16-bit GOT offset */ +#define R_TILEPRO_IMM16_X0_GOT_HA 45 /* X0 pipe ha() 16-bit GOT offset */ +#define R_TILEPRO_IMM16_X1_GOT_HA 46 /* X1 pipe ha() 16-bit GOT offset */ +#define R_TILEPRO_MMSTART_X0 47 /* X0 pipe mm "start" */ +#define R_TILEPRO_MMEND_X0 48 /* X0 pipe mm "end" */ +#define R_TILEPRO_MMSTART_X1 49 /* X1 pipe mm "start" */ +#define R_TILEPRO_MMEND_X1 50 /* X1 pipe mm "end" */ +#define R_TILEPRO_SHAMT_X0 51 /* X0 pipe shift amount */ +#define R_TILEPRO_SHAMT_X1 52 /* X1 pipe shift amount */ +#define R_TILEPRO_SHAMT_Y0 53 /* Y0 pipe shift amount */ +#define R_TILEPRO_SHAMT_Y1 54 /* Y1 pipe shift amount */ +#define R_TILEPRO_DEST_IMM8_X1 55 /* X1 pipe destination 8-bit */ +/* Relocs 56-59 are currently not defined. */ +#define R_TILEPRO_TLS_GD_CALL 60 /* "jal" for TLS GD */ +#define R_TILEPRO_IMM8_X0_TLS_GD_ADD 61 /* X0 pipe "addi" for TLS GD */ +#define R_TILEPRO_IMM8_X1_TLS_GD_ADD 62 /* X1 pipe "addi" for TLS GD */ +#define R_TILEPRO_IMM8_Y0_TLS_GD_ADD 63 /* Y0 pipe "addi" for TLS GD */ +#define R_TILEPRO_IMM8_Y1_TLS_GD_ADD 64 /* Y1 pipe "addi" for TLS GD */ +#define R_TILEPRO_TLS_IE_LOAD 65 /* "lw_tls" for TLS IE */ +#define R_TILEPRO_IMM16_X0_TLS_GD 66 /* X0 pipe 16-bit TLS GD offset */ +#define R_TILEPRO_IMM16_X1_TLS_GD 67 /* X1 pipe 16-bit TLS GD offset */ +#define R_TILEPRO_IMM16_X0_TLS_GD_LO 68 /* X0 pipe low 16-bit TLS GD offset */ +#define R_TILEPRO_IMM16_X1_TLS_GD_LO 69 /* X1 pipe low 16-bit TLS GD offset */ +#define R_TILEPRO_IMM16_X0_TLS_GD_HI 70 /* X0 pipe high 16-bit TLS GD offset */ +#define R_TILEPRO_IMM16_X1_TLS_GD_HI 71 /* X1 pipe high 16-bit TLS GD offset */ +#define R_TILEPRO_IMM16_X0_TLS_GD_HA 72 /* X0 pipe ha() 16-bit TLS GD offset */ +#define R_TILEPRO_IMM16_X1_TLS_GD_HA 73 /* X1 pipe ha() 16-bit TLS GD offset */ +#define R_TILEPRO_IMM16_X0_TLS_IE 74 /* X0 pipe 16-bit TLS IE offset */ +#define R_TILEPRO_IMM16_X1_TLS_IE 75 /* X1 pipe 16-bit TLS IE offset */ +#define R_TILEPRO_IMM16_X0_TLS_IE_LO 76 /* X0 pipe low 16-bit TLS IE offset */ +#define R_TILEPRO_IMM16_X1_TLS_IE_LO 77 /* X1 pipe low 16-bit TLS IE offset */ +#define R_TILEPRO_IMM16_X0_TLS_IE_HI 78 /* X0 pipe high 16-bit TLS IE offset */ +#define R_TILEPRO_IMM16_X1_TLS_IE_HI 79 /* X1 pipe high 16-bit TLS IE offset */ +#define R_TILEPRO_IMM16_X0_TLS_IE_HA 80 /* X0 pipe ha() 16-bit TLS IE offset */ +#define R_TILEPRO_IMM16_X1_TLS_IE_HA 81 /* X1 pipe ha() 16-bit TLS IE offset */ +#define R_TILEPRO_TLS_DTPMOD32 82 /* ID of module containing symbol */ +#define R_TILEPRO_TLS_DTPOFF32 83 /* Offset in TLS block */ +#define R_TILEPRO_TLS_TPOFF32 84 /* Offset in static TLS block */ +#define R_TILEPRO_IMM16_X0_TLS_LE 85 /* X0 pipe 16-bit TLS LE offset */ +#define R_TILEPRO_IMM16_X1_TLS_LE 86 /* X1 pipe 16-bit TLS LE offset */ +#define R_TILEPRO_IMM16_X0_TLS_LE_LO 87 /* X0 pipe low 16-bit TLS LE offset */ +#define R_TILEPRO_IMM16_X1_TLS_LE_LO 88 /* X1 pipe low 16-bit TLS LE offset */ +#define R_TILEPRO_IMM16_X0_TLS_LE_HI 89 /* X0 pipe high 16-bit TLS LE offset */ +#define R_TILEPRO_IMM16_X1_TLS_LE_HI 90 /* X1 pipe high 16-bit TLS LE offset */ +#define R_TILEPRO_IMM16_X0_TLS_LE_HA 91 /* X0 pipe ha() 16-bit TLS LE offset */ +#define R_TILEPRO_IMM16_X1_TLS_LE_HA 92 /* X1 pipe ha() 16-bit TLS LE offset */ + +#define R_TILEPRO_GNU_VTINHERIT 128 /* GNU C++ vtable hierarchy */ +#define R_TILEPRO_GNU_VTENTRY 129 /* GNU C++ vtable member usage */ + +#define R_TILEPRO_NUM 130 + +/* TILE-Gx relocations. */ +#define R_TILEGX_NONE 0 /* No reloc */ +#define R_TILEGX_64 1 /* Direct 64 bit */ +#define R_TILEGX_32 2 /* Direct 32 bit */ +#define R_TILEGX_16 3 /* Direct 16 bit */ +#define R_TILEGX_8 4 /* Direct 8 bit */ +#define R_TILEGX_64_PCREL 5 /* PC relative 64 bit */ +#define R_TILEGX_32_PCREL 6 /* PC relative 32 bit */ +#define R_TILEGX_16_PCREL 7 /* PC relative 16 bit */ +#define R_TILEGX_8_PCREL 8 /* PC relative 8 bit */ +#define R_TILEGX_HW0 9 /* hword 0 16-bit */ +#define R_TILEGX_HW1 10 /* hword 1 16-bit */ +#define R_TILEGX_HW2 11 /* hword 2 16-bit */ +#define R_TILEGX_HW3 12 /* hword 3 16-bit */ +#define R_TILEGX_HW0_LAST 13 /* last hword 0 16-bit */ +#define R_TILEGX_HW1_LAST 14 /* last hword 1 16-bit */ +#define R_TILEGX_HW2_LAST 15 /* last hword 2 16-bit */ +#define R_TILEGX_COPY 16 /* Copy relocation */ +#define R_TILEGX_GLOB_DAT 17 /* Create GOT entry */ +#define R_TILEGX_JMP_SLOT 18 /* Create PLT entry */ +#define R_TILEGX_RELATIVE 19 /* Adjust by program base */ +#define R_TILEGX_BROFF_X1 20 /* X1 pipe branch offset */ +#define R_TILEGX_JUMPOFF_X1 21 /* X1 pipe jump offset */ +#define R_TILEGX_JUMPOFF_X1_PLT 22 /* X1 pipe jump offset to PLT */ +#define R_TILEGX_IMM8_X0 23 /* X0 pipe 8-bit */ +#define R_TILEGX_IMM8_Y0 24 /* Y0 pipe 8-bit */ +#define R_TILEGX_IMM8_X1 25 /* X1 pipe 8-bit */ +#define R_TILEGX_IMM8_Y1 26 /* Y1 pipe 8-bit */ +#define R_TILEGX_DEST_IMM8_X1 27 /* X1 pipe destination 8-bit */ +#define R_TILEGX_MT_IMM14_X1 28 /* X1 pipe mtspr */ +#define R_TILEGX_MF_IMM14_X1 29 /* X1 pipe mfspr */ +#define R_TILEGX_MMSTART_X0 30 /* X0 pipe mm "start" */ +#define R_TILEGX_MMEND_X0 31 /* X0 pipe mm "end" */ +#define R_TILEGX_SHAMT_X0 32 /* X0 pipe shift amount */ +#define R_TILEGX_SHAMT_X1 33 /* X1 pipe shift amount */ +#define R_TILEGX_SHAMT_Y0 34 /* Y0 pipe shift amount */ +#define R_TILEGX_SHAMT_Y1 35 /* Y1 pipe shift amount */ +#define R_TILEGX_IMM16_X0_HW0 36 /* X0 pipe hword 0 */ +#define R_TILEGX_IMM16_X1_HW0 37 /* X1 pipe hword 0 */ +#define R_TILEGX_IMM16_X0_HW1 38 /* X0 pipe hword 1 */ +#define R_TILEGX_IMM16_X1_HW1 39 /* X1 pipe hword 1 */ +#define R_TILEGX_IMM16_X0_HW2 40 /* X0 pipe hword 2 */ +#define R_TILEGX_IMM16_X1_HW2 41 /* X1 pipe hword 2 */ +#define R_TILEGX_IMM16_X0_HW3 42 /* X0 pipe hword 3 */ +#define R_TILEGX_IMM16_X1_HW3 43 /* X1 pipe hword 3 */ +#define R_TILEGX_IMM16_X0_HW0_LAST 44 /* X0 pipe last hword 0 */ +#define R_TILEGX_IMM16_X1_HW0_LAST 45 /* X1 pipe last hword 0 */ +#define R_TILEGX_IMM16_X0_HW1_LAST 46 /* X0 pipe last hword 1 */ +#define R_TILEGX_IMM16_X1_HW1_LAST 47 /* X1 pipe last hword 1 */ +#define R_TILEGX_IMM16_X0_HW2_LAST 48 /* X0 pipe last hword 2 */ +#define R_TILEGX_IMM16_X1_HW2_LAST 49 /* X1 pipe last hword 2 */ +#define R_TILEGX_IMM16_X0_HW0_PCREL 50 /* X0 pipe PC relative hword 0 */ +#define R_TILEGX_IMM16_X1_HW0_PCREL 51 /* X1 pipe PC relative hword 0 */ +#define R_TILEGX_IMM16_X0_HW1_PCREL 52 /* X0 pipe PC relative hword 1 */ +#define R_TILEGX_IMM16_X1_HW1_PCREL 53 /* X1 pipe PC relative hword 1 */ +#define R_TILEGX_IMM16_X0_HW2_PCREL 54 /* X0 pipe PC relative hword 2 */ +#define R_TILEGX_IMM16_X1_HW2_PCREL 55 /* X1 pipe PC relative hword 2 */ +#define R_TILEGX_IMM16_X0_HW3_PCREL 56 /* X0 pipe PC relative hword 3 */ +#define R_TILEGX_IMM16_X1_HW3_PCREL 57 /* X1 pipe PC relative hword 3 */ +#define R_TILEGX_IMM16_X0_HW0_LAST_PCREL 58 /* X0 pipe PC-rel last hword 0 */ +#define R_TILEGX_IMM16_X1_HW0_LAST_PCREL 59 /* X1 pipe PC-rel last hword 0 */ +#define R_TILEGX_IMM16_X0_HW1_LAST_PCREL 60 /* X0 pipe PC-rel last hword 1 */ +#define R_TILEGX_IMM16_X1_HW1_LAST_PCREL 61 /* X1 pipe PC-rel last hword 1 */ +#define R_TILEGX_IMM16_X0_HW2_LAST_PCREL 62 /* X0 pipe PC-rel last hword 2 */ +#define R_TILEGX_IMM16_X1_HW2_LAST_PCREL 63 /* X1 pipe PC-rel last hword 2 */ +#define R_TILEGX_IMM16_X0_HW0_GOT 64 /* X0 pipe hword 0 GOT offset */ +#define R_TILEGX_IMM16_X1_HW0_GOT 65 /* X1 pipe hword 0 GOT offset */ +#define R_TILEGX_IMM16_X0_HW0_PLT_PCREL 66 /* X0 pipe PC-rel PLT hword 0 */ +#define R_TILEGX_IMM16_X1_HW0_PLT_PCREL 67 /* X1 pipe PC-rel PLT hword 0 */ +#define R_TILEGX_IMM16_X0_HW1_PLT_PCREL 68 /* X0 pipe PC-rel PLT hword 1 */ +#define R_TILEGX_IMM16_X1_HW1_PLT_PCREL 69 /* X1 pipe PC-rel PLT hword 1 */ +#define R_TILEGX_IMM16_X0_HW2_PLT_PCREL 70 /* X0 pipe PC-rel PLT hword 2 */ +#define R_TILEGX_IMM16_X1_HW2_PLT_PCREL 71 /* X1 pipe PC-rel PLT hword 2 */ +#define R_TILEGX_IMM16_X0_HW0_LAST_GOT 72 /* X0 pipe last hword 0 GOT offset */ +#define R_TILEGX_IMM16_X1_HW0_LAST_GOT 73 /* X1 pipe last hword 0 GOT offset */ +#define R_TILEGX_IMM16_X0_HW1_LAST_GOT 74 /* X0 pipe last hword 1 GOT offset */ +#define R_TILEGX_IMM16_X1_HW1_LAST_GOT 75 /* X1 pipe last hword 1 GOT offset */ +#define R_TILEGX_IMM16_X0_HW3_PLT_PCREL 76 /* X0 pipe PC-rel PLT hword 3 */ +#define R_TILEGX_IMM16_X1_HW3_PLT_PCREL 77 /* X1 pipe PC-rel PLT hword 3 */ +#define R_TILEGX_IMM16_X0_HW0_TLS_GD 78 /* X0 pipe hword 0 TLS GD offset */ +#define R_TILEGX_IMM16_X1_HW0_TLS_GD 79 /* X1 pipe hword 0 TLS GD offset */ +#define R_TILEGX_IMM16_X0_HW0_TLS_LE 80 /* X0 pipe hword 0 TLS LE offset */ +#define R_TILEGX_IMM16_X1_HW0_TLS_LE 81 /* X1 pipe hword 0 TLS LE offset */ +#define R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE 82 /* X0 pipe last hword 0 LE off */ +#define R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE 83 /* X1 pipe last hword 0 LE off */ +#define R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE 84 /* X0 pipe last hword 1 LE off */ +#define R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE 85 /* X1 pipe last hword 1 LE off */ +#define R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD 86 /* X0 pipe last hword 0 GD off */ +#define R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD 87 /* X1 pipe last hword 0 GD off */ +#define R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD 88 /* X0 pipe last hword 1 GD off */ +#define R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD 89 /* X1 pipe last hword 1 GD off */ +/* Relocs 90-91 are currently not defined. */ +#define R_TILEGX_IMM16_X0_HW0_TLS_IE 92 /* X0 pipe hword 0 TLS IE offset */ +#define R_TILEGX_IMM16_X1_HW0_TLS_IE 93 /* X1 pipe hword 0 TLS IE offset */ +#define R_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL \ + 94 /* X0 pipe PC-rel PLT last hword 0 */ +#define R_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL \ + 95 /* X1 pipe PC-rel PLT last hword 0 */ +#define R_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL \ + 96 /* X0 pipe PC-rel PLT last hword 1 */ +#define R_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL \ + 97 /* X1 pipe PC-rel PLT last hword 1 */ +#define R_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL \ + 98 /* X0 pipe PC-rel PLT last hword 2 */ +#define R_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL \ + 99 /* X1 pipe PC-rel PLT last hword 2 */ +#define R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE 100 /* X0 pipe last hword 0 IE off */ +#define R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE 101 /* X1 pipe last hword 0 IE off */ +#define R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE 102 /* X0 pipe last hword 1 IE off */ +#define R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE 103 /* X1 pipe last hword 1 IE off */ +/* Relocs 104-105 are currently not defined. */ +#define R_TILEGX_TLS_DTPMOD64 106 /* 64-bit ID of symbol's module */ +#define R_TILEGX_TLS_DTPOFF64 107 /* 64-bit offset in TLS block */ +#define R_TILEGX_TLS_TPOFF64 108 /* 64-bit offset in static TLS block */ +#define R_TILEGX_TLS_DTPMOD32 109 /* 32-bit ID of symbol's module */ +#define R_TILEGX_TLS_DTPOFF32 110 /* 32-bit offset in TLS block */ +#define R_TILEGX_TLS_TPOFF32 111 /* 32-bit offset in static TLS block */ +#define R_TILEGX_TLS_GD_CALL 112 /* "jal" for TLS GD */ +#define R_TILEGX_IMM8_X0_TLS_GD_ADD 113 /* X0 pipe "addi" for TLS GD */ +#define R_TILEGX_IMM8_X1_TLS_GD_ADD 114 /* X1 pipe "addi" for TLS GD */ +#define R_TILEGX_IMM8_Y0_TLS_GD_ADD 115 /* Y0 pipe "addi" for TLS GD */ +#define R_TILEGX_IMM8_Y1_TLS_GD_ADD 116 /* Y1 pipe "addi" for TLS GD */ +#define R_TILEGX_TLS_IE_LOAD 117 /* "ld_tls" for TLS IE */ +#define R_TILEGX_IMM8_X0_TLS_ADD 118 /* X0 pipe "addi" for TLS GD/IE */ +#define R_TILEGX_IMM8_X1_TLS_ADD 119 /* X1 pipe "addi" for TLS GD/IE */ +#define R_TILEGX_IMM8_Y0_TLS_ADD 120 /* Y0 pipe "addi" for TLS GD/IE */ +#define R_TILEGX_IMM8_Y1_TLS_ADD 121 /* Y1 pipe "addi" for TLS GD/IE */ + +#define R_TILEGX_GNU_VTINHERIT 128 /* GNU C++ vtable hierarchy */ +#define R_TILEGX_GNU_VTENTRY 129 /* GNU C++ vtable member usage */ + +#define R_TILEGX_NUM 130 + +/* RISC-V ELF Flags */ +#define EF_RISCV_RVC 0x0001 +#define EF_RISCV_FLOAT_ABI 0x0006 +#define EF_RISCV_FLOAT_ABI_SOFT 0x0000 +#define EF_RISCV_FLOAT_ABI_SINGLE 0x0002 +#define EF_RISCV_FLOAT_ABI_DOUBLE 0x0004 +#define EF_RISCV_FLOAT_ABI_QUAD 0x0006 +#define EF_RISCV_RVE 0x0008 +#define EF_RISCV_TSO 0x0010 + +/* RISC-V relocations. */ +#define R_RISCV_NONE 0 +#define R_RISCV_32 1 +#define R_RISCV_64 2 +#define R_RISCV_RELATIVE 3 +#define R_RISCV_COPY 4 +#define R_RISCV_JUMP_SLOT 5 +#define R_RISCV_TLS_DTPMOD32 6 +#define R_RISCV_TLS_DTPMOD64 7 +#define R_RISCV_TLS_DTPREL32 8 +#define R_RISCV_TLS_DTPREL64 9 +#define R_RISCV_TLS_TPREL32 10 +#define R_RISCV_TLS_TPREL64 11 +#define R_RISCV_BRANCH 16 +#define R_RISCV_JAL 17 +#define R_RISCV_CALL 18 +#define R_RISCV_CALL_PLT 19 +#define R_RISCV_GOT_HI20 20 +#define R_RISCV_TLS_GOT_HI20 21 +#define R_RISCV_TLS_GD_HI20 22 +#define R_RISCV_PCREL_HI20 23 +#define R_RISCV_PCREL_LO12_I 24 +#define R_RISCV_PCREL_LO12_S 25 +#define R_RISCV_HI20 26 +#define R_RISCV_LO12_I 27 +#define R_RISCV_LO12_S 28 +#define R_RISCV_TPREL_HI20 29 +#define R_RISCV_TPREL_LO12_I 30 +#define R_RISCV_TPREL_LO12_S 31 +#define R_RISCV_TPREL_ADD 32 +#define R_RISCV_ADD8 33 +#define R_RISCV_ADD16 34 +#define R_RISCV_ADD32 35 +#define R_RISCV_ADD64 36 +#define R_RISCV_SUB8 37 +#define R_RISCV_SUB16 38 +#define R_RISCV_SUB32 39 +#define R_RISCV_SUB64 40 +#define R_RISCV_GNU_VTINHERIT 41 +#define R_RISCV_GNU_VTENTRY 42 +#define R_RISCV_ALIGN 43 +#define R_RISCV_RVC_BRANCH 44 +#define R_RISCV_RVC_JUMP 45 +#define R_RISCV_RVC_LUI 46 +#define R_RISCV_GPREL_I 47 +#define R_RISCV_GPREL_S 48 +#define R_RISCV_TPREL_I 49 +#define R_RISCV_TPREL_S 50 +#define R_RISCV_RELAX 51 +#define R_RISCV_SUB6 52 +#define R_RISCV_SET6 53 +#define R_RISCV_SET8 54 +#define R_RISCV_SET16 55 +#define R_RISCV_SET32 56 +#define R_RISCV_32_PCREL 57 +#define R_RISCV_IRELATIVE 58 +#define R_RISCV_PLT32 59 +#define R_RISCV_SET_ULEB128 60 +#define R_RISCV_SUB_ULEB128 61 + +#define R_RISCV_NUM 62 + +/* RISC-V specific values for the st_other field. */ +#define STO_RISCV_VARIANT_CC \ + 0x80 /* Function uses variant calling + convention */ + +/* RISC-V specific values for the sh_type field. */ +#define SHT_RISCV_ATTRIBUTES (SHT_LOPROC + 3) + +/* RISC-V specific values for the p_type field. */ +#define PT_RISCV_ATTRIBUTES (PT_LOPROC + 3) + +/* RISC-V specific values for the d_tag field. */ +#define DT_RISCV_VARIANT_CC (DT_LOPROC + 1) + +/* BPF specific declarations. */ + +#define R_BPF_NONE 0 /* No reloc */ +#define R_BPF_64_64 1 +#define R_BPF_64_32 10 + +/* Imagination Meta specific relocations. */ + +#define R_METAG_HIADDR16 0 +#define R_METAG_LOADDR16 1 +#define R_METAG_ADDR32 2 /* 32bit absolute address */ +#define R_METAG_NONE 3 /* No reloc */ +#define R_METAG_RELBRANCH 4 +#define R_METAG_GETSETOFF 5 + +/* Backward compatibility */ +#define R_METAG_REG32OP1 6 +#define R_METAG_REG32OP2 7 +#define R_METAG_REG32OP3 8 +#define R_METAG_REG16OP1 9 +#define R_METAG_REG16OP2 10 +#define R_METAG_REG16OP3 11 +#define R_METAG_REG32OP4 12 + +#define R_METAG_HIOG 13 +#define R_METAG_LOOG 14 + +#define R_METAG_REL8 15 +#define R_METAG_REL16 16 + +/* GNU */ +#define R_METAG_GNU_VTINHERIT 30 +#define R_METAG_GNU_VTENTRY 31 + +/* PIC relocations */ +#define R_METAG_HI16_GOTOFF 32 +#define R_METAG_LO16_GOTOFF 33 +#define R_METAG_GETSET_GOTOFF 34 +#define R_METAG_GETSET_GOT 35 +#define R_METAG_HI16_GOTPC 36 +#define R_METAG_LO16_GOTPC 37 +#define R_METAG_HI16_PLT 38 +#define R_METAG_LO16_PLT 39 +#define R_METAG_RELBRANCH_PLT 40 +#define R_METAG_GOTOFF 41 +#define R_METAG_PLT 42 +#define R_METAG_COPY 43 +#define R_METAG_JMP_SLOT 44 +#define R_METAG_RELATIVE 45 +#define R_METAG_GLOB_DAT 46 + +/* TLS relocations */ +#define R_METAG_TLS_GD 47 +#define R_METAG_TLS_LDM 48 +#define R_METAG_TLS_LDO_HI16 49 +#define R_METAG_TLS_LDO_LO16 50 +#define R_METAG_TLS_LDO 51 +#define R_METAG_TLS_IE 52 +#define R_METAG_TLS_IENONPIC 53 +#define R_METAG_TLS_IENONPIC_HI16 54 +#define R_METAG_TLS_IENONPIC_LO16 55 +#define R_METAG_TLS_TPOFF 56 +#define R_METAG_TLS_DTPMOD 57 +#define R_METAG_TLS_DTPOFF 58 +#define R_METAG_TLS_LE 59 +#define R_METAG_TLS_LE_HI16 60 +#define R_METAG_TLS_LE_LO16 61 + +/* NDS32 relocations. */ +#define R_NDS32_NONE 0 +#define R_NDS32_32_RELA 20 +#define R_NDS32_COPY 39 +#define R_NDS32_GLOB_DAT 40 +#define R_NDS32_JMP_SLOT 41 +#define R_NDS32_RELATIVE 42 +#define R_NDS32_TLS_TPOFF 102 +#define R_NDS32_TLS_DESC 119 + +/* LoongArch ELF Flags */ +#define EF_LARCH_ABI_MODIFIER_MASK 0x07 +#define EF_LARCH_ABI_SOFT_FLOAT 0x01 +#define EF_LARCH_ABI_SINGLE_FLOAT 0x02 +#define EF_LARCH_ABI_DOUBLE_FLOAT 0x03 +#define EF_LARCH_OBJABI_V1 0x40 + +/* LoongArch specific dynamic relocations */ +#define R_LARCH_NONE 0 +#define R_LARCH_32 1 +#define R_LARCH_64 2 +#define R_LARCH_RELATIVE 3 +#define R_LARCH_COPY 4 +#define R_LARCH_JUMP_SLOT 5 +#define R_LARCH_TLS_DTPMOD32 6 +#define R_LARCH_TLS_DTPMOD64 7 +#define R_LARCH_TLS_DTPREL32 8 +#define R_LARCH_TLS_DTPREL64 9 +#define R_LARCH_TLS_TPREL32 10 +#define R_LARCH_TLS_TPREL64 11 +#define R_LARCH_IRELATIVE 12 +#define R_LARCH_TLS_DESC32 13 +#define R_LARCH_TLS_DESC64 14 + +/* Reserved for future relocs that the dynamic linker must understand. */ + +/* used by the static linker for relocating .text. */ +#define R_LARCH_MARK_LA 20 +#define R_LARCH_MARK_PCREL 21 +#define R_LARCH_SOP_PUSH_PCREL 22 +#define R_LARCH_SOP_PUSH_ABSOLUTE 23 +#define R_LARCH_SOP_PUSH_DUP 24 +#define R_LARCH_SOP_PUSH_GPREL 25 +#define R_LARCH_SOP_PUSH_TLS_TPREL 26 +#define R_LARCH_SOP_PUSH_TLS_GOT 27 +#define R_LARCH_SOP_PUSH_TLS_GD 28 +#define R_LARCH_SOP_PUSH_PLT_PCREL 29 +#define R_LARCH_SOP_ASSERT 30 +#define R_LARCH_SOP_NOT 31 +#define R_LARCH_SOP_SUB 32 +#define R_LARCH_SOP_SL 33 +#define R_LARCH_SOP_SR 34 +#define R_LARCH_SOP_ADD 35 +#define R_LARCH_SOP_AND 36 +#define R_LARCH_SOP_IF_ELSE 37 +#define R_LARCH_SOP_POP_32_S_10_5 38 +#define R_LARCH_SOP_POP_32_U_10_12 39 +#define R_LARCH_SOP_POP_32_S_10_12 40 +#define R_LARCH_SOP_POP_32_S_10_16 41 +#define R_LARCH_SOP_POP_32_S_10_16_S2 42 +#define R_LARCH_SOP_POP_32_S_5_20 43 +#define R_LARCH_SOP_POP_32_S_0_5_10_16_S2 44 +#define R_LARCH_SOP_POP_32_S_0_10_10_16_S2 45 +#define R_LARCH_SOP_POP_32_U 46 + +/* used by the static linker for relocating non .text. */ +#define R_LARCH_ADD8 47 +#define R_LARCH_ADD16 48 +#define R_LARCH_ADD24 49 +#define R_LARCH_ADD32 50 +#define R_LARCH_ADD64 51 +#define R_LARCH_SUB8 52 +#define R_LARCH_SUB16 53 +#define R_LARCH_SUB24 54 +#define R_LARCH_SUB32 55 +#define R_LARCH_SUB64 56 +#define R_LARCH_GNU_VTINHERIT 57 +#define R_LARCH_GNU_VTENTRY 58 + +/* reserved 59-63 */ + +#define R_LARCH_B16 64 +#define R_LARCH_B21 65 +#define R_LARCH_B26 66 +#define R_LARCH_ABS_HI20 67 +#define R_LARCH_ABS_LO12 68 +#define R_LARCH_ABS64_LO20 69 +#define R_LARCH_ABS64_HI12 70 +#define R_LARCH_PCALA_HI20 71 +#define R_LARCH_PCALA_LO12 72 +#define R_LARCH_PCALA64_LO20 73 +#define R_LARCH_PCALA64_HI12 74 +#define R_LARCH_GOT_PC_HI20 75 +#define R_LARCH_GOT_PC_LO12 76 +#define R_LARCH_GOT64_PC_LO20 77 +#define R_LARCH_GOT64_PC_HI12 78 +#define R_LARCH_GOT_HI20 79 +#define R_LARCH_GOT_LO12 80 +#define R_LARCH_GOT64_LO20 81 +#define R_LARCH_GOT64_HI12 82 +#define R_LARCH_TLS_LE_HI20 83 +#define R_LARCH_TLS_LE_LO12 84 +#define R_LARCH_TLS_LE64_LO20 85 +#define R_LARCH_TLS_LE64_HI12 86 +#define R_LARCH_TLS_IE_PC_HI20 87 +#define R_LARCH_TLS_IE_PC_LO12 88 +#define R_LARCH_TLS_IE64_PC_LO20 89 +#define R_LARCH_TLS_IE64_PC_HI12 90 +#define R_LARCH_TLS_IE_HI20 91 +#define R_LARCH_TLS_IE_LO12 92 +#define R_LARCH_TLS_IE64_LO20 93 +#define R_LARCH_TLS_IE64_HI12 94 +#define R_LARCH_TLS_LD_PC_HI20 95 +#define R_LARCH_TLS_LD_HI20 96 +#define R_LARCH_TLS_GD_PC_HI20 97 +#define R_LARCH_TLS_GD_HI20 98 +#define R_LARCH_32_PCREL 99 +#define R_LARCH_RELAX 100 +#define R_LARCH_DELETE 101 +#define R_LARCH_ALIGN 102 +#define R_LARCH_PCREL20_S2 103 +#define R_LARCH_CFA 104 +#define R_LARCH_ADD6 105 +#define R_LARCH_SUB6 106 +#define R_LARCH_ADD_ULEB128 107 +#define R_LARCH_SUB_ULEB128 108 +#define R_LARCH_64_PCREL 109 +#define R_LARCH_CALL36 110 +#define R_LARCH_TLS_DESC_PC_HI20 111 +#define R_LARCH_TLS_DESC_PC_LO12 112 +#define R_LARCH_TLS_DESC64_PC_LO20 113 +#define R_LARCH_TLS_DESC64_PC_HI12 114 +#define R_LARCH_TLS_DESC_HI20 115 +#define R_LARCH_TLS_DESC_LO12 116 +#define R_LARCH_TLS_DESC64_LO20 117 +#define R_LARCH_TLS_DESC64_HI12 118 +#define R_LARCH_TLS_DESC_LD 119 +#define R_LARCH_TLS_DESC_CALL 120 +#define R_LARCH_TLS_LE_HI20_R 121 +#define R_LARCH_TLS_LE_ADD_R 122 +#define R_LARCH_TLS_LE_LO12_R 123 +#define R_LARCH_TLS_LD_PCREL20_S2 124 +#define R_LARCH_TLS_GD_PCREL20_S2 125 +#define R_LARCH_TLS_DESC_PCREL20_S2 126 + +/* ARC specific declarations. */ + +/* Processor specific flags for the Ehdr e_flags field. */ +#define EF_ARC_MACH_MSK 0x000000ff +#define EF_ARC_OSABI_MSK 0x00000f00 +#define EF_ARC_ALL_MSK (EF_ARC_MACH_MSK | EF_ARC_OSABI_MSK) + +/* Processor specific values for the Shdr sh_type field. */ +#define SHT_ARC_ATTRIBUTES (SHT_LOPROC + 1) /* ARC attributes section. */ + +/* ARCompact/ARCv2 specific relocs. */ +#define R_ARC_NONE 0x0 +#define R_ARC_8 0x1 +#define R_ARC_16 0x2 +#define R_ARC_24 0x3 +#define R_ARC_32 0x4 + +#define R_ARC_B22_PCREL 0x6 +#define R_ARC_H30 0x7 +#define R_ARC_N8 0x8 +#define R_ARC_N16 0x9 +#define R_ARC_N24 0xA +#define R_ARC_N32 0xB +#define R_ARC_SDA 0xC +#define R_ARC_SECTOFF 0xD +#define R_ARC_S21H_PCREL 0xE +#define R_ARC_S21W_PCREL 0xF +#define R_ARC_S25H_PCREL 0x10 +#define R_ARC_S25W_PCREL 0x11 +#define R_ARC_SDA32 0x12 +#define R_ARC_SDA_LDST 0x13 +#define R_ARC_SDA_LDST1 0x14 +#define R_ARC_SDA_LDST2 0x15 +#define R_ARC_SDA16_LD 0x16 +#define R_ARC_SDA16_LD1 0x17 +#define R_ARC_SDA16_LD2 0x18 +#define R_ARC_S13_PCREL 0x19 +#define R_ARC_W 0x1A +#define R_ARC_32_ME 0x1B +#define R_ARC_N32_ME 0x1C +#define R_ARC_SECTOFF_ME 0x1D +#define R_ARC_SDA32_ME 0x1E +#define R_ARC_W_ME 0x1F +#define R_ARC_H30_ME 0x20 +#define R_ARC_SECTOFF_U8 0x21 +#define R_ARC_SECTOFF_S9 0x22 +#define R_AC_SECTOFF_U8 0x23 +#define R_AC_SECTOFF_U8_1 0x24 +#define R_AC_SECTOFF_U8_2 0x25 +#define R_AC_SECTOFF_S9 0x26 +#define R_AC_SECTOFF_S9_1 0x27 +#define R_AC_SECTOFF_S9_2 0x28 +#define R_ARC_SECTOFF_ME_1 0x29 +#define R_ARC_SECTOFF_ME_2 0x2A +#define R_ARC_SECTOFF_1 0x2B +#define R_ARC_SECTOFF_2 0x2C +#define R_ARC_SDA_12 0x2D +#define R_ARC_SDA16_ST2 0x30 +#define R_ARC_32_PCREL 0x31 +#define R_ARC_PC32 0x32 +#define R_ARC_GOTPC32 0x33 +#define R_ARC_PLT32 0x34 +#define R_ARC_COPY 0x35 +#define R_ARC_GLOB_DAT 0x36 +#define R_ARC_JMP_SLOT 0x37 +#define R_ARC_RELATIVE 0x38 +#define R_ARC_GOTOFF 0x39 +#define R_ARC_GOTPC 0x3A +#define R_ARC_GOT32 0x3B +#define R_ARC_S21W_PCREL_PLT 0x3C +#define R_ARC_S25H_PCREL_PLT 0x3D + +#define R_ARC_JLI_SECTOFF 0x3F + +#define R_ARC_TLS_DTPMOD 0x42 +#define R_ARC_TLS_DTPOFF 0x43 +#define R_ARC_TLS_TPOFF 0x44 +#define R_ARC_TLS_GD_GOT 0x45 +#define R_ARC_TLS_GD_LD 0x46 +#define R_ARC_TLS_GD_CALL 0x47 +#define R_ARC_TLS_IE_GOT 0x48 +#define R_ARC_TLS_DTPOFF_S9 0x49 +#define R_ARC_TLS_LE_S9 0x4A +#define R_ARC_TLS_LE_32 0x4B +#define R_ARC_S25W_PCREL_PLT 0x4C +#define R_ARC_S21H_PCREL_PLT 0x4D +#define R_ARC_NPS_CMEM16 0x4E + +/* OpenRISC 1000 specific relocs. */ +#define R_OR1K_NONE 0 +#define R_OR1K_32 1 +#define R_OR1K_16 2 +#define R_OR1K_8 3 +#define R_OR1K_LO_16_IN_INSN 4 +#define R_OR1K_HI_16_IN_INSN 5 +#define R_OR1K_INSN_REL_26 6 +#define R_OR1K_GNU_VTENTRY 7 +#define R_OR1K_GNU_VTINHERIT 8 +#define R_OR1K_32_PCREL 9 +#define R_OR1K_16_PCREL 10 +#define R_OR1K_8_PCREL 11 +#define R_OR1K_GOTPC_HI16 12 +#define R_OR1K_GOTPC_LO16 13 +#define R_OR1K_GOT16 14 +#define R_OR1K_PLT26 15 +#define R_OR1K_GOTOFF_HI16 16 +#define R_OR1K_GOTOFF_LO16 17 +#define R_OR1K_COPY 18 +#define R_OR1K_GLOB_DAT 19 +#define R_OR1K_JMP_SLOT 20 +#define R_OR1K_RELATIVE 21 +#define R_OR1K_TLS_GD_HI16 22 +#define R_OR1K_TLS_GD_LO16 23 +#define R_OR1K_TLS_LDM_HI16 24 +#define R_OR1K_TLS_LDM_LO16 25 +#define R_OR1K_TLS_LDO_HI16 26 +#define R_OR1K_TLS_LDO_LO16 27 +#define R_OR1K_TLS_IE_HI16 28 +#define R_OR1K_TLS_IE_LO16 29 +#define R_OR1K_TLS_LE_HI16 30 +#define R_OR1K_TLS_LE_LO16 31 +#define R_OR1K_TLS_TPOFF 32 +#define R_OR1K_TLS_DTPOFF 33 +#define R_OR1K_TLS_DTPMOD 34 + +#endif /* elf.h */ diff --git a/kernel/lib/backtrace.c b/kernel/lib/backtrace.c index fb708b2..485cc0f 100644 --- a/kernel/lib/backtrace.c +++ b/kernel/lib/backtrace.c @@ -1,4 +1,5 @@ #include <lib.h> +#include <comus/mboot.h> struct stackframe { struct stackframe *rbp; @@ -38,9 +39,10 @@ void log_backtrace_ex(void *ip, void *bp) { struct stackframe *frame = bp; kputs("Stack trace:\n"); - kprintf(" %p\n", ip); + kprintf(" %p\t%s\n", ip, mboot_get_elf_sym((uint64_t)ip)); while (frame) { - kprintf(" %p\n", frame->rip); + kprintf(" %p\t%s\n", frame->rip, + mboot_get_elf_sym((uint64_t)frame->rip)); frame = frame->rbp; } } diff --git a/kernel/main.c b/kernel/main.c index 99954d6..7ea47ad 100644 --- a/kernel/main.c +++ b/kernel/main.c @@ -1,4 +1,3 @@ -#include "lib/kio.h" #include <comus/cpu.h> #include <comus/memory.h> #include <comus/mboot.h> diff --git a/kernel/mboot/elf.c b/kernel/mboot/elf.c new file mode 100644 index 0000000..88b61a7 --- /dev/null +++ b/kernel/mboot/elf.c @@ -0,0 +1,77 @@ +#include "lib/kio.h" +#include <lib.h> +#include <elf.h> +#include <comus/mboot.h> + +#include "mboot.h" + +#define MULTIBOOT_TAG_TYPE_ELF_SECTIONS 9 + +struct multiboot_tag_elf_sections { + uint32_t type; + uint32_t size; + uint32_t num; + uint32_t entsize; + uint32_t shndx; + Elf64_Shdr sections[]; +}; + +static struct multiboot_tag_elf_sections *elf = NULL; +static Elf64_Shdr *symtab = NULL; +static Elf64_Shdr *symstrtab = NULL; + +static Elf64_Shdr *mboot_get_elf_sec(uint32_t sh_type) +{ + for (uint32_t i = 0; i < elf->num; i++) { + Elf64_Shdr *ent = &elf->sections[i]; + if (ent->sh_type == sh_type) + return ent; + } + + return NULL; +} + +static int mboot_load_elf(void) +{ + void *tag = locate_mboot_table(MULTIBOOT_TAG_TYPE_ELF_SECTIONS); + if (tag == NULL) + return 1; + + // found elf sections + elf = (struct multiboot_tag_elf_sections *)tag; + + // load symtab + if ((symtab = mboot_get_elf_sec(SHT_SYMTAB)) == NULL) + return 1; + + // load strsymtab + if ((symstrtab = mboot_get_elf_sec(symtab->sh_link)) == NULL) + return 1; + + return 0; +} + +const char *mboot_get_elf_sym(uint64_t addr) +{ + if (symstrtab == NULL) + if (mboot_load_elf()) + return NULL; + + // walk symbol table + Elf64_Sym *syms = (Elf64_Sym *)symtab->sh_addr; + Elf64_Sym *best = NULL; + for (uint32_t i = 0; i < symtab->sh_size / symtab->sh_entsize; i++) { + Elf64_Sym *sym = &syms[i]; + if (sym->st_value < addr) + continue; + if (best == NULL || (best->st_value < sym->st_value)) + best = sym; + } + + if (best != NULL) { + char *buf = (char *)symstrtab->sh_addr; + return &buf[best->st_name]; + } + + return "???"; +} diff --git a/kernel/mboot/mboot.c b/kernel/mboot/mboot.c index e10f33c..949337d 100644 --- a/kernel/mboot/mboot.c +++ b/kernel/mboot/mboot.c @@ -3,7 +3,7 @@ #include "mboot.h" -static volatile void *mboot; +static volatile void *mboot = NULL; void mboot_init(long magic, volatile void *ptr) { @@ -14,9 +14,12 @@ void mboot_init(long magic, volatile void *ptr) void *locate_mboot_table(uint32_t type) { + if (mboot == NULL) + return NULL; + struct multiboot *info = (struct multiboot *)mboot; - const char *mboot_end = ((char *)info) + info->total_size; + const char *mboot_end = ((char *)info) + info->total_size; char *tag_ptr = info->tags; while (tag_ptr < mboot_end) { diff --git a/kernel/mboot/mmap.c b/kernel/mboot/mmap.c index 8959c49..e0963ca 100644 --- a/kernel/mboot/mmap.c +++ b/kernel/mboot/mmap.c @@ -30,11 +30,9 @@ int mboot_get_mmap(struct memory_map *res) int idx = 0; uintptr_t i = (uintptr_t)mmap->entries; - char buf[20]; for (; i < (uintptr_t)mmap->entries + mmap->size; i += mmap->entry_size, idx++) { struct multiboot_mmap_entry *seg = (struct multiboot_mmap_entry *)i; - const char *type = NULL; res->entries[idx].addr = seg->addr; res->entries[idx].len = seg->len; res->entries[idx].type = seg->type; diff --git a/kernel/old/Make.mk b/kernel/old/Make.mk deleted file mode 100644 index ac8928d..0000000 --- a/kernel/old/Make.mk +++ /dev/null @@ -1,76 +0,0 @@ -# -# Makefile fragment for the kernel components of the system. -# -# Makefile fragment for the kernel component of the system. -# -# THIS IS NOT A COMPLETE Makefile - run GNU make in the top-level -# directory, and this will be pulled in automatically. -# - -SUBDIRS += kernel - -################### -# FILES SECTION # -################### - -BOOT_OBJ := $(patsubst %.c, $(BUILDDIR)/%.o, $(BOOT_SRC)) - -KERN_SRC := kernel/startup.S kernel/isrs.S \ - kernel/cio.c kernel/clock.c kernel/kernel.c kernel/kmem.c \ - kernel/list.c kernel/procs.c kernel/sio.c kernel/support.c \ - kernel/syscalls.c kernel/user.c kernel/vm.c kernel/vmtables.c - -KERN_OBJ := $(patsubst %.c, $(BUILDDIR)/%.o, $(KERN_SRC)) -KERN_OBJ := $(patsubst %.S, $(BUILDDIR)/%.o, $(KERN_OBJ)) - -KCFLAGS := -ggdb -KLDFLAGS := -T kernel/kernel.ld -KLIBS := -lkernel -lcommon - -################### -# RULES SECTION # -################### - -kernel: $(BUILDDIR)/kernel/kernel.b - -$(BUILDDIR)/kernel/%.o: kernel/%.c $(BUILDDIR)/.vars.CFLAGS - @mkdir -p $(@D) - $(CC) $(CFLAGS) $(KCFLAGS) -c -o $@ $< - -#$(BUILDDIR)/kernel/%.o: kernel/%.S $(BUILDDIR)/.vars.CFLAGS -# @mkdir -p $(@D) -# $(CPP) $(CPPFLAGS) -o $(@D)/$*.s $< -# $(AS) $(ASFLAGS) $(KCFLAGS) -o $@ $(@D)/$*.s -a=$(@D)/$*.lst -# $(RM) -f $(@D)/$*.s - -$(BUILDDIR)/kernel/%.o: kernel/%.S $(BUILDDIR)/.vars.CFLAGS - @mkdir -p $(@D) - $(CC) $(CFLAGS) $(KCFLAGS) -c -o $@ $< - $(OBJDUMP) -S $@ > $(@D)/$*.asm - -$(BUILDDIR)/kernel/kernel: $(KERN_OBJ) - @mkdir -p $(@D) - $(LD) $(KLDFLAGS) $(LDFLAGS) -o $@ $(KERN_OBJ) $(KLIBS) - $(OBJDUMP) -S $@ > $@.asm - $(NM) -n $@ > $@.sym - $(READELF) -a $@ > $@.info - -$(BUILDDIR)/kernel/kernel.b: $(BUILDDIR)/kernel/kernel - $(LD) $(LDFLAGS) -o $(BUILDDIR)/kernel/kernel.b -s \ - --oformat binary -Ttext 0x10000 $(BUILDDIR)/kernel/kernel - -# some debugging assist rules -$(BUILDDIR)/kernel/%.i: kernel/%.c $(BUILDDIR)/.vars.CFLAGS - @mkdir -p $(@D) - $(CC) $(CFLAGS) $(KCFLAGS) -E -c $< > $(@D)/$*.i - -$(BUILDDIR)/kernel/%.dat: $(BUILDDIR)/kernel/%.o - @mkdir -p $(@D) - $(OBJCOPY) -S -O binary -j .data $< $@ - hexdump -C $@ > $(@D)/$*.hex - -$(BUILDDIR)/kernel/%.rodat: $(BUILDDIR)/kernel/%.o - @mkdir -p $(@D) - $(OBJCOPY) -S -O binary -j .rodata $< $@ - hexdump -C $@ > $(@D)/$*.hex - diff --git a/kernel/old/cio.c b/kernel/old/cio.c deleted file mode 100644 index cfff543..0000000 --- a/kernel/old/cio.c +++ /dev/null @@ -1,796 +0,0 @@ -/* -** SCCS ID: @(#)cio.c 2.10 1/22/25 -** -** @file cio.c -** -** @author Warren R. Carithers -** -** Based on: c_io.c 1.13 (Ken Reek, Jon Coles, Warren R. Carithers) -** -** Console I/O routines -** -** This module implements a simple set of input and output routines -** for the console screen and keyboard on the machines in the DSL. -** Refer to the header file comments for complete details. -** -** Naming conventions: -** -** Externally-visible functions have names beginning with the -** characters "cio_". -** -*/ - -#include <cio.h> -#include <lib.h> -#include <support.h> -#include <x86/arch.h> -#include <x86/pic.h> -#include <x86/ops.h> - -/* -** Bit masks for the lower five and eight bits of a value -*/ -#define BMASK5 0x1f -#define BMASK8 0xff - -/* -** Video parameters -*/ -#define SCREEN_MIN_X 0 -#define SCREEN_MIN_Y 0 -#define SCREEN_X_SIZE 80 -#define SCREEN_Y_SIZE 25 -#define SCREEN_MAX_X ( SCREEN_X_SIZE - 1 ) -#define SCREEN_MAX_Y ( SCREEN_Y_SIZE - 1 ) - -/* -** Video state -*/ -static unsigned int scroll_min_x, scroll_min_y; -static unsigned int scroll_max_x, scroll_max_y; -static unsigned int curr_x, curr_y; -static unsigned int min_x, min_y; -static unsigned int max_x, max_y; - -// pointer to input notification function -static void (*notify)(int); - -#ifdef SA_DEBUG -#include <stdio.h> -#define cio_putchar putchar -#define cio_puts(x) fputs( x, stdout ) -#endif - - -/* -** VGA definitions. -*/ - -// calculate the memory address of a specific character position -// within VGA memory -#define VIDEO_ADDR(x,y) ( unsigned short * ) \ - ( VID_BASE_ADDR + 2 * ( (y) * SCREEN_X_SIZE + (x) ) ) - -// port addresses -#define VGA_CTRL_IX_ADDR 0x3d4 -# define VGA_CTRL_CUR_HIGH 0x0e // cursor location, high byte -# define VGA_CTRL_CUR_LOW 0x0f // cursor location, low byte -#define VGA_CTRL_IX_DATA 0x3d5 - -// attribute bits -#define VGA_ATT_BBI 0x80 // blink, or background intensity -#define VGA_ATT_BGC 0x70 // background color -#define VGA_ATT_FICS 0x80 // foreground intensity or char font select -#define VGA_ATT_FGC 0x70 // foreground color - -// color selections -#define VGA_BG_BLACK 0x0000 // background colors -#define VGA_BG_BLUE 0x1000 -#define VGA_BG_GREEN 0x2000 -#define VGA_BG_CYAN 0x3000 -#define VGA_BG_RED 0x4000 -#define VGA_BG_MAGENTA 0x5000 -#define VGA_BG_BROWN 0x6000 -#define VGA_BG_WHITE 0x7000 - -#define VGA_FG_BLACK 0x0000 // foreground colors -#define VGA_FG_BLUE 0x0100 -#define VGA_FG_GREEN 0x0200 -#define VGA_FG_CYAN 0x0300 -#define VGA_FG_RED 0x0400 -#define VGA_FG_MAGENTA 0x0500 -#define VGA_FG_BROWN 0x0600 -#define VGA_FG_WHITE 0x0700 - -// color combinations -#define VGA_WHITE_ON_BLACK (VGA_FG_WHITE | VGA_BG_BLACK) -#define VGA_BLACK_ON_WHITE (VGA_FG_BLACK | VGA_BG_WHITE) - -/* -** Internal support routines. -*/ - -/* -** setcursor: set the cursor location (screen coordinates) -*/ -static void setcursor( void ) { - unsigned addr; - unsigned int y = curr_y; - - if( y > scroll_max_y ) { - y = scroll_max_y; - } - - addr = (unsigned)( y * SCREEN_X_SIZE + curr_x ); - - outb( VGA_CTRL_IX_ADDR, VGA_CTRL_CUR_HIGH ); - outb( VGA_CTRL_IX_DATA, ( addr >> 8 ) & BMASK8 ); - outb( VGA_CTRL_IX_ADDR, VGA_CTRL_CUR_LOW ); - outb( VGA_CTRL_IX_DATA, addr & BMASK8 ); -} - -/* -** putchar_at: physical output to the video memory -*/ -static void putchar_at( unsigned int x, unsigned int y, unsigned int c ) { - /* - ** If x or y is too big or small, don't do any output. - */ - if( x <= max_x && y <= max_y ) { - unsigned short *addr = VIDEO_ADDR( x, y ); - - /* - ** The character may have attributes associated with it; if - ** so, use those, otherwise use white on black. - */ - c &= 0xffff; // keep only the lower bytes - if( c > BMASK8 ) { - *addr = (unsigned short)c; - } else { - *addr = (unsigned short)c | VGA_WHITE_ON_BLACK; - } - } -} - -/* -** Globally-visible support routines. -*/ - -/* -** Set the scrolling region -*/ -void cio_setscroll( unsigned int s_min_x, unsigned int s_min_y, - unsigned int s_max_x, unsigned int s_max_y ) { - scroll_min_x = bound( min_x, s_min_x, max_x ); - scroll_min_y = bound( min_y, s_min_y, max_y ); - scroll_max_x = bound( scroll_min_x, s_max_x, max_x ); - scroll_max_y = bound( scroll_min_y, s_max_y, max_y ); - curr_x = scroll_min_x; - curr_y = scroll_min_y; - setcursor(); -} - -/* -** Cursor movement in the scroll region -*/ -void cio_moveto( unsigned int x, unsigned int y ) { - curr_x = bound( scroll_min_x, x + scroll_min_x, scroll_max_x ); - curr_y = bound( scroll_min_y, y + scroll_min_y, scroll_max_y ); - setcursor(); -} - -/* -** The putchar family -*/ -void cio_putchar_at( unsigned int x, unsigned int y, unsigned int c ) { - if( ( c & 0x7f ) == '\n' ) { - unsigned int limit; - - /* - ** If we're in the scroll region, don't let this loop - ** leave it. If we're not in the scroll region, don't - ** let this loop enter it. - */ - if( x > scroll_max_x ) { - limit = max_x; - } - else if( x >= scroll_min_x ) { - limit = scroll_max_x; - } - else { - limit = scroll_min_x - 1; - } - while( x <= limit ) { - putchar_at( x, y, ' ' ); - x += 1; - } - } - else { - putchar_at( x, y, c ); - } -} - -#ifndef SA_DEBUG -void cio_putchar( unsigned int c ) { - /* - ** If we're off the bottom of the screen, scroll the window. - */ - if( curr_y > scroll_max_y ) { - cio_scroll( curr_y - scroll_max_y ); - curr_y = scroll_max_y; - } - - switch( c & BMASK8 ) { - case '\n': - /* - ** Erase to the end of the line, then move to new line - ** (actual scroll is delayed until next output appears). - */ - while( curr_x <= scroll_max_x ) { - putchar_at( curr_x, curr_y, ' ' ); - curr_x += 1; - } - curr_x = scroll_min_x; - curr_y += 1; - break; - - case '\r': - curr_x = scroll_min_x; - break; - - default: - putchar_at( curr_x, curr_y, c ); - curr_x += 1; - if( curr_x > scroll_max_x ) { - curr_x = scroll_min_x; - curr_y += 1; - } - break; - } - setcursor(); -} -#endif - -/* -** The puts family -*/ -void cio_puts_at( unsigned int x, unsigned int y, const char *str ) { - unsigned int ch; - - while( (ch = *str++) != '\0' && x <= max_x ) { - cio_putchar_at( x, y, ch ); - x += 1; - } -} - -#ifndef SA_DEBUG -void cio_puts( const char *str ) { - unsigned int ch; - - while( (ch = *str++) != '\0' ) { - cio_putchar( ch ); - } -} -#endif - -/* -** Write a "sized" buffer (like cio_puts(), but no NUL) -*/ -void cio_write( const char *buf, int length ) { - for( int i = 0; i < length; ++i ) { - cio_putchar( buf[i] ); - } -} - -void cio_clearscroll( void ) { - unsigned int nchars = scroll_max_x - scroll_min_x + 1; - unsigned int l; - unsigned int c; - - for( l = scroll_min_y; l <= scroll_max_y; l += 1 ) { - unsigned short *to = VIDEO_ADDR( scroll_min_x, l ); - - for( c = 0; c < nchars; c += 1 ) { - *to++ = ' ' | 0x0700; - } - } -} - -void cio_clearscreen( void ) { - unsigned short *to = VIDEO_ADDR( min_x, min_y ); - unsigned int nchars = ( max_y - min_y + 1 ) * ( max_x - min_x + 1 ); - - while( nchars > 0 ) { - *to++ = ' ' | 0x0700; - nchars -= 1; - } -} - - -void cio_scroll( unsigned int lines ) { - unsigned short *from; - unsigned short *to; - int nchars = scroll_max_x - scroll_min_x + 1; - int line, c; - - /* - ** If # of lines is the whole scrolling region or more, just clear. - */ - if( lines > scroll_max_y - scroll_min_y ) { - cio_clearscroll(); - curr_x = scroll_min_x; - curr_y = scroll_min_y; - setcursor(); - return; - } - - /* - ** Must copy it line by line. - */ - for( line = scroll_min_y; line <= scroll_max_y - lines; line += 1 ) { - from = VIDEO_ADDR( scroll_min_x, line + lines ); - to = VIDEO_ADDR( scroll_min_x, line ); - for( c = 0; c < nchars; c += 1 ) { - *to++ = *from++; - } - } - - for( ; line <= scroll_max_y; line += 1 ) { - to = VIDEO_ADDR( scroll_min_x, line ); - for( c = 0; c < nchars; c += 1 ) { - *to++ = ' ' | 0x0700; - } - } -} - -static int mypad( int x, int y, int extra, int padchar ) { - while( extra > 0 ) { - if( x != -1 || y != -1 ) { - cio_putchar_at( x, y, padchar ); - x += 1; - } - else { - cio_putchar( padchar ); - } - extra -= 1; - } - return x; -} - -static int mypadstr( int x, int y, char *str, int len, int width, - int leftadjust, int padchar ) { - int extra; - - if( len < 0 ) { - len = strlen( str ); - } - extra = width - len; - if( extra > 0 && !leftadjust ) { - x = mypad( x, y, extra, padchar ); - } - if( x != -1 || y != -1 ) { - cio_puts_at( x, y, str ); - x += len; - } - else { - cio_puts( str ); - } - if( extra > 0 && leftadjust ) { - x = mypad( x, y, extra, padchar ); - } - return x; -} - -static void do_printf( int x, int y, char **f ) { - char *fmt = *f; - int *ap; - char buf[ 12 ]; - char ch; - char *str; - int leftadjust; - int width; - int len; - int padchar; - - /* - ** Get characters from the format string and process them - */ - - ap = (int *)( f + 1 ); - - while( (ch = *fmt++) != '\0' ) { - - /* - ** Is it the start of a format code? - */ - - if( ch == '%' ) { - - /* - ** Yes, get the padding and width options (if there). - ** Alignment must come at the beginning, then fill, - ** then width. - */ - - leftadjust = 0; - padchar = ' '; - width = 0; - - ch = *fmt++; - - if( ch == '-' ) { - leftadjust = 1; - ch = *fmt++; - } - - if( ch == '0' ) { - padchar = '0'; - ch = *fmt++; - } - - while( ch >= '0' && ch <= '9' ) { - width *= 10; - width += ch - '0'; - ch = *fmt++; - } - - /* - ** What data type do we have? - */ - switch( ch ) { - - case 'c': - // ch = *( (int *)ap )++; - ch = *ap++; - buf[ 0 ] = ch; - buf[ 1 ] = '\0'; - x = mypadstr( x, y, buf, 1, width, leftadjust, padchar ); - break; - - case 'd': - // len = cvtdec( buf, *( (int *)ap )++ ); - len = cvtdec( buf, *ap++ ); - x = mypadstr( x, y, buf, len, width, leftadjust, padchar ); - break; - - case 's': - // str = *( (char **)ap )++; - str = (char *) (*ap++); - x = mypadstr( x, y, str, -1, width, leftadjust, padchar ); - break; - - case 'x': - // len = cvthex( buf, *( (int *)ap )++ ); - len = cvthex( buf, *ap++ ); - x = mypadstr( x, y, buf, len, width, leftadjust, padchar ); - break; - - case 'o': - // len = cvtoct( buf, *( (int *)ap )++ ); - len = cvtoct( buf, *ap++ ); - x = mypadstr( x, y, buf, len, width, leftadjust, padchar ); - break; - - case 'u': - len = cvtuns( buf, *ap++ ); - x = mypadstr( x, y, buf, len, width, leftadjust, padchar ); - break; - - } - } else { - - /* - ** No - just print it normally. - */ - - if( x != -1 || y != -1 ) { - cio_putchar_at( x, y, ch ); - switch( ch ) { - case '\n': - y += 1; - /* FALL THRU */ - - case '\r': - x = scroll_min_x; - break; - - default: - x += 1; - } - } - else { - cio_putchar( ch ); - } - } - } -} - -void cio_printf_at( unsigned int x, unsigned int y, char *fmt, ... ) { - do_printf( x, y, &fmt ); -} - -void cio_printf( char *fmt, ... ) { - do_printf( -1, -1, &fmt ); -} - -/* -** These are the "standard" IBM AT "Set 1" keycodes. -*/ - -static unsigned char scan_code[ 2 ][ 128 ] = { - { // unshifted characters -/* 00-07 */ '\377', '\033', '1', '2', '3', '4', '5', '6', -/* 08-0f */ '7', '8', '9', '0', '-', '=', '\b', '\t', -/* 10-17 */ 'q', 'w', 'e', 'r', 't', 'y', 'u', 'i', -/* 18-1f */ 'o', 'p', '[', ']', '\n', '\377', 'a', 's', -/* 20-27 */ 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';', -/* 28-2f */ '\'', '`', '\377', '\\', 'z', 'x', 'c', 'v', -/* 30-37 */ 'b', 'n', 'm', ',', '.', '/', '\377', '*', -/* 38-3f */ '\377', ' ', '\377', '\377', '\377', '\377', '\377', '\377', -/* 40-47 */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '7', -/* 48-4f */ '8', '9', '-', '4', '5', '6', '+', '1', -/* 50-57 */ '2', '3', '0', '.', '\377', '\377', '\377', '\377', -/* 58-5f */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377', -/* 60-67 */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377', -/* 68-6f */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377', -/* 70-77 */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377', -/* 78-7f */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377' - }, - - { // shifted characters -/* 00-07 */ '\377', '\033', '!', '@', '#', '$', '%', '^', -/* 08-0f */ '&', '*', '(', ')', '_', '+', '\b', '\t', -/* 10-17 */ 'Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I', -/* 18-1f */ 'O', 'P', '{', '}', '\n', '\377', 'A', 'S', -/* 20-27 */ 'D', 'F', 'G', 'H', 'J', 'K', 'L', ':', -/* 28-2f */ '"', '~', '\377', '|', 'Z', 'X', 'C', 'V', -/* 30-37 */ 'B', 'N', 'M', '<', '>', '?', '\377', '*', -/* 38-3f */ '\377', ' ', '\377', '\377', '\377', '\377', '\377', '\377', -/* 40-47 */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '7', -/* 48-4f */ '8', '9', '-', '4', '5', '6', '+', '1', -/* 50-57 */ '2', '3', '0', '.', '\377', '\377', '\377', '\377', -/* 58-5f */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377', -/* 60-67 */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377', -/* 68-6f */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377', -/* 70-77 */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377', -/* 78-7f */ '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377' - } -}; - -/* -** Scan code masks -*/ - -// 'release' bit -#define REL_BIT 0x80 -#define CODE_BITS 0x7f - -#define IS_PRESS(c) (((c) & REL_BIT) == 0) -#define IS_RELEASE(c) (((c) & REL_BIT) != 0) - -/* -** Scan codes for some special characters -*/ - -// escape code - followed by another code byte -#define SCAN_ESC 0xe0 - -// shift keys: press, release -#define L_SHIFT_DN 0x2a -#define R_SHIFT_DN 0x36 -#define L_SHIFT_UP 0xaa -#define R_SHIFT_UP 0xb6 - -// control keys -#define L_CTRL_DN 0x1d -#define L_CTRL_UP 0x9d - -/* -** I/O communication constants -*/ -#define KBD_DATA 0x60 -#define KBD_STATUS 0x64 -#define READY 0x1 - -/* -** Circular buffer for input characters. Characters are inserted at -** next_space, and are removed at next_char. Buffer is empty if -** these are equal. -*/ -#define C_BUFSIZE 200 - -static char input_buffer[ C_BUFSIZE ]; -static volatile char *next_char = input_buffer; -static volatile char *next_space = input_buffer; - -static volatile char *increment( volatile char *pointer ) { - if( ++pointer >= input_buffer + C_BUFSIZE ) { - pointer = input_buffer; - } - return pointer; -} - -static int input_scan_code( int code ) { - static int shift = 0; - static int ctrl_mask = BMASK8; - int rval = -1; - - /* - ** Do the shift processing - */ - code &= BMASK8; - switch( code ) { - case L_SHIFT_DN: - case R_SHIFT_DN: - shift = 1; - break; - - case L_SHIFT_UP: - case R_SHIFT_UP: - shift = 0; - break; - - case L_CTRL_DN: - ctrl_mask = BMASK5; - break; - - case L_CTRL_UP: - ctrl_mask = BMASK8; - break; - - default: - /* - ** Process ordinary characters only on the press (to handle - ** autorepeat). Ignore undefined scan codes. - */ - if( IS_PRESS(code) ) { - code = scan_code[ shift ][ (int)code ]; - if( code != '\377' ) { - volatile char *next = increment( next_space ); - - /* - ** Store character only if there's room - */ - rval = code & ctrl_mask; - if( next != next_char ) { - *next_space = code & ctrl_mask; - next_space = next; - } - } - } - } - return( rval ); -} - -static void keyboard_isr( int vector, int code ) { - - int data = inb( KBD_DATA ); - int val = input_scan_code( data ); - - // if there is a notification function, call it - if( val != -1 && notify ) - notify( val ); - - outb( PIC1_CMD, PIC_EOI ); -} - -int cio_getchar( void ) { - char c; - int interrupts_enabled = r_eflags() & EFL_IF; - - while( next_char == next_space ) { - if( !interrupts_enabled ) { - /* - ** Must read the next keystroke ourselves. - */ - while( ( inb( KBD_STATUS ) & READY ) == 0 ) { - ; - } - (void) input_scan_code( inb( KBD_DATA ) ); - } - } - - c = *next_char & BMASK8; - next_char = increment( next_char ); - if( c != EOT ) { - cio_putchar( c ); - } - return c; -} - -int cio_gets( char *buffer, unsigned int size ) { - char ch; - int count = 0; - - while( size > 1 ) { - ch = cio_getchar(); - if( ch == EOT ) { - break; - } - *buffer++ = ch; - count += 1; - size -= 1; - if( ch == '\n' ) { - break; - } - } - *buffer = '\0'; - return count; -} - -int cio_input_queue( void ) { - int n_chars = next_space - next_char; - - if( n_chars < 0 ) { - n_chars += C_BUFSIZE; - } - return n_chars; -} - -/* -** Initialization routines -*/ -void cio_init( void (*fcn)(int) ) { - /* - ** Screen dimensions - */ - min_x = SCREEN_MIN_X; - min_y = SCREEN_MIN_Y; - max_x = SCREEN_MAX_X; - max_y = SCREEN_MAX_Y; - - /* - ** Scrolling region - */ - scroll_min_x = SCREEN_MIN_X; - scroll_min_y = SCREEN_MIN_Y; - scroll_max_x = SCREEN_MAX_X; - scroll_max_y = SCREEN_MAX_Y; - - /* - ** Initial cursor location - */ - curr_y = min_y; - curr_x = min_x; - setcursor(); - - /* - ** Notification function (or NULL) - */ - notify = fcn; - - /* - ** Set up the interrupt handler for the keyboard - */ - install_isr( VEC_KBD, keyboard_isr ); -} - -#ifdef SA_DEBUG -int main() { - cio_printf( "%d\n", 123 ); - cio_printf( "%d\n", -123 ); - cio_printf( "%d\n", 0x7fffffff ); - cio_printf( "%d\n", 0x80000001 ); - cio_printf( "%d\n", 0x80000000 ); - cio_printf( "x%14dy\n", 0x80000000 ); - cio_printf( "x%-14dy\n", 0x80000000 ); - cio_printf( "x%014dy\n", 0x80000000 ); - cio_printf( "x%-014dy\n", 0x80000000 ); - cio_printf( "%s\n", "xyz" ); - cio_printf( "|%10s|\n", "xyz" ); - cio_printf( "|%-10s|\n", "xyz" ); - cio_printf( "%c\n", 'x' ); - cio_printf( "|%4c|\n", 'y' ); - cio_printf( "|%-4c|\n", 'y' ); - cio_printf( "|%04c|\n", 'y' ); - cio_printf( "|%-04c|\n", 'y' ); - cio_printf( "|%3d|\n", 5 ); - cio_printf( "|%3d|\n", 54321 ); - cio_printf( "%x\n", 0x123abc ); - cio_printf( "|%04x|\n", 20 ); - cio_printf( "|%012x|\n", 0xfedcba98 ); - cio_printf( "|%-012x|\n", 0x76543210 ); -} - -int curr_x, curr_y, max_x, max_y; -#endif diff --git a/kernel/old/clock.c b/kernel/old/clock.c deleted file mode 100644 index 96f71c4..0000000 --- a/kernel/old/clock.c +++ /dev/null @@ -1,163 +0,0 @@ -/** -** @file clock.c -** -** @author CSCI-452 class of 20245 -** -** @brief Clock module implementation -*/ - -#define KERNEL_SRC - -#include <common.h> - -#include <clock.h> -#include <procs.h> - -#include <x86/arch.h> -#include <x86/pic.h> -#include <x86/pit.h> - -/* -** PRIVATE DEFINITIONS -*/ - -/* -** PRIVATE DATA TYPES -*/ - -/* -** PRIVATE GLOBAL VARIABLES -*/ - -// pinwheel control variables -static uint32_t pinwheel; // pinwheel counter -static uint32_t pindex; // index into pinwheel string - -/* -** PUBLIC GLOBAL VARIABLES -*/ - -// current system time -uint32_t system_time; - -/* -** PRIVATE FUNCTIONS -*/ - -/** -** Name: clk_isr -** -** The ISR for the clock -** -** @param vector Vector number for the clock interrupt -** @param code Error code (0 for this interrupt) -*/ -static void clk_isr( int vector, int code ) { - - // spin the pinwheel - - ++pinwheel; - if( pinwheel == (CLOCK_FREQ / 10) ) { - pinwheel = 0; - ++pindex; - cio_putchar_at( 0, 0, "|/-\\"[ pindex & 3 ] ); - } - -#if defined(SYSTEM_STATUS) - // Periodically, dump the queue lengths and the SIO status (along - // with the SIO buffers, if non-empty). - // - // Define the symbol SYSTEM_STATUS with a value equal to the desired - // reporting frequency, in seconds. - - if( (system_time % SEC_TO_TICKS(SYSTEM_STATUS)) == 0 ) { - cio_printf_at( 1, 0, " queues: R[%u] W[%u] S[%u] Z[%u] I[%u] ", - pcb_queue_length(ready), - pcb_queue_length(waiting), - pcb_queue_length(sleeping), - pcb_queue_length(zombie), - pcb_queue_length(sioread) - ); - } -#endif - - // time marches on! - ++system_time; - - // wake up any sleeping processes whose time has come - // - // we give them preference over the current process when - // it is scheduled again - - do { - // if there isn't anyone in the sleep queue, we're done - if( pcb_queue_empty(sleeping) ) { - break; - } - - // peek at the first member of the queue - pcb_t *tmp = pcb_queue_peek( sleeping ); - assert( tmp != NULL ); - - // the sleep queue is sorted in ascending order by wakeup - // time, so we know that the retrieved PCB's wakeup time is - // the earliest of any process on the sleep queue; if that - // time hasn't arrived yet, there's nobody left to awaken - - if( tmp->wakeup > system_time ) { - break; - } - - // OK, we need to wake this process up - assert( pcb_queue_remove(sleeping,&tmp) == SUCCESS ); - schedule( tmp ); - } while( 1 ); - - // next, we decrement the current process' remaining time - current->ticks -= 1; - - // has it expired? - if( current->ticks < 1 ) { - // yes! reschedule it - schedule( current ); - current = NULL; - // and pick a new process - dispatch(); - } - - // tell the PIC we're done - outb( PIC1_CMD, PIC_EOI ); -} - -/* -** PUBLIC FUNCTIONS -*/ - -/** -** Name: clk_init -** -** Initializes the clock module -** -*/ -void clk_init( void ) { - -#if TRACING_INIT - cio_puts( " Clock" ); -#endif - - // start the pinwheel - pinwheel = (CLOCK_FREQ / 10) - 1; - pindex = 0; - - // return to the dawn of time - system_time = 0; - - // configure the clock - uint32_t divisor = PIT_FREQ / CLOCK_FREQ; - outb( PIT_CONTROL_PORT, PIT_0_LOAD | PIT_0_SQUARE ); - outb( PIT_0_PORT, divisor & 0xff ); // LSB of divisor - outb( PIT_0_PORT, (divisor >> 8) & 0xff ); // MSB of divisor - - // register the second-stage ISR - install_isr( VEC_TIMER, clk_isr ); -} diff --git a/kernel/old/include/.vm.h.swp b/kernel/old/include/.vm.h.swp Binary files differdeleted file mode 100644 index eb334b9..0000000 --- a/kernel/old/include/.vm.h.swp +++ /dev/null diff --git a/kernel/old/include/bootstrap.h b/kernel/old/include/bootstrap.h deleted file mode 100644 index ade778a..0000000 --- a/kernel/old/include/bootstrap.h +++ /dev/null @@ -1,120 +0,0 @@ -/* -** SCCS ID: @(#)bootstrap.h 2.4 1/22/25 -** -** @file bootstrap.h -** -** @author K. Reek -** @author Warren R. Carithers, Garrett C. Smith -** -** Addresses where various stuff goes in memory. -*/ - -#ifndef BOOTSTRAP_H_ -#define BOOTSTRAP_H_ - -/* -** The boot device -*/ -#define BDEV_FLOPPY 0x00 -#define BDEV_USB 0x80 /* hard drive */ - -#define BDEV BDEV_USB /* default */ - -/* -** Bootstrap definitions -*/ -#define BOOT_SEG 0x07c0 /* 07c0:0000 */ -#define BOOT_DISP 0x0000 -#define BOOT_ADDR ((BOOT_SEG << 4) + BOOT_DISP) - -#define PART2_DISP 0x0200 /* 07c0:0200 */ -#define PART2_ADDR ((BOOT_SEG << 4) + PART2_DISP) - -#define SECTOR_SIZE 0x200 /* 512 bytes */ - -/* Note: this assumes the bootstrap is two sectors long! */ -#define BOOT_SIZE (SECTOR_SIZE + SECTOR_SIZE) - -#define OFFSET_LIMIT (0x10000 - SECTOR_SIZE) - -#define BOOT_SP_DISP 0x4000 /* stack pointer 07c0:4000, or 0xbc00 */ -#define BOOT_SP_ADDR ((BOOT_SEG << 4) + BOOT_SP_DISP) - -#define SECTOR1_END (BOOT_ADDR + SECTOR_SIZE) -#define SECTOR2_END (BOOT_ADDR + BOOT_SIZE) - -// location of the user blob data -// (three halfwords of data) -#define USER_BLOB_DATA (SECTOR2_END - 12) - -/* -** The target program itself -*/ -#define TARGET_SEG 0x00001000 /* 1000:0000 */ -#define TARGET_ADDR 0x00010000 /* and upward */ -#define TARGET_STACK 0x00010000 /* and downward */ - -/* -** The Global Descriptor Table (0000:0500 - 0000:2500) -*/ -#define GDT_SEG 0x00000050 -#define GDT_ADDR 0x00000500 - - /* segment register values */ -#define GDT_LINEAR 0x0008 /* All of memory, R/W */ -#define GDT_CODE 0x0010 /* All of memory, R/E */ -#define GDT_DATA 0x0018 /* All of memory, R/W */ -#define GDT_STACK 0x0020 /* All of memory, R/W */ - -/* -** The Interrupt Descriptor Table (0000:2500 - 0000:2D00) -*/ -#define IDT_SEG 0x00000250 -#define IDT_ADDR 0x00002500 - -/* -** Additional I/O ports used by the bootstrap code -*/ - -// keyboard controller -#define KBD_DATA 0x60 -#define KBD_CMD 0x64 -#define KBD_STAT 0x64 - -// status register bits -#define KBD_OBSTAT 0x01 -#define KBD_IBSTAT 0x02 -#define KBD_SYSFLAG 0x04 -#define KBD_CMDDAT 0x08 - -// commands -#define KBD_P1_DISABLE 0xad -#define KBD_P1_ENABLE 0xae -#define KBD_RD_OPORT 0xd0 -#define KBD_WT_OPORT 0xd1 - -#ifdef ASM_SRC - -// segment descriptor macros for use in assembly source files -// layout: -// .word lower 16 bits of limit -// .word lower 16 bits of base -// .byte middle 8 bits of base -// .byte type byte -// .byte granularity byte -// .byte upper 8 bits of base -// we use 4K units, so we ignore the lower 12 bits of the limit -#define SEGNULL \ - .word 0, 0, 0, 0 - -#define SEGMENT(base,limit,dpl,type) \ - .word (((limit) >> 12) & 0xffff); \ - .word ((base) & 0xffff) ; \ - .byte (((base) >> 16) & 0xff) ; \ - .byte (SEG_PRESENT | (dpl) | SEG_NON_SYSTEM | (type)) ; \ - .byte (SEG_GRAN_4KBYTE | SEG_DB_32BIT | (((limit) >> 28) & 0xf)) ; \ - .byte (((base) >> 24) & 0xff) - -#endif /* ASM_SRC */ - -#endif diff --git a/kernel/old/include/cio.h b/kernel/old/include/cio.h deleted file mode 100644 index 1854f6e..0000000 --- a/kernel/old/include/cio.h +++ /dev/null @@ -1,287 +0,0 @@ -/** -** SCCS ID: @(#)cio.h 2.7 1/22/25 -** -** @file cio.h -** -** @author Warren R. Carithers -** @authors K. Reek, Jon Coles -** -** Based on: c_io.c 1.13 (Ken Reek, Jon Coles, Warren R. Carithers) -** -** Declarations and descriptions of console I/O routines -** -** These routines provide a rudimentary capability for printing to -** the screen and reading from the keyboard. -** -** Screen output: -** There are two families of functions. The first provides a window -** that behaves in the usual manner: writes extending beyond the right -** edge of the window wrap around to the next line, the top line -** scrolls off the window to make room for new lines at the bottom. -** However, you may choose what part of the screen contains this -** scrolling window. This allows you to print some text at fixed -** locations on the screen while the rest of the screen scrolls. -** -** The second family allows for printing at fixed locations on the -** screen. No scrolling or line wrapping are done for these functions. -** It is not intended that these functions be used to write in the -** scrolling area of the screen. -** -** In both sets of functions, the (x,y) coordinates are interpreted -** as (column,row), with the upper left corner of the screen being -** (0,0) and the lower right corner being (79,24). -** -** The printf provided in both sets of functions has the same -** conversion capabilities. Format codes are of the form: -** -** %-0WC -** -** where "-", "0", and "W" are all optional: -** "-" is the left-adjust flag (default is right-adjust) -** "0" is the zero-fill flag (default is space-fill) -** "W" is a number specifying the minimum field width (default: 1 ) -** and "C" is the conversion type, which must be one of these: -** "c" print a single character -** "s" print a null-terminated string -** "d" print an integer as a decimal value -** "x" print an integer as a hexadecimal value -** "o" print an integer as a octal value -** -** Keyboard input: -** Two functions are provided: getting a single character and getting -** a newline-terminated line. A third function returns a count of -** the number of characters available for immediate reading. -** No conversions are provided (yet). -*/ - -#ifndef CIO_H_ -#define CIO_H_ - -#ifndef ASM_SRC - -// EOT indicator (control-D) -#define EOT '\04' - -/***************************************************************************** -** -** INITIALIZATION ROUTINES -** -** Initializes the I/O system. -*/ - -/** -** cio_init -** -** Initializes the I/O routines. Must be called before -** any CIO functions can be used. -** -** @param notify pointer to an input notification function, or NULL -*/ -void cio_init( void (*notify)(int) ); - -/***************************************************************************** -** -** SCROLLING OUTPUT ROUTINES -** -** Each operation begins at the current cursor position and advances -** it. If a newline is output, the reminder of that line is cleared. -** Output extending past the end of the line is wrapped. If the -** cursor is moved below the scrolling region's bottom edge, scrolling -** is delayed until the next output is produced. -*/ - -/** -** cio_setscroll -** -** This sets the scrolling region to be the area defined by the arguments. -** The remainder of the screen does not scroll and may be used to display -** data you do not want to move. By default, the scrolling region is the -** entire screen. X and Y coordinates begin at 0 in the upper left corner -** of the screen. -** -** @param min_x,min_y upper-left corner of the region -** @param max_x,max_y lower-right corner of the region -*/ -void cio_setscroll( unsigned int min_x, unsigned int min_y, - unsigned int max_x, unsigned int max_y ); - -/** -** cio_moveto -** -** Moves the cursor to the specified position. (0,0) indicates -** the upper left corner of the scrolling region. Subsequent -** output will begin at the cursor position. -** -** @param x,y desired coordinate position -*/ -void cio_moveto( unsigned int x, unsigned int y ); - -/** -** cio_putchar -** -** Prints a single character. -** -** @param c the character to be printed -*/ -void cio_putchar( unsigned int c ); - -/** -** cio_puts -** -** Prints the characters in the string up to but not including -** the terminating null byte. -** -** @param str pointer to a NUL-terminated string to be printed -*/ -void cio_puts( const char *str ); - -/** -** cio_write -** -** Prints "length" characters from the buffer. -** -** @param buf the buffer of characters -** @param length the number of characters to print -*/ -void cio_write( const char *buf, int length ); - -/** -** cio_printf -** -** Limited form of printf (see the beginning of this file for -** a list of what is implemented). -** -** @param fmt a printf-style format control string -** @param ... optional additional values to be printed -*/ -void cio_printf( char *fmt, ... ); - -/** -** cio_scroll -** -** Scroll the scrolling region up by the given number of lines. -** The output routines scroll automatically so normally you -** do not need to call this routine yourself. -** -** @param lines the number of lines to scroll -*/ -void cio_scroll( unsigned int lines ); - -/** -** cio_clearscroll -** -** Clears the entire scrolling region to blank spaces, and -** moves the cursor to (0,0). -*/ -void cio_clearscroll( void ); - -/***************************************************************************** -** -** NON-SCROLLING OUTPUT ROUTINES -** -** Coordinates are relative to the entire screen: (0,0) is the upper -** left corner. There is no line wrap or scrolling. -*/ - -/** -** cio_putchar_at -** -** Prints the given character. If a newline is printed, -** the rest of the line is cleared. If this happens to the -** left of the scrolling region, the clearing stops when the -** region is reached. If this happens inside the scrolling -** region, the clearing stops when the edge of the region -** is reached. -** -** @param x,y desired coordinate position -** @param c the character to be printed -*/ -void cio_putchar_at( unsigned int x, unsigned int y, unsigned int c ); - -/** -** cio_puts_at -** -** Prints the given string. cio_putchar_at is used to print -** the individual characters; see that description for details. -** -** @param x,y desired coordinate position -** @param str pointer to a NUL-terminated string to be printed -*/ -void cio_puts_at( unsigned int x, unsigned int y, const char *str ); - -/** -** cio_printf_at -** -** Limited form of printf (see the beginning of this file for -** a list of what is implemented). -** -** @param x,y desired coordinate position -** @param fmt a printf-style format control string -** @param ... optional additional values to be printed -*/ -void cio_printf_at( unsigned int x, unsigned int y, char *fmt, ... ); - -/** -** cio_clearscreen -** -** This function clears the entire screen, including the scrolling region. -*/ -void cio_clearscreen( void ); - -/***************************************************************************** -** -** INPUT ROUTINES -** -** When interrupts are enabled, a keyboard ISR collects keystrokes -** and saves them until the program calls for them. If the input -** queue fills, additional characters are silently discarded. -** When interrupts are not enabled, keystrokes made when no input -** routines have been ** called are lost. This can cause errors in -** the input translation because the states of the Shift and Ctrl keys -** may not be tracked accurately. If interrupts are disabled, the user -** is advised to refrain from typing anything except when the program is -** waiting for input. -*/ - -/** -** cio_getchar -** -** If the character is not immediately available, the function -** waits until the character arrives. -** -** @return the next character from the keyboard input buffer -*/ -int cio_getchar( void ); - -/** -** cio_gets -** -** This function reads a newline-terminated line from the -** keyboard. cio_getchar is used to obtain the characters; -** see that description for more details. The function -** returns when: -** a newline is entered (this is stored in the buffer) -** ctrl-D is entered (not stored in the buffer) -** the buffer becomes full. -** The buffer is null-terminated in all cases. -** -** @param buffer destination buffer for the input character sequence -** @param size the buffer length -** -** @return count of the number of characters read into the buffer -*/ -int cio_gets( char *buffer, unsigned int size ); - -/** -** cio_input_queue -** -** This function lets the program determine whether there is input -** available. This indicates whether or not a call to cio_getchar() -** would block. -** -** @return number of characters in the input queue -*/ -int cio_input_queue( void ); -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/clock.h b/kernel/old/include/clock.h deleted file mode 100644 index 6eae41f..0000000 --- a/kernel/old/include/clock.h +++ /dev/null @@ -1,55 +0,0 @@ -/** -** @file clock.h -** -** @author CSCI-452 class of 20245 -** -** @brief Clock module declarations -*/ - -#ifndef CLOCK_H_ -#define CLOCK_H_ - -#include <common.h> - -/* -** General (C and/or assembly) definitions -*/ - -// conversion functions for seconds, ms, and ticks -// (SEC_TO_MS is defined in defs.h) -#define MS_TO_TICKS(n) ((n)) -#define SEC_TO_TICKS(n) (MS_TO_TICKS(SEC_TO_MS(n))) -#define TICKS_TO_SEC(n) ((n) / CLOCK_FREQ) -#define TICKS_TO_SEC_ROUNDED(n) (((n)+(CLOCK_FREQ-1)) / CLOCK_FREQ) - -#ifndef ASM_SRC - -/* -** Start of C-only definitions -*/ - -/* -** Types -*/ - -/* -** Globals -*/ - -// current system time -extern uint32_t system_time; - -/* -** Prototypes -*/ - -/** -** Name: clk_init -** -** Clock module initialization -*/ -void clk_init( void ); - -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/common.h b/kernel/old/include/common.h deleted file mode 100644 index 599c492..0000000 --- a/kernel/old/include/common.h +++ /dev/null @@ -1,31 +0,0 @@ -/** -** @file common.h -** -** @author Warren R. Carithers -** -** @brief Common definitions for the baseline system. -** -** This header file pulls in the standard header information needed -** by all parts of the system. It is purely for our convenience. -*/ - -#ifndef COMMON_H_ -#define COMMON_H_ - -// everything needs these; they also pull in -// the kernel- or user-level defs and lib headers -#include <types.h> -#include <params.h> -#include <defs.h> -#include <lib.h> - -#ifdef KERNEL_SRC - -// only kernel code needs these headers -#include <common.h> -#include <cio.h> -#include <debug.h> - -#endif /* KERNEL_SRC */ - -#endif diff --git a/kernel/old/include/compat.h b/kernel/old/include/compat.h deleted file mode 100644 index ee62090..0000000 --- a/kernel/old/include/compat.h +++ /dev/null @@ -1,131 +0,0 @@ -/** -** @file compat.h -** -** @author Warren R. Carithers -** -** @brief Compatibility definitions for standard modules. -** -** These definitions are here to simplify the integration -** of some pre-written modules into the 452 baseline system. -** This is used primarily for the 'kmem' and 'sio' modules. -** -** We use CPP symbols and not actual data types for things here, -** as this means we don't need to include any other header files -** into this file. This helps get around "include loops" (e.g., -** a.h includes b.h, which includes c.h, which includes a.h) when -** there are many interdependencies between source files. -*/ - -#ifndef COMPAT_H_ -#define COMPAT_H_ - -#include <common.h> -#include <procs.h> - -/* -** Section 1: sized integer types -** -** Internally, we use standard names for "sized" integer types for -** simplicity. If those disagree with the names used in the rest of -** the system, we take the opportunity to define our names here. -** -** To enable these, uncomment them, and place the apropriate -** existing type names in place of the '?' characters. -*/ - -// standard "sized integer" types -// #define int8_t ? -// #define uint8_t ? -// #define int16_t ? -// #define uint16_t ? -// #define int32_t ? -// #define uint32_t ? -// #define int64_t ? -// #define uint64_t ? -// #define bool_t ? - -/* -** Section 2: other types -** -** Add type definitions here as needed. -** -** Note: we do not include the PCB and Queue declarations -** here because we don't actually need them in this header -** file - we're only defining CPP macros. Whatever file -** uses these macros, however, must include the appropriate -** headers if it uses these macros. -** -** To enable these, uncomment them, and place the apropriate -** existing type names in place of the '?' characters. -*/ - -// type name for the PCB -#define PCBTYPE pcb_t - -// type name for our queue -#define QTYPE pcb_queue_t - -/* -** Section 3: interface and behavior -** -** Include #define statements here as needed to define -** the names of functions and globals used in these modules -** in terms of the names used in the rest of the baseline. -** -** To enable these, uncomment them, and place the apropriate -** existing variable or function names in place of the '?' characters. -*/ - -// string functions -#define SLENGTH strlen - -// scheduler -#define SCHED schedule - -// dispatcher -#define DISPATCH dispatch - -/* -** blocked queue for reading processes -** -** Define this if we are blocking processes which try to -** read from the SIO when no characters are available. -** Its value should be the name of the globally-visible -** queue to be used. -*/ -#define QNAME sioread - -#ifdef QNAME - -// Only define these macros if we need to be able to create and -// manage a queue of things. It is expected that these will need -// to be customized based on the names and calling sequences of -// the appropriate functions. - -// invoke the queue creation function -// examples: -// -// #define QCREATE(q) do { -// _que_create( &(q), NULL ); -// } while(0) -// -// #define QCREATE(q) // do nothing - -#define QCREATE(q) // handled elsewhere for us - -// check to see if the queue is empty -// examples: -// -// #define QEMPTY(q) queue_is_empty(q) -// #define QEMPTY(q) (quene_length(q) > 0) -#define QEMPTY(q) pcb_queue_empty(q) - -// this macro expands into code that removes a value from -// 'q' and places it into 'd' -#define QDEQUE(q,d) do { \ - assert(pcb_queue_remove( (q), (pcb_t **) &(d) ) == SUCCESS ); \ - } while(0) - -#endif /* QNAME */ - -#endif diff --git a/kernel/old/include/debug.h b/kernel/old/include/debug.h deleted file mode 100644 index 487a592..0000000 --- a/kernel/old/include/debug.h +++ /dev/null @@ -1,327 +0,0 @@ -/** -** @file debug.h -** -** @author Numerous CSCI-452 classes -** -** Debugging macros and constants. -** -*/ - -#ifndef DEBUG_H_ -#define DEBUG_H_ - -// Standard system headers - -#include <cio.h> -#include <support.h> - -// Kernel library - -#include <lib.h> - -#ifndef ASM_SRC - -/* -** Start of C-only definitions -*/ - -/* -** General function entry/exit announcements -*/ - -#ifdef ANNOUNCE_ENTRY -// Announce that we have entered a kernel function -// usage: ENTERING( "name" ), EXITING( "name" ) -// currently, these do not use the macro parameter, but could be -// modified to do so; instead, we use the __func__ CPP pseudo-macro -// to get the function name -#define ENTERING(n) do { cio_puts( " enter " __func__ ); } while(0) -#define EXITING(n) do { cio_puts( " exit " __func__ ); } while(0) -#else -#define ENTERING(m) // do nothing -#define EXITING(m) // do nothing -#endif - -/* -** Console messages when error conditions are noted. -*/ - -// Warning messages to the console -// m: message (condition, etc.) -#define WARNING(m) do { \ - cio_printf( "\n** %s (%s @ %d): ", __func__, __FILE__, __LINE__ ); \ - cio_puts( m ); \ - cio_putchar( '\n' ); \ - } while(0) - -// Panic messages to the console -// n: severity level -// m: message (condition, etc.) -#define PANIC(n,m) do { \ - sprint( b512, "%s (%s @ %d), %d: %s\n", \ - __func__, __FILE__, __LINE__, n, # m ); \ - kpanic( b512 ); \ - } while(0) - -/* -** Assertions are categorized by the "sanity level" being used in this -** compilation; each only triggers a fault if the sanity level is at or -** above a specific value. This allows selective enabling/disabling of -** debugging checks. -** -** The sanity level is set during compilation with the CPP macro -** "SANITY". A sanity level of 0 disables conditional assertions, -** but not the basic assert() version. -*/ - -#ifndef SANITY -// default sanity check level: check everything! -#define SANITY 9999 -#endif - -// Always-active assertions -#define assert(x) if( !(x) ) { PANIC(0,x); } - -// only provide these macros if the sanity check level is positive - -#if SANITY > 0 - -#define assert1(x) if( SANITY >= 1 && !(x) ) { PANIC(1,x); } -#define assert2(x) if( SANITY >= 2 && !(x) ) { PANIC(2,x); } -#define assert3(x) if( SANITY >= 3 && !(x) ) { PANIC(3,x); } -#define assert4(x) if( SANITY >= 4 && !(x) ) { PANIC(4,x); } -// arbitrary sanity level -#define assertN(n,x) if( SANITY >= (n) && !(x) ) { PANIC(n,x); } - -#else - -#define assert1(x) // do nothing -#define assert2(x) // do nothing -#define assert3(x) // do nothing -#define assert4(x) // do nothing -#define assertN(n,x) // do nothing - -#endif /* SANITY > 0 */ - -/* -** Tracing options are enabled by defining one or more of the T_ -** macros described in the Makefile. -** -** To add a tracing option: -** -** 1) Pick a short name for it (e.g., "PCB", "VM", ...) -** 2) At the end of this list, add code like this, with "name" -** replaced by your short name, and "nnnnnnnn" replaced by a -** unique bit that will designate this tracing option: -** -** #ifdef T_name -** #define TRname 0xnnnnnnnn -** #else -** #define TRname 0 -** #endif -** -** Use the next bit position following the one in last list entry. -** 3) Add this to the end of the "TRACE" macro definition: -** -** | TRname -** -** 4) In the list of "TRACING_*" macros, add one for your option -** (using a name that might be more descriptive) in the 'then' clause: -** -** #define TRACING_bettername ((TRACE & TRname) != 0) -** -** 5) Also add a "null" version in the 'else' clause: -** -** #define TRACING_bettername 0 -** -** 6) Maybe add your T_name choice to the Makefile with an explanation -** on the off chance you want anyone else to be able to understand -** what it's used for. :-) -** -** We're making CPP work for its pay with this file. -*/ - -// 2^0 bit -#ifdef T_PCB -#define TRPCB 0x00000001 -#else -#define TRPCB 0 -#endif - -#ifdef T_VM -#define TRVM 0x00000002 -#else -#define TRVM 0 -#endif - -#ifdef T_QUE -#define TRQUEUE 0x00000004 -#else -#define TRQUEUE 0 -#endif - -#ifdef T_SCH -#define TRSCHED 0x00000008 -#else -#define TRSCHED 0 -#endif - -// 2^4 bit -#ifdef T_DSP -#define TRDISP 0x00000010 -#else -#define TRDISP 0 -#endif - -#ifdef T_SCALL -#define TRSYSCALLS 0x00000020 -#else -#define TRSYSCALLS 0 -#endif - -#ifdef T_SRET -#define TRSYSRETS 0x00000040 -#else -#define TRSYSRETS 0 -#endif - -#ifdef T_EXIT -#define TREXIT 0x00000080 -#else -#define TREXIT 0 -#endif - -// 2^8 bit -#ifdef T_INIT -#define TRINIT 0x00000100 -#else -#define TRINIT 0 -#endif - -#ifdef T_KM -#define TRKMEM 0x00000200 -#else -#define TRKMEM 0 -#endif - -#ifdef T_KMFR -#define TRKMEM_F 0x00000400 -#else -#define TRKMEM_F 0 -#endif - -#ifdef T_KMIN -#define TRKMEM_I 0x00000800 -#else -#define TRKMEM_I 0 -#endif - -// 2^12 bit -#ifdef T_FORK -#define TRFORK 0x00001000 -#else -#define TRFORK 0 -#endif - -#ifdef T_EXEC -#define TREXEC 0x00002000 -#else -#define TREXEC 0 -#endif - -#ifdef T_SIO -#define TRSIO_STAT 0x00004000 -#else -#define TRSIO_STAT 0 -#endif - -#ifdef T_SIOR -#define TRSIO_RD 0x00008000 -#else -#define TRSIO_RD 0 -#endif - -// 2^16 bit -#ifdef T_SIOW -#define TRSIO_WR 0x00010000 -#else -#define TRSIO_WR 0 -#endif - -#ifdef T_USER -#define TRUSER 0x00020000 -#else -#define TRUSER 0 -#endif - -#ifdef T_ELF -#define TRELF 0x00040000 -#else -#define TRELF 0 -#endif - -// 13 bits remaining for tracing options -// next available bit: 0x00080000 - -#define TRACE (TRDISP | TREXIT | TRINIT | TRKMEM | TRKMEM_F | TRKMEM_I | TRPCB | TRQUEUE | TRSCHED | TREXEC | TRSIO_RD | TRSIO_STAT | TRSIO_WR | TRFORK | TRVM | TRSYSCALLS | TRSYSRETS | TRUSER | TRELF) - -#if TRACE > 0 - -// compile-time expressions for testing trace options -// usage: #if TRACING_thing -#define TRACING_PCB ((TRACE & TRPCB) != 0) -#define TRACING_VM ((TRACE & TRVM) != 0) -#define TRACING_QUEUE ((TRACE & TRQUEUE) != 0) -#define TRACING_SCHED ((TRACE & TRSCHED) != 0) -#define TRACING_DISPATCH ((TRACE & TRDISPATCH) != 0) -#define TRACING_SYSCALLS ((TRACE & TRSYSCALLS) != 0) -#define TRACING_SYSRETS ((TRACE & TRSYSRETS) != 0) -#define TRACING_EXIT ((TRACE & TREXIT) != 0) -#define TRACING_INIT ((TRACE & TRINIT) != 0) -#define TRACING_KMEM ((TRACE & TRKMEM) != 0) -#define TRACING_KMEM_FREELIST ((TRACE & TRKMEM_F) != 0) -#define TRACING_KMEM_INIT ((TRACE & TRKMEM_I) != 0) -#define TRACING_FORK ((TRACE & TRFORK) != 0) -#define TRACING_EXEC ((TRACE & TREXEC) != 0) -#define TRACING_SIO_STAT ((TRACE & TRSIO_STAT) != 0) -#define TRACING_SIO_ISR ((TRACE & TRSIO_ISR) != 0) -#define TRACING_SIO_RD ((TRACE & TRSIO_RD) != 0) -#define TRACING_SIO_WR ((TRACE & TRSIO_WR) != 0) -#define TRACING_USER ((TRACE & TRUSER) != 0) -#define TRACING_ELF ((TRACE & TRELF) != 0) - -// more generic tests -#define TRACING_SOMETHING (TRACE != 0) - -#else - -// TRACE == 0, so just define these all as "false" - -#define TRACING_PCB 0 -#define TRACING_STACK 0 -#define TRACING_QUEUE 0 -#define TRACING_SCHED 0 -#define TRACING_DISPATCH 0 -#define TRACING_SYSCALLS 0 -#define TRACING_SYSRET 0 -#define TRACING_EXIT 0 -#define TRACING_INIT 0 -#define TRACING_KMEM 0 -#define TRACING_KMEM_FREELIST 0 -#define TRACING_KMEM_INIT 0 -#define TRACING_FORK 0 -#define TRACING_EXEC 0 -#define TRACING_SI_STAT 0 -#define TRACING_SIO_ISR 0 -#define TRACING_SIO_RD 0 -#define TRACING_SIO_WR 0 -#define TRACING_USER 0 -#define TRACING_ELF 0 - -#define TRACING_SOMETHING 0 - -#endif /* TRACE */ - -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/defs.h b/kernel/old/include/defs.h deleted file mode 100644 index 0280c47..0000000 --- a/kernel/old/include/defs.h +++ /dev/null @@ -1,129 +0,0 @@ -/** -** @file defs.h -** -** @author Warren R. Carithers -** -** @brief Common definitions. -** -** This header file defines things which are neede by all -** parts of the system (OS and user levels). -** -** Things which are kernel-specific go in the kdefs.h file; -** things which are user-specific go in the udefs.h file. -** The correct one of these will be automatically included -** at the end of this file. -*/ - -#ifndef DEFS_H_ -#define DEFS_H_ - -/* -** General (C and/or assembly) definitions -** -** This section of the header file contains definitions that can be -** used in either C or assembly-language source code. -*/ - -// NULL pointer value -// -// we define this the traditional way so that -// it's usable from both C and assembly - -#define NULL 0 - -// predefined i/o channels - -#define CHAN_CIO 0 -#define CHAN_SIO 1 - -// maximum allowable number of command-line arguments -#define MAX_ARGS 10 - -// sizes of various things -#define NUM_1KB 0x00000400 // 2^10 -#define NUM_4KB 0x00001000 // 2^12 -#define NUM_1MB 0x00100000 // 2^20 -#define NUM_4MB 0x00400000 // 2^22 -#define NUM_1GB 0x40000000 // 2^30 -#define NUM_2GB 0x80000000 // 2^31 -#define NUM_3GB 0xc0000000 - -#ifndef ASM_SRC - -/* -** Start of C-only definitions -** -** Anything that should not be visible to something other than -** the C compiler should be put here. -*/ - -/* -** System error codes -** -** These can be returned to both system functions -** and to user system calls. -*/ - // success! -#define SUCCESS (0) -# define E_SUCCESS SUCCESS - // generic "something went wrong" -#define E_FAILURE (-1) - // specific failure reasons -#define E_BAD_PARAM (-2) -#define E_BAD_CHAN (-3) -#define E_NO_CHILDREN (-4) -#define E_NO_MEMORY (-5) -#define E_NOT_FOUND (-6) -#define E_NO_PROCS (-7) - -/* -** These error codes are internal to the OS. -*/ -#define E_EMPTY_QUEUE (-100) -#define E_NO_PCBS (-101) -#define E_NO_PTE (-102) -#define E_LOAD_LIMIT (-103) - -// exit status values -#define EXIT_SUCCESS (0) -#define EXIT_FAILURE (-1) -#define EXIT_KILLED (-101) -#define EXIT_BAD_SYSCALL (-102) - -/* -** Process priority values -*/ -enum priority_e { - PRIO_HIGH, PRIO_STD, PRIO_LOW, PRIO_DEFERRED - // sentinel - , N_PRIOS -}; - -// halves of various data sizes - -#define UI16_UPPER 0xff00 -#define UI16_LOWER 0x00ff - -#define UI32_UPPER 0xffff0000 -#define UI32_LOWER 0x0000ffff - -#define UI64_UPPER 0xffffffff00000000LL -#define UI64_LOWER 0x00000000ffffffffLL - -// Simple conversion pseudo-functions usable by everyone - -// convert seconds to ms -#define SEC_TO_MS(n) ((n) * 1000) - -#endif /* !ASM_SRC */ - -/* -** Level-specific definitions -*/ -#ifdef KERNEL_SRC -#include <kdefs.h> -#else -#include <udefs.h> -#endif /* KERNEL_SRC */ - -#endif diff --git a/kernel/old/include/elf.h b/kernel/old/include/elf.h deleted file mode 100644 index a43e5c3..0000000 --- a/kernel/old/include/elf.h +++ /dev/null @@ -1,235 +0,0 @@ -/** -** @file elf.h -** -** @author Warren R. Carithers -** -** @brief ELF format declarations -*/ - -#ifndef ELF_H_ -#define ELF_H_ - -#include <common.h> - -#ifndef ASM_SRC - -/* -** Start of C-only definitions -*/ - -// ELF data types (TIS ELF Spec v1.2, May 1995 -typedef uint32_t e32_a; // 32-bit unsigned address -typedef uint16_t e32_h; // 16-bit unsigned "medium" integer -typedef uint32_t e32_o; // 32-bit unsigned offset -typedef int32_t e32_sw; // 32-bit signed "large" integer -typedef uint32_t e32_w; // 32-bit unsigned "large" integer -typedef uint8_t e32_si; // 8-bit unsigned "small" integer - -// ELF magic number - first four bytes -#define ELF_MAGIC 0x464C457FU // "\x7FELF" in little-endian order -#define EI_NIDENT 16 - -union elfident_u { - uint8_t bytes[EI_NIDENT]; // array of 16 bytes - struct { - uint32_t magic; // magic number - uint8_t class; // file class - uint8_t data; // data encoding - uint8_t version; // file version - uint8_t osabi; // OS ABI identification - uint8_t abivers; // ABI version - uint8_t pad[7]; // padding to 16 bytes - } f; -}; - -// indices for byte fields in the ident array -#define EI_MAGIC 0 -# define EI_MAG0 EI_MAGIC -# define EI_MAG1 1 -# define EI_MAG2 2 -# define EI_MAG3 3 -#define EI_CLASS 4 -#define EI_DATA 5 -#define EI_VERSION 6 -#define EI_OSABI 7 -#define EI_ABIVERSION 8 - -// ELF classes -#define ELF_CLASS_NONE 0 -#define ELF_CLASS_32 1 // 32-bit objects -#define ELF_CLASS_64 2 // 64-bit objects - -// ELF data encoding -#define ELF_DATA_NONE 0 // invalid data encoding -#define ELF_DATA_2LSB 1 // two's complement little-endian -#define ELF_DATA_2MSB 2 // two's complement big-endian - -// ELF versions -#define ELF_VERSION__NONE 0 // invalid version -# define EV_NONE ELF_VERSION_NONE -#define ELF_VERSION__CURRENT 1 // current version -# define EV_CURRENT ELF_VERSION_CURRENT - -// ELF header -// -// field names are from the TIS ELF Spec v1.2, May 1995 -typedef struct elfhdr_s { - union elfident_u e_ident; // file identification - e32_h e_type; // file type - e32_h e_machine; // required architecture - e32_w e_version; // object file version - e32_a e_entry; // entry point (VA) - e32_o e_phoff; // offset to program header table (PHT) - e32_o e_shoff; // offset to section header table (SHT) - e32_w e_flags; // processor-specific flags - e32_h e_ehsize; // ELF header size (bytes) - e32_h e_phentsize; // size of one PHT entry (bytes) - e32_h e_phnum; // number of PHT entries - e32_h e_shentsize; // size of one SHT entry (bytes) - e32_h e_shnum; // number of SHT entries - e32_h e_shstrndx; // SHT index of the sect. name string table -} elfhdr_t; - -#define SZ_ELFHDR sizeof(elfhdr_t) - -// field values -// e_type -#define ET_NONE 0 // no file type -#define ET_REL 1 // relocatable file -#define ET_EXEC 2 // executable file -#define ET_DYN 3 // shared object file -#define ET_CORE 4 // core file -#define ET_LO_OS 0xfe00 // processor-specific -#define ET_HI_OS 0xfeff // processor-specific -#define ET_LO_CP 0xff00 // processor-specific -#define ET_HI_CP 0xffff // processor-specific - -// e_machine -#define EM_NONE 0x00 // no machine type -#define EM_M32 0x01 // AT&T WE 32100 -#define EM_SPARC 0x02 // SUN SPARC -#define EM_386 0x03 // Intel Architecture -#define EM_68K 0x04 // Motorola 68000 -#define EM_88K 0x05 // Motorola 88000 -#define EM_IAMCU 0x06 // Intel MCU -#define EM_860 0x07 // Intel 80860 -#define EM_MIPS 0x08 // MIPS RS3000 Big-Endian -#define EM_S370 0x09 // IBM System/370 -#define EM_MIPS_RS3_LE 0x0a // MIPS RS3000 Big-Endian -#define EM_SPARC32PLLUS 0x12 // Sun "v8plus" -#define EM_PPC 0x14 // IBM PowerPC -#define EM_PPC64 0x15 // IBM PowerPC 64-bit -#define EM_S390 0x16 // IBM System/390 -#define EM_ARM 0x28 // ARM up to V7/AArch32 -#define EM_SPARCV9 0x2b // SPARC V9 64-bit -#define EM_IA_64 0x32 // Intel Itanium (Merced) -#define EM_MIPS_X 0x32 // Stanford MIPS-X -#define EM_X86_64 0x3E // AMD x86-64 (Intel64) -#define EM_PDP11 0x40 // DEC PDP-11 -#define EM_VAX 0x4b // DEC VAX -#define EM_AARCH64 0xb7 // ARM AArch64 -#define EM_Z80 0xec // Zilog Z-80 -#define EM_AMDGPU 0xf0 // AMD GPU -#define EM_RISCV 0xf3 // RISC-V -#define EM_BPF 0xf7 // Berkeley Packet Filter - -// ELF section header -// -// field names are from the TIS ELF Spec v1.2, May 1995 -typedef struct shdr_s { - e32_w sh_name; // section name (index into string table) - e32_w sh_type; // section contents/semantics - e32_w sh_flags; // attribute flag bits - e32_a sh_addr; // 0, or load point of this section in memory - e32_o sh_offset; // byte offset within the file - e32_w sh_size; // section size in bytes - e32_w sh_link; // section header index table link - e32_w sh_info; // "extra information" - e32_w sh_addralign; // required alignment - e32_w sh_entsize; // 0, or size of each entry in the section -} elfsecthdr_t; - -#define SZ_ELFSECTHDR sizeof(elfsecthdr_t) - -// sh_name -#define SHN_UNDEF 0 - -// sh_type -#define SHT_NULL 0x00 -#define SHT_PROGBITS 0x01 -#define SHT_SYMTAB 0x02 -#define SHT_STRTAB 0x03 -#define SHT_RELA 0x04 -#define SHT_HASH 0x05 -#define SHT_DYNAMIC 0x06 -#define SHT_NOTE 0x07 -#define SHT_NOBITS 0x08 -#define SHT_REL 0x09 -#define SHT_SHLIB 0x0a -#define SHT_DYNSYM 0x0b -#define SHT_LO_CP 0x70000000 -#define SHT_HI_CP 0x7fffffff -#define SHT_LO_US 0x80000000 -#define SHT_HI_US 0x8fffffff - -// sh_flags -#define SHF_WRITE 0x001 -#define SHF_ALLOC 0x002 -#define SHF_EXECINSTR 0x004 -#define SHF_MERGE 0x010 -#define SHF_STRINGS 0x020 -#define SHF_INFO_LINK 0x040 -#define SHF_LINK_ORDER 0x080 -#define SHF_OS_NONCON 0x100 -#define SHF_GROUP 0x200 -#define SHF_TLS 0x400 -#define SHF_MASKOS 0x0ff00000 -#define SHF_MASKPROC 0xf0000000 - -// ELF program header -// -// field names are from the TIS ELF Spec v1.2, May 1995 -typedef struct phdr_s { - e32_w p_type; // type of segment - e32_o p_offset; // byte offset in file - e32_a p_va; // load point in memory (virtual address) - e32_a p_pa; // load point in memory (physical address) - e32_w p_filesz; // number of bytes in this file - e32_w p_memsz; // number of bytes in memory - e32_w p_flags; // attribute flag bits - e32_w p_align; // required alignment -} elfproghdr_t; - -#define SZ_ELFPROGHDR sizeof(elfproghdr_t) - -// p_type -#define PT_NULL 0 -#define PT_LOAD 1 -#define PT_DYNAMIC 2 -#define PT_INTERP 3 -#define PT_NOTE 4 -#define PT_SHLIB 5 -#define PT_PHDR 6 -#define PT_TLS 7 -#define PT_LO_OS 0x70000000 -#define PT_HI_OS 0x7fffffff -#define PT_LO_CP 0x70000000 -#define PT_HI_CP 0x7fffffff - -// p_flags -#define PF_E 0x1 -#define PF_W 0x2 -#define PF_R 0x4 -#define PF_MASKPROC 0xf0000000 - -/* -** Globals -*/ - -/* -** Prototypes -*/ - -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/kdefs.h b/kernel/old/include/kdefs.h deleted file mode 100644 index 794516b..0000000 --- a/kernel/old/include/kdefs.h +++ /dev/null @@ -1,152 +0,0 @@ -/** -** @file kdefs.h -** -** @author CSCI-452 class of 20245 -** -** @brief Kernel-only declarations. -*/ - -#ifndef KDEFS_H_ -#define KDEFS_H_ - -// debugging macros -#include <debug.h> - -/* -** General (C and/or assembly) definitions -*/ - -// page sizes -#define SZ_PAGE NUM_4KB -#define SZ_BIGPAGE NUM_4MB - -// kernel stack size (bytes) -#define N_KSTKPAGES 1 -#define SZ_KSTACK (N_KSTKPAGES * SZ_PAGE) - -// user stack size -#define N_USTKPAGES 2 -#define SZ_USTACK (N_USTKPAGES * SZ_PAGE) - -// declarations for modulus checking of (e.g.) sizes and addresses - -#define MOD4_BITS 0x00000003 -#define MOD4_MASK 0xfffffffc -#define MOD4_INC 0x00000004 -#define MOD4_SHIFT 2 - -#define MOD16_BITS 0x0000000f -#define MOD16_MASK 0xfffffff0 -#define MOD16_INC 0x00000010 -#define MOD16_SHIFT 4 - -#define MOD1K_BITS 0x000003ff -#define MOD1K_MASK 0xfffffc00 -#define MOD1K_INC 0x00000400 -#define MOD1K_SHIFT 10 - -#define MOD4K_BITS 0x00000fff -#define MOD4K_MASK 0xfffff000 -#define MOD4K_INC 0x00001000 -#define MOD4K_SHIFT 12 - -#define MOD1M_BITS 0x000fffff -#define MOD1M_MASK 0xfff00000 -#define MOD1M_INC 0x00100000 -#define MOD1M_SHIFT 20 - -#define MOD4M_BITS 0x003fffff -#define MOD4M_MASK 0xffc00000 -#define MOD4M_INC 0x00400000 -#define MOD4M_SHIFT 22 - -#define MOD1G_BITS 0x3fffffff -#define MOD1G_MASK 0xc0000000 -#define MOD1G_INC 0x40000000 -#define MOD1G_SHIFT 30 - -#ifndef ASM_SRC - -/* -** Start of C-only definitions -*/ - -// unit conversion macros -#define B_TO_KB(x) (((uint_t)(x))>>10) -#define B_TO_MB(x) (((uint_t)(x))>>20) -#define B_TO_GB(x) (((uint_t)(x))>>30) - -#define KB_TO_B(x) (((uint_t)(x))<<10) -#define KB_TO_MB(x) (((uint_t)(x))>>10) -#define KB_TO_GB(x) (((uint_t)(x))>>20) - -#define MB_TO_B(x) (((uint_t)(x))<<20) -#define MB_TO_KB(x) (((uint_t)(x))<<10) -#define MB_TO_GB(x) (((uint_t)(x))>>10) - -#define GB_TO_B(x) (((uint_t)(x))<<30) -#define GB_TO_KB(x) (((uint_t)(x))<<20) -#define GB_TO_MB(x) (((uint_t)(x))<<10) - -// potetially useful compiler attributes -#define ATTR_ALIGNED(x) __attribute__((__aligned__(x))) -#define ATTR_PACKED __attribute__((__packed__)) -#define ATTR_UNUSED __attribute__((__unused__)) - -/* -** Utility macros -*/ - -// -// macros to clear data structures -// -// these are usable for clearing single-valued data items (e.g., -// a PCB, etc.) -#define CLEAR(v) memclr( &v, sizeof(v) ) -#define CLEAR_PTR(p) memclr( p, sizeof(*p) ) - -// -// macros for access registers and system call arguments -// - -// REG(pcb,x) -- access a specific register in a process context -#define REG(pcb,x) ((pcb)->context->x) - -// RET(pcb) -- access return value register in a process context -#define RET(pcb) ((pcb)->context->eax) - -// ARG(pcb,n) -- access argument #n from the indicated process -// -// ARG(pcb,0) --> return address -// ARG(pcb,1) --> first parameter -// ARG(pcb,2) --> second parameter -// etc. -// -// ASSUMES THE STANDARD 32-BIT ABI, WITH PARAMETERS PUSHED ONTO THE -// STACK. IF THE PARAMETER PASSING MECHANISM CHANGES, SO MUST THIS! -#define ARG(pcb,n) ( ( (uint32_t *) (((pcb)->context) + 1) ) [(n)] ) - -/* -** Types -*/ - -/* -** Globals -*/ - -// general-purpose character buffer -extern char b256[256]; - -// buffer for use by PANIC() macro -extern char b512[512]; - -// kernel stack -extern uint8_t kstack[SZ_KSTACK]; - -/* -** Prototypes -*/ - -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/klib.h b/kernel/old/include/klib.h deleted file mode 100644 index c1d270c..0000000 --- a/kernel/old/include/klib.h +++ /dev/null @@ -1,57 +0,0 @@ -/* -** @file klib.h -** -** @author Warren R. Carithers -** -** Additional support functions for the kernel. -*/ - -#ifndef KLIB_H_ -#define KLIB_H_ - -#include <common.h> - -#ifndef ASM_SRC - -#include <x86/ops.h> - -/** -** Name: put_char_or_code( ch ) -** -** Description: Prints a character on the console, unless it -** is a non-printing character, in which case its hex code -** is printed -** -** @param ch The character to be printed -*/ -void put_char_or_code( int ch ); - -/** -** Name: backtrace -** -** Perform a simple stack backtrace. Could be augmented to use the -** symbol table to print function/variable names, etc., if so desired. -** -** @param ebp Initial EBP to use -** @param args Number of function argument values to print -*/ -void backtrace( uint32_t *ebp, uint_t args ); - -/** -** Name: kpanic -** -** Kernel-level panic routine -** -** usage: kpanic( msg ) -** -** Prefix routine for panic() - can be expanded to do other things -** (e.g., printing a stack traceback) -** -** @param msg[in] String containing a relevant message to be printed, -** or NULL -*/ -void kpanic( const char *msg ); - -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/kmem.h b/kernel/old/include/kmem.h deleted file mode 100644 index 5a98765..0000000 --- a/kernel/old/include/kmem.h +++ /dev/null @@ -1,138 +0,0 @@ -/** -** @file kmem.h -** -** @author Warren R. Carithers -** @author Kenneth Reek -** @author 4003-506 class of 20013 -** -** @brief Support for dynamic memory allocation within the OS. -** -** This is a basic page allocator. Each allocation request returns -** a pointer to a single 4096-byte page of memory. -** -** The module also supports subddivision of pages into "slices", -** each of which is 1KB (i.e., 1/4 of a page). -*/ - -#ifndef KMEM_H_ -#define KMEM_H_ - -#define KERNEL_SRC - -// standard types etc. -#include <common.h> - -/* -** General (C and/or assembly) definitions -*/ - -// Slab and slice sizes, in bytes - -#define SZ_SLAB SZ_PAGE -#define SZ_SLICE (SZ_SLAB >> 2) - -// memory limits -// -// these determine the range of memory addresses the kmem -// module will manage -// -// we won't map any memory below 1MB or above 1GB -#define KM_LOW_CUTOFF NUM_1MB -#define KM_HIGH_CUTOFF NUM_1GB - -#ifndef ASM_SRC - -/* -** Start of C-only definitions -*/ - -/* -** Types -*/ - -/* -** Globals -*/ - -/* -** Prototypes -*/ - -/** -** Name: km_init -** -** Find what memory is present on the system and -** construct the list of free memory blocks. -** -** Dependencies: -** Must be called before any other init routine that uses -** dynamic storage is called. -*/ -void km_init( void ); - -/** -** Name: km_dump -** -** Dump information about the free lists to the console. By default, -** prints only the list sizes; if 'addrs' is true, also dumps the list -** of page addresses; if 'all' is also true, dumps page addresses and -** slice addresses. -** -** @param addrs Also dump page addresses -** @param both Also dump slice addresses -*/ -void km_dump( bool_t addrs, bool_t both ); - -/* -** Functions that manipulate free memory blocks. -*/ - -/** -** Name: km_page_alloc -** -** Allocate a page of memory from the free list. -** -** @return a pointer to the beginning of the allocated page, -** or NULL if no memory is available -*/ -void *km_page_alloc( void ); - -/** -** Name: km_page_free -** -** Returns a memory block to the list of available blocks, -** combining it with adjacent blocks if they're present. -** -** CRITICAL ASSUMPTION: multi-page blocks will be freed one page -** at a time! -** -** @param[in] block Pointer to the page to be returned to the free list -*/ -void km_page_free( void *block ); - -/** -** Name: km_slice_alloc -** -** Dynamically allocates a slice (1/4 of a page). If no -** memory is available, we return NULL (unless ALLOC_FAIL_PANIC -** was defined, in which case we panic). -** -** @return a pointer to the allocated slice -*/ -void *km_slice_alloc( void ); - -/** -** Name: km_slice_free -** -** Returns a slice to the list of available slices. -** -** We make no attempt to merge slices, as they are independent -** blocks of memory (unlike pages). -** -** @param[in] block Pointer to the slice (1/4 page) to be freed -*/ -void km_slice_free( void *block ); - -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/lib.h b/kernel/old/include/lib.h deleted file mode 100644 index bde0554..0000000 --- a/kernel/old/include/lib.h +++ /dev/null @@ -1,314 +0,0 @@ -/** -** @file lib.h -** -** @author Numerous CSCI-452 classes -** -** @brief C declarations of common library functions -** -** These are callable from either kernel or user code. Care should be taken -** that user code is linked against these separately from kernel code, to -** ensure separation of the address spaces. -*/ - -#ifndef LIB_H_ -#define LIB_H_ - -#ifndef ASM_SRC - -#include <common.h> - -/* -********************************************** -** MEMORY MANIPULATION FUNCTIONS -********************************************** -*/ - -/** -** blkmov(dst,src,len) -** -** Copy a word-aligned block from src to dst. Deals with overlapping -** buffers. -** -** If the buffer addresses aren't word-aligned or the length is not a -** multiple of four, calls memmove(). -** -** @param dst Destination buffer -** @param src Source buffer -** @param len Buffer size (in bytes) -*/ -void blkmov( void *dst, const void *src, register uint32_t len ); - -/** -** memset(buf,len,value) -** -** initialize all bytes of a block of memory to a specific value -** -** @param buf The buffer to initialize -** @param len Buffer size (in bytes) -** @param value Initialization value -*/ -void memset( void *buf, register uint32_t len, register uint32_t value ); - -/** -** memclr(buf,len) -** -** Initialize all bytes of a block of memory to zero -** -** @param buf The buffer to initialize -** @param len Buffer size (in bytes) -*/ -void memclr( void *buf, register uint32_t len ); - -/** -** memcpy(dst,src,len) -** -** Copy a block from one place to another -** -** May not correctly deal with overlapping buffers -** -** @param dst Destination buffer -** @param src Source buffer -** @param len Buffer size (in bytes) -*/ -void memcpy( void *dst, register const void *src, register uint32_t len ); - -/** -** memmove(dst,src,len) -** -** Copy a block from one place to another. Deals with overlapping -** buffers -** -** @param dst Destination buffer -** @param src Source buffer -** @param len Buffer size (in bytes) -*/ -void memmove( void *dst, register const void *src, register uint32_t len ); - -/* -********************************************** -** STRING MANIPULATION FUNCTIONS -********************************************** -*/ - -/** -** str2int(str,base) - convert a string to a number in the specified base -** -** @param str The string to examine -** @param base The radix to use in the conversion -** -** @return The converted integer -*/ -int str2int( register const char *str, register int base ); - -/** -** strlen(str) - return length of a NUL-terminated string -** -** @param str The string to examine -** -** @return The length of the string, or 0 -*/ -uint32_t strlen( register const char *str ); - -/** -** strcmp(s1,s2) - compare two NUL-terminated strings -** -** @param s1 The first source string -** @param s2 The second source string -** -** @return negative if s1 < s2, zero if equal, and positive if s1 > s2 -*/ -int strcmp( register const char *s1, register const char *s2 ); - -/** -** strcpy(dst,src) - copy a NUL-terminated string -** -** @param dst The destination buffer -** @param src The source buffer -** -** @return The dst parameter -** -** NOTE: assumes dst is large enough to hold the copied string -*/ -char *strcpy( register char *dst, register const char *src ); - -/** -** strcat(dst,src) - append one string to another -** -** @param dst The destination buffer -** @param src The source buffer -** -** @return The dst parameter -** -** NOTE: assumes dst is large enough to hold the resulting string -*/ -char *strcat( register char *dst, register const char *src ); - -/** -** pad(dst,extra,padchar) - generate a padding string -** -** @param dst Pointer to where the padding should begin -** @param extra How many padding bytes to add -** @param padchar What character to pad with -** -** @return Pointer to the first byte after the padding -** -** NOTE: does NOT NUL-terminate the buffer -*/ -char *pad( char *dst, int extra, int padchar ); - -/** -** padstr(dst,str,len,width,leftadjust,padchar - add padding characters -** to a string -** -** @param dst The destination buffer -** @param str The string to be padded -** @param len The string length, or -1 -** @param width The desired final length of the string -** @param leftadjust Should the string be left-justified? -** @param padchar What character to pad with -** -** @return Pointer to the first byte after the padded string -** -** NOTE: does NOT NUL-terminate the buffer -*/ -char *padstr( char *dst, char *str, int len, int width, - int leftadjust, int padchar ); - -/** -** sprint(dst,fmt,...) - formatted output into a string buffer -** -** @param dst The string buffer -** @param fmt Format string -** -** The format string parameter is followed by zero or more additional -** parameters which are interpreted according to the format string. -** -** NOTE: assumes the buffer is large enough to hold the result string -** -** NOTE: relies heavily on the x86 parameter passing convention -** (parameters are pushed onto the stack in reverse order as -** 32-bit values). -*/ -void sprint( char *dst, char *fmt, ... ); - -/* -********************************************** -** CONVERSION FUNCTIONS -********************************************** -*/ - -/** -** cvtuns0(buf,value) - local support routine for cvtuns() -** -** Convert a 32-bit unsigned value into a NUL-terminated character string -** -** @param buf Result buffer -** @param value Value to be converted -** -** @return Pointer to the first unused byte in the buffer -** -** NOTE: assumes buf is large enough to hold the resulting string -*/ -char *cvtuns0( char *buf, uint32_t value ); - -/** -** cvtuns(buf,value) -** -** Convert a 32-bit unsigned value into a NUL-terminated character string -** -** @param buf Result buffer -** @param value Value to be converted -** -** @return Length of the resulting buffer -** -** NOTE: assumes buf is large enough to hold the resulting string -*/ -int cvtuns( char *buf, uint32_t value ); - -/** -** cvtdec0(buf,value) - local support routine for cvtdec() -** -** convert a 32-bit unsigned integer into a NUL-terminated character string -** -** @param buf Destination buffer -** @param value Value to convert -** -** @return The number of characters placed into the buffer -** (not including the NUL) -** -** NOTE: assumes buf is large enough to hold the resulting string -*/ -char *cvtdec0( char *buf, int value ); - -/** -** cvtdec(buf,value) -** -** convert a 32-bit signed value into a NUL-terminated character string -** -** @param buf Destination buffer -** @param value Value to convert -** -** @return The number of characters placed into the buffer -** (not including the NUL) -** -** NOTE: assumes buf is large enough to hold the resulting string -*/ -int cvtdec( char *buf, int32_t value ); - -/** -** cvthex(buf,value) -** -** convert a 32-bit unsigned value into a mininal-length (up to -** 8-character) NUL-terminated character string -** -** @param buf Destination buffer -** @param value Value to convert -** -** @return The number of characters placed into the buffer -** (not including the NUL) -** -** NOTE: assumes buf is large enough to hold the resulting string -*/ -int cvthex( char *buf, uint32_t value ); - -/** -** cvtoct(buf,value) -** -** convert a 32-bit unsigned value into a mininal-length (up to -** 11-character) NUL-terminated character string -** -** @param buf Destination buffer -** @param value Value to convert -** -** @return The number of characters placed into the buffer -** (not including the NUL) -** -** NOTE: assumes buf is large enough to hold the resulting string -*/ -int cvtoct( char *buf, uint32_t value ); - -/** -** bound(min,value,max) -** -** This function confines an argument within specified bounds. -** -** @param min Lower bound -** @param value Value to be constrained -** @param max Upper bound -** -** @return The constrained value -*/ -uint32_t bound( uint32_t min, uint32_t value, uint32_t max ); - -#endif /* !ASM_SRC */ - -/* -** Finally, pull in the level-specific library headers -*/ -#ifdef KERNEL_SRC -#include <klib.h> -#else -#include <ulib.h> -#endif /* KERNEL_SRC */ - -#endif diff --git a/kernel/old/include/list.h b/kernel/old/include/list.h deleted file mode 100644 index 28c2377..0000000 --- a/kernel/old/include/list.h +++ /dev/null @@ -1,68 +0,0 @@ -/** -** @file list.h -** -** @author Warren R. Carithers -** -** @brief Support for a basic linked list data type. -** -** This module provides a very basic linked list data structure. -** A list can contain anything that has a pointer field in the first -** four bytes; these routines assume those bytes contain a pointer to -** the following entry in the list, whatever that may be. -*/ - -#ifndef LIST_H_ -#define LIST_H_ - -#define KERNEL_SRC - -// standard types etc. -#include <common.h> - -/* -** General (C and/or assembly) definitions -*/ - -#ifndef ASM_SRC - -/* -** Start of C-only definitions -*/ - -/* -** Data types -*/ - -// The list structure -typedef struct list_s { - struct list_s *next; // link to the successor -} list_t; - -/* -** Prototypes -*/ - -/** -** Name: list_add -** -** Add the supplied data to the beginning of the specified list. -** -** @param[in,out] list The address of a list_t variable -** @param[in] data The data to prepend to the list -*/ -void list_add( list_t *list, void *data ); - -/** -** Name: list_remove -** -** Remove the first entry from a linked list. -** -** @param[in,out] list The address of a list_t variable -** -** @return a pointer to the removed data, or NULL if the list was empty -*/ -void *list_remove( list_t *list ); - -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/params.h b/kernel/old/include/params.h deleted file mode 100644 index 52eb81d..0000000 --- a/kernel/old/include/params.h +++ /dev/null @@ -1,31 +0,0 @@ -/** -** @file params.h -** -** @author CSCI-452 class of 20245 -** -** @brief System configuration settings -** -** This header file contains many of the "easily tunable" system -** settings, such as clock rate, number of simultaneous user -** processes, etc. This provides a sort of "one-stop shop" for -** things that might be tweaked frequently. -*/ - -#ifndef PARAMS_H_ -#define PARAMS_H_ - -/* -** General (C and/or assembly) definitions -*/ - -// Upper bound on the number of simultaneous user-level -// processes in the system (completely arbitrary) - -#define N_PROCS 25 - -// Clock frequency (Hz) - -#define CLOCK_FREQ 1000 -#define TICKS_PER_MS 1 - -#endif diff --git a/kernel/old/include/procs.h b/kernel/old/include/procs.h deleted file mode 100644 index 9db4ac8..0000000 --- a/kernel/old/include/procs.h +++ /dev/null @@ -1,452 +0,0 @@ -/* -** @file procs.h -** -** @author CSCI-452 class of 20245 -** -** @brief Process-related declarations -*/ - -#ifndef PROCS_H_ -#define PROCS_H_ - -#include <common.h> - -/* -** General (C and/or assembly) definitions -*/ - -#ifndef ASM_SRC - -/* -** Start of C-only definitions -*/ - -/* -** Types -*/ - -/* -** Process states -*/ -enum state_e { - // pre-viable - STATE_UNUSED = 0, STATE_NEW, - // runnable - STATE_READY, STATE_RUNNING, - // runnable, but waiting for some event - STATE_SLEEPING, STATE_BLOCKED, STATE_WAITING, - // no longer runnable - STATE_KILLED, STATE_ZOMBIE - // sentinel value - , N_STATES -}; - -// these may be handy for checking general conditions of processes -// they depend on the order of the state names in the enum! -#define FIRST_VIABLE STATE_READY -#define FIRST_BLOCKED STATE_SLEEPING -#define LAST_VIABLE STATE_WAITING - -/* -** Process priorities are defined in <defs.h> -*/ - -/* -** Quantum lengths - values are number of clock ticks -*/ -enum quantum_e { - QUANTUM_SHORT = 1, - QUANTUM_STANDARD = 3, - QUANTUM_LONG = 5 -}; - -/* -** PID-related definitions -*/ -#define PID_INIT 1 -#define FIRST_USER_PID 2 - -/* -** Process context structure -** -** NOTE: the order of data members here depends on the -** register save code in isr_stubs.S!!!! -** -** This will be at the top of the user stack when we enter -** an ISR. In the case of a system call, it will be followed -** by the return address and the system call parameters. -*/ - -typedef struct context_s { - uint32_t ss; // pushed by isr_save - uint32_t gs; - uint32_t fs; - uint32_t es; - uint32_t ds; - uint32_t edi; - uint32_t esi; - uint32_t ebp; - uint32_t esp; - uint32_t ebx; - uint32_t edx; - uint32_t ecx; - uint32_t eax; - uint32_t vector; - uint32_t code; // pushed by isr_save or the hardware - uint32_t eip; // pushed by the hardware - uint32_t cs; - uint32_t eflags; -} context_t; - -#define SZ_CONTEXT sizeof(context_t) - -/* -** program section information for user processes -*/ - -typedef struct section_s { - uint_t length; // length, in some units - uint_t addr; // location, in some units -} section_t; - -// note: these correspond to the PT_LOAD sections found in -// an ELF file, not necessarily to text/data/bss -#define SECT_L1 0 -#define SECT_L2 1 -#define SECT_L3 2 -#define SECT_STACK 3 - -// total number of section table entries in our PCB -#define N_SECTS 4 -// number of those that can be loaded from an ELF module -#define N_LOADABLE 3 - -/* -** The process control block -** -** Fields are ordered by size to avoid padding -** -** Currently, this is 72 bytes long. It could be reduced to 64 (2^6) -** bytes by making the last four fields uint16_t types; that would -** divide nicely into 1024 bytes, giving 16 PCBs per 1/4 page of memory. -*/ - -typedef struct pcb_s { - - // four-byte fields - // start with these four bytes, for easy access in assembly - context_t *context; // pointer to context save area on stack - - // VM information - pde_t *pdir; // page directory for this process - section_t sects[N_SECTS]; // per-section memory information - - // queue linkage - struct pcb_s *next; // next PCB in queue - - // process state information - struct pcb_s *parent; // pointer to PCB of our parent process - uint32_t wakeup; // wakeup time, for sleeping processes - int32_t exit_status; // termination status, for parent's use - - // these things may not need to be four bytes - uint_t pid; // PID of this process - enum state_e state; // process' current state - enum priority_e priority; // process priority level - uint_t ticks; // remaining ticks in this time slice - -} pcb_t; - -#define SZ_PCB sizeof(pcb_t) - -/* -** PCB queue structure (opaque to the rest of the kernel) -*/ -typedef struct pcb_queue_s *pcb_queue_t; - -/* -** Queue ordering methods -*/ -enum pcb_queue_order_e { - O_FIFO, O_PRIO, O_PID, O_WAKEUP - // sentinel - , N_ORDERINGS -}; -#define O_FIRST_STYLE O_FIFO -#define O_LAST_STYLE O_WAKEUP - -/* -** Globals -*/ - -// public-facing queue handles -extern pcb_queue_t pcb_freelist; -extern pcb_queue_t ready; -extern pcb_queue_t waiting; -extern pcb_queue_t sleeping; -extern pcb_queue_t zombie; -extern pcb_queue_t sioread; - -// pointer to the currently-running process -extern pcb_t *current; - -// the process table -extern pcb_t ptable[N_PROCS]; - -// next available PID -extern uint_t next_pid; - -// pointer to the PCB for the 'init' process -extern pcb_t *init_pcb; - -// table of state name strings -extern const char *state_str[N_STATES]; - -// table of priority name strings -extern const char *prio_str[N_PRIOS]; - -// table of queue ordering name strings -extern const char *ord_str[N_ORDERINGS]; - -/* -** Prototypes -*/ - -/** -** Name: pcb_init -** -** Initialization for the Process module. -*/ -void pcb_init( void ); - -/** -** Name: pcb_alloc -** -** Allocate a PCB from the list of free PCBs. -** -** @param pcb Pointer to a pcb_t * where the PCB pointer will be returned. -** -** @return status of the allocation attempt -*/ -int pcb_alloc( pcb_t **pcb ); - -/** -** Name: pcb_free -** -** Return a PCB to the list of free PCBs. -** -** @param pcb Pointer to the PCB to be deallocated. -*/ -void pcb_free( pcb_t *pcb ); - -/** -** Name: pcb_zombify -** -** Turn the indicated process into a Zombie. This function -** does most of the real work for exit() and kill() calls. -** Is also called from the scheduler and dispatcher. -** -** @param pcb Pointer to the newly-undead PCB -*/ -void pcb_zombify( register pcb_t *victim ); - -/** -** Name: pcb_cleanup -** -** Reclaim a process' data structures -** -** @param pcb The PCB to reclaim -*/ -void pcb_cleanup( pcb_t *pcb ); - -/** -** Name: pcb_find_pid -** -** Locate the PCB for the process with the specified PID -** -** @param pid The PID to be located -** -** @return Pointer to the PCB, or NULL -*/ -pcb_t *pcb_find_pid( uint_t pid ); - -/** -** Name: pcb_find_ppid -** -** Locate the PCB for the process with the specified parent -** -** @param pid The PID to be located -** -** @return Pointer to the PCB, or NULL -*/ -pcb_t *pcb_find_ppid( uint_t pid ); - -/** -** Name: pcb_queue_reset -** -** Initialize a PCB queue. -** -** @param queue[out] The queue to be initialized -** @param order[in] The desired ordering for the queue -** -** @return status of the init request -*/ -int pcb_queue_reset( pcb_queue_t queue, enum pcb_queue_order_e style ); - -/** -** Name: pcb_queue_empty -** -** Determine whether a queue is empty. Essentially just a wrapper -** for the PCB_QUEUE_EMPTY() macro, for use outside this module. -** -** @param[in] queue The queue to check -** -** @return true if the queue is empty, else false -*/ -bool_t pcb_queue_empty( pcb_queue_t queue ); - -/** -** Name: pcb_queue_length -** -** Return the count of elements in the specified queue. -** -** @param[in] queue The queue to check -** -** @return the count (0 if the queue is empty) -*/ -uint_t pcb_queue_length( const pcb_queue_t queue ); - -/** -** Name: pcb_queue_insert -** -** Inserts a PCB into the indicated queue. -** -** @param queue[in,out] The queue to be used -** @param pcb[in] The PCB to be inserted -** -** @return status of the insertion request -*/ -int pcb_queue_insert( pcb_queue_t queue, pcb_t *pcb ); - -/** -** Name: pcb_queue_peek -** -** Return the first PCB from the indicated queue, but don't -** remove it from the queue -** -** @param queue[in] The queue to be used -** -** @return the PCB pointer, or NULL if the queue is empty -*/ -pcb_t *pcb_queue_peek( const pcb_queue_t queue ); - -/** -** Name: pcb_queue_remove -** -** Remove the first PCB from the indicated queue. -** -** @param queue[in,out] The queue to be used -** @param pcb[out] Pointer to where the PCB pointer will be saved -** -** @return status of the removal request -*/ -int pcb_queue_remove( pcb_queue_t queue, pcb_t **pcb ); - -/** -** Name: pcb_queue_remove_this -** -** Remove the specified PCB from the indicated queue. -** -** @param queue[in,out] The queue to be used -** @param pcb[in] Pointer to the PCB to be removed -** -** @return status of the removal request -*/ -int pcb_queue_remove_this( pcb_queue_t queue, pcb_t *pcb ); - -/* -** Scheduler routines -*/ - -/** -** schedule(pcb) -** -** Schedule the supplied process -** -** @param pcb Pointer to the PCB of the process to be scheduled -*/ -void schedule( pcb_t *pcb ); - -/** -** dispatch() -** -** Select the next process to receive the CPU -*/ -void dispatch( void ); - -/* -** Debugging/tracing routines -*/ - -/** -** Name: ctx_dump -** -** Dumps the contents of this process context to the console -** -** @param msg[in] An optional message to print before the dump -** @param c[in] The context to dump out -*/ -void ctx_dump( const char *msg, register context_t *c ); - -/** -** Name: ctx_dump_all -** -** dump the process context for all active processes -** -** @param msg[in] Optional message to print -*/ -void ctx_dump_all( const char *msg ); - -/** -** Name: pcb_dump -** -** Dumps the contents of this PCB to the console -** -** @param msg[in] An optional message to print before the dump -** @param p[in] The PCB to dump -** @param all[in] Dump all the contents? -*/ -void pcb_dump( const char *msg, register pcb_t *p, bool_t all ); - -/** -** Name: pcb_queue_dump -** -** Dump the contents of the specified queue to the console -** -** @param msg[in] An optional message to print before the dump -** @param queue[in] The queue to dump -** @param contents[in] Also dump (some) contents? -*/ -void pcb_queue_dump( const char *msg, pcb_queue_t queue, bool_t contents ); - -/** -** Name: ptable_dump -** -** dump the contents of the "active processes" table -** -** @param msg[in] Optional message to print -** @param all[in] Dump all or only part of the relevant data -*/ -void ptable_dump( const char *msg, bool_t all ); - -/** -** Name: ptable_dump_counts -** -** Prints basic information about the process table (number of -** entries, number with each process state, etc.). -*/ -void ptable_dump_counts( void ); - -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/sio.h b/kernel/old/include/sio.h deleted file mode 100644 index dca80ed..0000000 --- a/kernel/old/include/sio.h +++ /dev/null @@ -1,168 +0,0 @@ -/** -** @file sio.h -** -** @author Warren R. Carithers -** -** @brief SIO definitions -*/ - -#ifndef SIO_H_ -#define SIO_H_ - -// compatibility definitions -#include <compat.h> - -/* -** General (C and/or assembly) definitions -*/ - -// sio interrupt settings - -#define SIO_TX 0x01 -#define SIO_RX 0x02 -#define SIO_BOTH (SIO_TX | SIO_RX) - -#ifndef ASM_SRC - -/* -** Start of C-only definitions -*/ - -#include <common.h> - -#include <procs.h> - -/* -** PUBLIC GLOBAL VARIABLES -*/ - -// queue for read-blocked processes -extern QTYPE QNAME; - -/* -** PUBLIC FUNCTIONS -*/ - -/** -** sio_init() -** -** Initialize the UART chip. -*/ -void sio_init( void ); - -/** -** sio_enable() -** -** Enable SIO interrupts -** -** usage: uint8_t old = sio_enable( uint8_t which ) -** -** @param which Bit mask indicating which interrupt(s) to enable -** -** @return the prior IER setting -*/ -uint8_t sio_enable( uint8_t which ); - -/** -** sio_disable() -** -** Disable SIO interrupts -** -** usage: uint8_t old = sio_disable( uint8_t which ) -** -** @param which Bit mask indicating which interrupt(s) to disable -** -** @return the prior IER setting -*/ -uint8_t sio_disable( uint8_t which ); - -/** -** sio_inq_length() -** -** Get the input queue length -** -** usage: int num = sio_inq_length() -** -** @return the count of characters still in the input queue -*/ -int sio_inq_length( void ); - -/** -** sio_readc() -** -** Get the next input character -** -** usage: int ch = sio_readc() -** -** @return the next character, or -1 if no character is available -*/ -int sio_readc( void ); - -/** -** sio_read() -** -** Read the entire input buffer into a user buffer of a specified size -** -** usage: int num = sio_read( char *buffer, int length ) -** -** @param buf The destination buffer -** @param length Length of the buffer -** -** @return the number of bytes copied, or 0 if no characters were available -*/ -int sio_read( char *buffer, int length ); - -/** -** sio_writec( ch ) -** -** Write a character to the serial output -** -** usage: sio_writec( int ch ) -** -** @param ch Character to be written (in the low-order 8 bits) -*/ -void sio_writec( int ch ); - -/** -** sio_write( ch ) -** -** Write a buffer of characters to the serial output -** -** usage: int num = sio_write( const char *buffer, int length ) -** -** @param buffer Buffer containing characters to write -** @param length Number of characters to write -** -** @return the number of characters copied into the SIO output buffer -*/ -int sio_write( const char *buffer, int length ); - -/** -** sio_puts( buf ) -** -** Write a NUL-terminated buffer of characters to the serial output -** -** usage: n = sio_puts( const char *buffer ); -** -** @param buffer The buffer containing a NUL-terminated string -** -** @return the count of bytes transferred -*/ -int sio_puts( const char *buffer ); - -/** -** sio_dump( full ) -** -** Dump the contents of the SIO buffers to the console -** -** usage: sio_dump(true) or sio_dump(false) -** -** @param full Boolean indicating whether or not a "full" dump -** is being requested (which includes the contents -** of the queues) -*/ -void sio_dump( bool_t full ); - -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/support.h b/kernel/old/include/support.h deleted file mode 100644 index bdc5dc6..0000000 --- a/kernel/old/include/support.h +++ /dev/null @@ -1,87 +0,0 @@ -/** -** SCCS ID: @(#)support.h 2.3 1/22/25 -** -** @file support.h -** -** @author K. Reek -** @author Warren R. Carithers -** -** Declarations for functions provided in support.c, and -** some hardware characteristics needed in the initialization. -** -*/ - -#ifndef SUPPORT_H -#define SUPPORT_H - -/* -** Delay values -** -** Notes: The parameter to the delay() function is ambiguous; it -** purports to indicate a delay length, but that isn't really tied -** to any real-world time measurement. -** -** On the original systems we used (dual 500MHz Intel P3 CPUs), each -** "unit" was approximately one tenth of a second, so delay(10) would -** delay for about one second. -** -** On the current machines (Intel Core i5-7500), delay(100) is about -** 2.5 seconds, so each "unit" is roughly 0.025 seconds. -** -** Ultimately, just remember that THESE VALUES ARE APPROXIMATE AT BEST. -*/ -#define DELAY_1_SEC 40 -#define DELAY_1_25_SEC 50 -#define DELAY_2_SEC 80 -#define DELAY_2_5_SEC 100 -#define DELAY_3_SEC 120 -#define DELAY_5_SEC 200 -#define DELAY_7_SEC 280 -#define DELAY_10_SEC 400 - -#ifndef ASM_SRC -/** -** panic -** -** Called when we find an unrecoverable error, this routine disables -** interrupts, prints a description of the error and then goes into a -** hard loop to prevent any further processing. -** -** @param reason NUL-terminated message to be printed. -*/ -void panic( char *reason ); - -/** -** init_interrupts -** -** (Re)initilizes the interrupt system. This includes initializing the -** IDT and the PIC. It is up to the user to enable processor interrupts -** when they're ready. -*/ -void init_interrupts( void ); - -/* -** install_isr -** -** Installs a second-level handler for a specific interrupt. Returns the -** previously-installed handler for reinstallation (if desired). -** -** @param vector the interrupt vector number -** @param handler the second-stage ISR function to be called by the stub -** -** @return a pointer to the previously-registered ISR -*/ -void (*install_isr( int vector, - void ( *handler )(int,int) ) )( int, int ); - -/* -** Name: delay -** -** See the comment above about the relative accuracy of the 'length' -** parameter. -*/ -void delay( int length ); - -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/syscalls.h b/kernel/old/include/syscalls.h deleted file mode 100644 index e66f6c0..0000000 --- a/kernel/old/include/syscalls.h +++ /dev/null @@ -1,80 +0,0 @@ -/** -** @file syscalls.h -** -** @author CSCI-452 class of 20245 -** -** @brief System call declarations -*/ - -#ifndef SYSCALLS_H_ -#define SYSCALLS_H_ - -#include <common.h> - -/* -** General (C and/or assembly) definitions -*/ - -/* -** system call codes -** -** these are used in the user-level C library stub functions, -** and are defined here as CPP macros instead of as an enum -** so that they can be used from assembly -*/ - -#define SYS_exit 0 -#define SYS_waitpid 1 -#define SYS_fork 2 -#define SYS_exec 3 -#define SYS_read 4 -#define SYS_write 5 -#define SYS_getpid 6 -#define SYS_getppid 7 -#define SYS_gettime 8 -#define SYS_getprio 9 -#define SYS_setprio 10 -#define SYS_kill 11 -#define SYS_sleep 12 - -// UPDATE THIS DEFINITION IF MORE SYSCALLS ARE ADDED! -#define N_SYSCALLS 13 - -// dummy system call code for testing our ISR -#define SYS_bogus 0xbad - -// interrupt vector entry for system calls -#define VEC_SYSCALL 0x80 - -#ifndef ASM_SRC - -/* -** Start of C-only definitions -*/ - -/* -** Types -*/ - -/* -** Globals -*/ - -/* -** Prototypes -*/ - -#ifdef KERNEL_SRC - -/** -** Name: sys_init -** -** Syscall module initialization routine -*/ -void sys_init( void ); - -#endif /* KERNEL_SRC */ - -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/types.h b/kernel/old/include/types.h deleted file mode 100644 index 2f934f1..0000000 --- a/kernel/old/include/types.h +++ /dev/null @@ -1,58 +0,0 @@ -/** -** @file types.h -** -** @author Warren R. Carithers -** -** @brief Common type declarations. -** -** This header file contains type declarations used throughout -** the kernel and user code. -*/ - -#ifndef TYPES_H_ -#define TYPES_H_ - -#ifndef ASM_SRC - -/* -** Start of C-only definitions -** -** Anything that should not be visible to something other than -** the C compiler should be put here. -*/ - -/* -** Types -*/ - -// standard integer sized types -typedef char int8_t; -typedef unsigned char uint8_t; -typedef short int16_t; -typedef unsigned short uint16_t; -typedef int int32_t; -typedef unsigned int uint32_t; -typedef long long int int64_t; -typedef unsigned long long int uint64_t; - -// other integer types -typedef unsigned char uchar_t; -typedef unsigned int uint_t; -typedef unsigned long int ulong_t; - -// Boolean values -typedef uint8_t bool_t; - -#define true 1 -#define false 0 - -#ifdef KERNEL_SRC -// we define these here instead of in vm.h in order to get around a -// nasty chick/egg dependency between procs.h and vm.h -typedef uint32_t pde_t; // page directory entry -typedef uint32_t pte_t; // page table entry -#endif /* KERNEL_SRC */ - -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/udefs.h b/kernel/old/include/udefs.h deleted file mode 100644 index 50b6952..0000000 --- a/kernel/old/include/udefs.h +++ /dev/null @@ -1,113 +0,0 @@ -/** -** @file udefs.h -** -** @author CSCI-452 class of 20245 -** -** @brief "Userland" configuration information -*/ - -#ifndef UDEFS_H_ -#define UDEFS_H_ - -#include <common.h> - -/* -** General (C and/or assembly) definitions -** -** This section of the header file contains definitions that can be -** used in either C or assembly-language source code. -*/ - -// delay loop counts - -#define DELAY_LONG 100000000 -#define DELAY_MED 4500000 -#define DELAY_SHORT 2500000 - -#define DELAY_STD DELAY_SHORT - -#ifndef ASM_SRC - -/* -** Start of C-only definitions -*/ - -// convenience macros - -// a delay loop - kind of ugly, but it works - -#define DELAY(n) do { \ - for(int _dlc = 0; _dlc < (DELAY_##n); ++_dlc) continue; \ - } while(0) - -/* -** We need the list of program IDs so that we can request -** their execution -*/ - -#include <userids.h> - -/* -** All user main() functions have the following prototype: -** -** int name( int argc, char *argv[] ); -** -** To simplify declaring them, we define a macro that expands into -** that header. This can be used both in the implementation (followed -** by the function body) and in places where we just need the prototype -** (following it with a semicolon). -*/ - -#define USERMAIN(f) int f( int argc, char *argv[] ) - -/* -** User process controls. -** -** To enable a specific test, define the symbol SPAWN_name here, and -** guard the places in other code that use or refer to that test. For -** example, test 'A' is enabled by definining SPAWN_A here, and all -** places that refer to test 'A' are guarded with: -** -** #ifdef SPAWN_A -** ... conditionally-compiled code -** #endif -** -** Generally, most of these will exit with a status of 0. If a process -** returns from its main function when it shouldn't (e.g., if it had -** called exit() but continued to run), it will usually return a status -** of ?. -*/ - -/* -** The standard set of test programs, start by the shell (which is started -** automatically from the initial user process) -** -** There is no user 'O' program, and programs 'W' through 'Z' are spawned -** from other processes and are never spawned directly. -*/ - -#define SPAWN_A -#define SPAWN_B -#define SPAWN_C -#define SPAWN_D -#define SPAWN_E -#define SPAWN_F -#define SPAWN_G -#define SPAWN_H -#define SPAWN_I -#define SPAWN_J -#define SPAWN_K -#define SPAWN_L -#define SPAWN_M -#define SPAWN_N -#define SPAWN_P -#define SPAWN_Q -#define SPAWN_R -#define SPAWN_S -#define SPAWN_T -#define SPAWN_U -#define SPAWN_V - -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/ulib.h b/kernel/old/include/ulib.h deleted file mode 100644 index d254d6a..0000000 --- a/kernel/old/include/ulib.h +++ /dev/null @@ -1,315 +0,0 @@ -/** -** @file ulib.h -** -** @author CSCI-452 class of 20245 -** -** @brief Declarations for user-level library functions -** -** This module implements a simple collection of support functions -** similar to the standard C library. -*/ - -#ifndef ULIB_H_ -#define ULIB_H_ - -#include <common.h> - -/* -** General (C and/or assembly) definitions -*/ - -#ifndef ASM_SRC - -/* -** Start of C-only definitions -*/ - -/* -** Types -*/ - -/* -** Globals -*/ - -/* -** Prototypes -*/ - -/* -************************************************* -** SYSTEM CALLS ********************************* -************************************************* -*/ - -/** -** exit - terminate the calling process -** -** usage: exit(status); -** -** @param status Termination status of this process -** -** Does not return. -*/ -void exit( int32_t status ); - -/** -** waitpid - wait for a child process to terminate -** -** usage: pid = waitpid(pid,&status); -** -** @param pid PID of the desired child, or 0 for any child -** @param status Pointer to int32_t into which the child's status is placed, -** or NULL -** -** @return The PID of the terminated child, or an error code -** -** If there are no children in the system, returns an error code (*status -** is unchanged). -** -** If there are one or more children in the system and at least one has -** terminated but hasn't yet been cleaned up, cleans up that process and -** returns its information; otherwise, blocks until a child terminates. -*/ -int waitpid( uint_t pid, int32_t *status ); - -/** -** fork - create a duplicate of the calling process -** -** usage: pid = fork(); -** -** @return parent - the pid of the new child, or an error code -** child - 0 -*/ -int fork( void ); - -/** -** exec - replace the memory image of the calling process -** -** usage: exec( what, args ) -** -** @param what program table index of the program to exec -** @param args the command-line argument vector -** -** Does not return if it succeeds; if it returns, something has -** gone wrong. -*/ -void exec( uint_t what, char **args ); - -/** -** read - read into a buffer from a stream -** -** usage: n = read(channel,buf,length) -** -** @param chan I/O stream to read from -** @param buf Buffer to read into -** @param length Maximum capacity of the buffer -** -** @return The count of bytes transferred, or an error code -*/ -int read( uint_t chan, void *buffer, uint_t length ); - -/** -** write - write from a buffer to a stream -** -** usage: n = write(channel,buf,length) -** -** @param chan I/O stream to write to -** @param buf Buffer to write from -** @param length Maximum capacity of the buffer -** -** @return The count of bytes transferred, or an error code -*/ -int write( uint_t chan, const void *buffer, uint_t length ); - -/** -** getpid - get the PID of the calling process -** -** usage: pid = getpid() -** -** @return the PID of this process -*/ -uint_t getpid( void ); - -/** -** getppid - get the PID of the calling process' parent -** -** usage: pid = getppid() -** -** @return the PID of this process' parent -*/ -uint_t getppid( void ); - -/** -** gettime - get the current system time -** -** usage: pid = gettime() -** -** @return the system time -*/ -uint32_t gettime( void ); - -/** -** getprio - get the scheduling priority of the calling process -** -** usage: prio = getprio() -** -** @return the process' priority -*/ -int getprio( void ); - -/** -** setprio - set the scheduling priority of the calling process -** -** usage: oldprio = setprio(newprio) -** -** @param new the desired new priority -** -** @return the old priority value -*/ -int setprio( int new ); - -/** -** kill - terminate a process with extreme prejudice -** -** usage: n = kill( pid ) -** -** @param pid the intended victim -** -** @return 0 on success, else an error code -*/ -int32_t kill( uint_t pid ); - -/** -** sleep - put the current process to sleep for some length of time -** -** usage: sleep(n); -** -** @param ms Desired sleep time (in ms), or 0 to yield the CPU -** -** @return the time the process spent sleeping (in ms) -*/ -int sleep( uint32_t ms ); - -/** -** bogus - a nonexistent system call, to test our syscall ISR -** -** usage: bogus() -** -** Does not return. -*/ -void bogus( void ); - -/* -************************************************* -** CONVENIENT "SHORTHAND" VERSIONS OF SYSCALLS ** -************************************************* -** -** These are library functions that perform specific common -** variants of system calls. This helps reduce the total number -** of system calls, keeping our baseline OS as lean and mean -** as we can make it. :-) -*/ - -/** -** wait - wait for any child to exit -** -** usage: pid = wait(&status) -** -** Calls waitpid(0,status) -** -** @param status Pointer to int32_t into which the child's status is placed, -** or NULL -** -** @return The PID of the terminated child, or an error code -*/ -int wait( int32_t *status ); - -/** -** spawn - create a new process running a different program -** -** usage: n = spawn(what,args) -** -** Creates a new process and then execs 'what' -** -** @param what Program table index of the program to spawn -** @param args The command-line argument vector for the process -** -** @return The PID of the child, or an error code -*/ -int spawn( uint_t what, char **args ); - -/** -** cwritech(ch) - write a single character to the console -** -** @param ch The character to write -** -** @return The return value from calling write() -*/ -int cwritech( char ch ); - -/** -** cwrites(str) - write a NUL-terminated string to the console -** -** @param str The string to write -** -*/ -int cwrites( const char *str ); - -/** -** cwrite(buf,leng) - write a sized buffer to the console -** -** @param buf The buffer to write -** @param leng The number of bytes to write -** -** @return The return value from calling write() -*/ -int cwrite( const char *buf, uint32_t leng ); - -/** -** swritech(ch) - write a single character to the SIO -** -** @param ch The character to write -** -** @return The return value from calling write() -*/ -int swritech( char ch ); - -/** -** swrites(str) - write a NUL-terminated string to the SIO -** -** @param str The string to write -** -** @return The return value from calling write() -*/ -int swrites( const char *str ); - -/** -** swrite(buf,leng) - write a sized buffer to the SIO -** -** @param buf The buffer to write -** @param leng The number of bytes to write -** -** @return The return value from calling write() -*/ -int swrite( const char *buf, uint32_t leng ); - -/* -************************************************* -** MISCELLANEOUS USEFUL SUPPORT FUNCTIONS ******* -************************************************* -*/ - -/** -** fake_exit() -** -** dummy "startup" function -** -** calls exit(%eax) - serves as the "return to" code for -** main() functions, in case they don't call exit() themselves -*/ -void fake_exit( void ); - -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/user.h b/kernel/old/include/user.h deleted file mode 100644 index 4d9402f..0000000 --- a/kernel/old/include/user.h +++ /dev/null @@ -1,138 +0,0 @@ -/** -** @file user.h -** -** @author CSCI-452 class of 20245 -** -** @brief Declarations of user-level code management routines -*/ - -#ifndef USER_H_ -#define USER_H_ - -#include <common.h> - -#include <procs.h> -#include <x86/arch.h> - -// default value for EFLAGS in new processes -#define DEFAULT_EFLAGS (EFL_MB1 | EFL_IF) - -/* -** General (C and/or assembly) definitions -*/ - -#ifndef ASM_SRC - -/* -** Start of C-only definitions -*/ - -/* -** Types -*/ - -/* -** Blob file organization -** -** The file begins with a four-byte magic number and a four-byte integer -** indicating the number of ELF files contained in the blob. This is -** followed by an array of 32-byte file table entries, and then the contents -** of the ELF files in the order they appear in the program file table. -** -** Bytes Contents -** ----- ---------------------------- -** 0 - 3 File magic number ("BLB\0") -** 4 - 7 Number of ELF files in blob ("n") -** 8 - n*32+8 Program file table -** n*32+9 - ? ELF file contents -** -** Each program file table entry contains the following information: -** -** name File name (up to 19 characters long) -** offset Byte offset to the ELF header for this file -** size Size of this ELF file, in bytes -** flags Flags related to this file -*/ - -// user program blob header -typedef struct header_s { - char magic[4]; - uint32_t num; -} header_t; - -// length of the file name field -#define NAMELEN 20 - -// program descriptor -typedef struct prog_s { - char name[NAMELEN]; // truncated name (15 chars) - uint32_t offset; // offset from the beginning of the blob - uint32_t size; // size of this ELF module - uint32_t flags; // miscellaneous flags -} prog_t; - -/* -** Globals -*/ - -/* -** Prototypes -*/ - -/** -** Name: user_init -** -** Initializes the user support module. -*/ -void user_init( void ); - -/** -** Name: user_locate -** -** Locates a user program in the user code archive. -** -** @param what The ID of the user program to find -** -** @return pointer to the program table entry in the code archive, or NULL -*/ -prog_t *user_locate( uint_t what ); - -/** -** Name: user_duplicate -** -** Duplicates the memory setup for an existing process. -** -** @param new The PCB for the new copy of the program -** @param old The PCB for the existing the program -** -** @return the status of the duplicate attempt -*/ -int user_duplicate( pcb_t *new, pcb_t *old ); - -/** -** Name: user_load -** -** Loads a user program from the user code archive into memory. -** Allocates all needed frames and sets up the VM tables. -** -** @param prog A pointer to the program table entry to be loaded -** @param pcb The PCB for the program being loaded -** @param args The argument vector for the program -** -** @return the status of the load attempt -*/ -int user_load( prog_t *prog, pcb_t *pcb, const char **args ); - -/** -** Name: user_cleanup -** -** "Unloads" a user program. Deallocates all memory frames and -** cleans up the VM structures. -** -** @param pcb The PCB of the program to be cleaned up -*/ -void user_cleanup( pcb_t *pcb ); - -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/userids.h b/kernel/old/include/userids.h deleted file mode 100644 index 284f3ee..0000000 --- a/kernel/old/include/userids.h +++ /dev/null @@ -1,33 +0,0 @@ -/** -** @file userids.h -** -** @author Warren R. Carithers -** -** @brief IDs for user-level programs -** -** NOTE: this file is automatically generated when the user.img file -** is created. Do not edit this manually! -*/ - -#ifndef USERIDS_H_ -#define USERIDS_H_ - -#ifndef ASM_SRC -/* -** These IDs are used to identify the various user programs. -** Each call to exec() will provide one of these as the first -** argument. -** -** This list should be updated if/when the collection of -** user processes changes. -*/ -enum users_e { - Init, Idle, Shell, ProgABC, ProgDE, ProgFG, ProgH, ProgI, - ProgJ, ProgKL, ProgMN, ProgP, ProgQ, ProgR, ProgS, ProgTUV, - ProgW, ProgX, ProgY, ProgZ - // sentinel - , N_USERS -}; -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/vm.h b/kernel/old/include/vm.h deleted file mode 100644 index 6e3935e..0000000 --- a/kernel/old/include/vm.h +++ /dev/null @@ -1,443 +0,0 @@ -/** -** @file vm.h -** -** @author CSCI-452 class of 20245 -** -** @brief Virtual memory-related declarations. -*/ - -#ifndef VM_H_ -#define VM_H_ - -#include <defs.h> -#include <types.h> - -#include <procs.h> - -/* -** VM layout of the system -** -** User processes use the first 4MB of the 32-bit address space; see the -** next comment for details. -** -** Kernel virtual addresses are in the "higher half" range, beginning -** at 0x80000000. We define our mapping such that virtual address -** 0x8nnnnnnn maps to physical address 0x0nnnnnnn, so converting between -** the two is trivial. -*/ - -/* -** VM layout of process' address space -** -** Processes are limited to the first 4MB of the 32-bit address space: -** -** Address Range Contents -** ======================= ================================ -** 0x00000000 - 0x00000fff page 0 is inaccessible -** 0x00001000 - 0x000..fff text occupies pages 1 - N -** 0x000..000 - 0x000..fff data occupies pages N+1 - N+d -** 0x000..000 - 0x000..fff bss occupies pages N+d+1 - N+d+b -** 0x000..000 - 0x003fdfff unusable -** 0x003fe000 - 0x003fffff stack occupies last two pages -** -** This gives us the following page table structure: -** -** Page directory: -** Entries Contents -** ======== ============================== -** 0 point to PMT for address space -** 1 - 1023 invalid -** -** Page map table: -** Entries Contents -** ======== ============================== -** 0 invalid -** 1 - N text frames -** N+1 - N+d data frames -** N+d+1 - N+d+b bss frames -** N+d+b+1 - 1021 invalid -** 1022 - 1023 stack frames -*/ - -/* -** General (C and/or assembly) definitions -*/ - -// user virtual addresses -#define USER_TEXT 0x00001000 -#define USER_STACK 0x003fe000 -#define USER_STK_END 0x00400000 - -// how to find the addresses of the stack pages in the VM hierarchy -// user address space is the first 4MB of virtual memory -#define USER_PDE 0 -// the stack occupies the last two pages of the address space -#define USER_STK_PTE1 1022 -#define USER_STK_PTE2 1023 - -// some important memory addresses -#define KERN_BASE 0x80000000 // start of "kernel" memory -#define EXT_BASE 0x00100000 // start of "extended" memory (1MB) -#define DEV_BASE 0xfe000000 // "device" memory -#define PHYS_TOP 0x3fffffff // last usable physical address (1GB - 1) - -// where the kernel actually lives -#define KERN_PLINK 0x00010000 -#define KERN_VLINK (KERN_BASE + KERN_PLINK) - -// number of entries in a page directory or page table -#define N_PDE 1024 -#define N_PTE 1024 - -// index field shift counts and masks -#define PDIX_SHIFT 22 -#define PTIX_SHIFT 12 -#define PIX2I_MASK 0x3ff - -// physical/virtual converters that don't use casting -// (usable from anywhere) -#define V2PNC(a) ((a) - KERN_BASE) -#define P2VNC(a) ((a) + KERN_BASE) - -// page-size address rounding macros -#define SZ_PG_M1 MOD4K_BITS -#define SZ_PG_MASK MOD4K_MASK -#define PGUP(a) (((a)+SZ_PG_M1) & SZ_PG_MASK) -#define PGDOWN(a) ((a) & SZ_PG_MASK) - -// page directory entry bit fields -#define PDE_P 0x00000001 // 1 = present -#define PDE_RW 0x00000002 // 1 = writable -#define PDE_US 0x00000004 // 1 = user and system usable -#define PDE_PWT 0x00000008 // cache: 1 = write-through -#define PDE_PCD 0x00000010 // cache: 1 = disabled -#define PDE_A 0x00000020 // accessed -#define PDE_D 0x00000040 // dirty (4MB pages) -#define PDE_AVL1 0x00000040 // ignored (4KB pages) -#define PDE_PS 0x00000080 // 1 = 4MB page size -#define PDE_G 0x00000100 // global -#define PDE_AVL2 0x00000e00 // ignored -#define PDE_PAT 0x00001000 // (4MB pages) use page attribute table -#define PDE_PTA 0xfffff000 // page table address field (4KB pages) -#define PDE_FA 0xffc00000 // frame address field (4MB pages) - -// page table entry bit fields -#define PTE_P 0x00000001 // present -#define PTE_RW 0x00000002 // 1 = writable -#define PTE_US 0x00000004 // 1 = user and system usable -#define PTE_PWT 0x00000008 // cache: 1 = write-through -#define PTE_PCD 0x00000010 // cache: 1 = disabled -#define PTE_A 0x00000020 // accessed -#define PTE_D 0x00000040 // dirty -#define PTE_PAT 0x00000080 // use page attribute table -#define PTE_G 0x00000100 // global -#define PTE_AVL2 0x00000e00 // ignored -#define PTE_FA 0xfffff000 // frame address field - -// error code bit assignments for page faults -#define PFLT_P 0x00000001 -#define PFLT_W 0x00000002 -#define PFLT_US 0x00000004 -#define PFLT_RSVD 0x00000008 -#define PFLT_ID 0x00000010 -#define PFLT_PK 0x00000020 -#define PFLT_SS 0x00000040 -#define PFLT_HLAT 0x00000080 -#define PFLT_SGX 0x00008000 -#define PFLT_UNUSED 0xffff7f00 - -#ifndef ASM_SRC - -/* -** Start of C-only definitions -*/ - -// physical/virtual converters that do use casting -// (not usable from assembly) -#define V2P(a) (((uint32_t)(a)) - KERN_BASE) -#define P2V(a) (((uint32_t)(a)) + KERN_BASE) - -// create a pde/pte from an integer frame number and permission bits -#define MKPDE(f,p) ((pde_t)( TO_FRAME((f)) | (p) )) -#define MKPTE(f,p) ((pte_t)( TO_FRAME((f)) | (p) )) - -// is a PDE/PTE present? -// (P bit is in the same place in both) -#define IS_PRESENT(entry) (((entry) & PDE_P) != 0 ) - -// is a PDE a 4MB page entry? -#define IS_LARGE(pde) (((pde) & PDE_PS) != 0 ) - -// is this entry "system only" or "system and user"? -#define IS_SYSTEM(entry) (((entry) & PDE_US) == 0 ) -#define IS_USER(entry) (((entry) & PDE_US) != 0 ) - -// low-order nine bits of PDEs and PTEs hold "permission" flag bits -#define PERMS_MASK MOD4K_MASK - -// 4KB frame numbers are 20 bits wide -#define FRAME_4K_SHIFT 12 -#define FRAME2I_4K_MASK 0x000fffff -#define TO_4KFRAME(n) (((n)&FRAME2I_4K_MASK) << FRAME_4K_SHIFT) -#define GET_4KFRAME(n) (((n) >> FRAME_4K_SHIFT)&F2I_4K_MASK) -#define PDE_4K_ADDR(n) ((n) & MOD4K_MASK) -#define PTE_4K_ADDR(n) ((n) & MOD4K_MASK) - -// 4MB frame numbers are 10 bits wide -#define FRAME_4M_SHIFT 22 -#define FRAME2I_4M_MASK 0x000003ff -#define TO_4MFRAME(n) (((n)&FRAME2I_4M_MASK) << FRAME_4M_SHIFT) -#define GET_4MFRAME(n) (((n) >> FRAME_4M_SHIFT)&F2I_4M_MASK) -#define PDE_4M_ADDR(n) ((n) & MOD4M_MASK) -#define PTE_4M_ADDR(n) ((n) & MOD4M_MASK) - -// extract the PMT address or frame address from a table entry -// PDEs could point to 4MB pages, or 4KB PMTs -#define PDE_ADDR(p) (IS_LARGE(p)?(((uint32_t)p)&PDE_FA):(((uint32_t)p)&PDE_PTA)) -// PTEs always point to 4KB pages -#define PTE_ADDR(p) (((uint32_t)(p))&PTE_FA) -// everything has nine bits of permission flags -#define PERMS(p) (((uint32_t)(p))&PERMS_MASK) - -// extract the table indices from a 32-bit address -#define PDIX(v) ((((uint32_t)(v)) >> PDIX_SHIFT) & PIX2I_MASK) -#define PTIX(v) ((((uint32_t)(v)) >> PTIX_SHIFT) & PIX2I_MASK) - -/* -** Types -*/ - -// page directory entries - -// as a 32-bit word, in types.h -// typedef uint32_t pde_t; - -// PDE for 4KB pages -typedef struct pdek_s { - uint_t p :1; // present - uint_t rw :1; // writable - uint_t us :1; // user/supervisor - uint_t pwt :1; // cache write-through - uint_t pcd :1; // cache disable - uint_t a :1; // accessed - uint_t avl1 :1; // ignored (available) - uint_t ps :1; // page size (must be 0) - uint_t avl2 :4; // ignored (available) - uint_t fa :20; // frame address -} pdek_f_t; - -// PDE for 4MB pages -typedef struct pdem_s { - uint_t p :1; // present - uint_t rw :1; // writable - uint_t us :1; // user/supervisor - uint_t pwt :1; // cache write-through - uint_t pcd :1; // cache disable - uint_t a :1; // accessed - uint_t d :1; // dirty - uint_t ps :1; // page size (must be 1) - uint_t g :1; // global - uint_t avl :3; // ignored (available) - uint_t fa :20; // frame address -} pdem_f_t; - -// page table entries - -// as a 32-bit word, in types.h -// typedef uint32_t pte_t; - -// broken out into fields -typedef struct pte_s { - uint_t p :1; // present - uint_t rw :1; // writable - uint_t us :1; // user/supervisor - uint_t pwt :1; // cache write-through - uint_t pcd :1; // cache disable - uint_t a :1; // accessed - uint_t d :1; // dirty - uint_t pat :1; // page attribute table in use - uint_t g :1; // global - uint_t avl :3; // ignored (available) - uint_t fa :20; // frame address -} ptef_t; - -// page fault error code bits -// comment: meaning when 1 / meaning when 0 -struct pfec_s { - uint_t p :1; // page-level protection violation / !present - uint_t w :1; // write / read - uint_t us :1; // user-mode access / supervisor-mode access - uint_t rsvd :1; // reserved bit violation / not - uint_t id :1; // instruction fetch / data fetch - uint_t pk :1; // protection-key violation / !pk - uint_t ss :1; // shadow stack access / !ss - uint_t hlat :1; // HLAT paging / ordinary paging or access rights - uint_t xtr1 :7; // unused - uint_t sgz :1; // SGX-specific access control violation / !SGX - uint_t xtr2 :16; // more unused -}; - -typedef union pfec_u { - uint32_t u; - struct pfec_s s; -} pfec_t; - -// Mapping descriptor for VA::PA mappings -typedef struct mapping_t { - uint32_t va_start; // starting virtual address for this range - uint32_t pa_start; // first physical address in the range - uint32_t pa_end; // last physical address in the range - uint32_t perm; // access control -} mapping_t; - -/* -** Globals -*/ - -// created page directory for the kernel -extern pde_t *kpdir; - -/* -** Prototypes -*/ - -/** -** Name: vm_init -** -** Initialize the VM module -** -** Note: should not be called until after the memory free list has -** been set up. -*/ -void vm_init( void ); - -/** -** Name: vm_pagedup -** -** Duplicate a page of memory -** -** @param old Pointer to the first byte of a page -** -** @return a pointer to the new, duplicate page, or NULL -*/ -void *vm_pagedup( void *old ); - -/** -** Name: vm_ptdup -** -** Duplicate a page directory entry -** -** @param dst Pointer to where the duplicate should go -** @param curr Pointer to the entry to be duplicated -** -** @return true on success, else false -*/ -bool_t vm_ptdup( pde_t *dst, pde_t *curr ); - -/** -** Name: vm_getpte -** -** Return the address of the PTE corresponding to the virtual address -** 'va' within the address space controlled by 'pgdir'. If there is no -** page table for that VA and 'alloc' is true, create the necessary -** page table entries. -** -** @param pdir Pointer to the page directory to be searched -** @param va The virtual address we're looking for -** @param alloc Should we allocate a page table if there isn't one? -** -** @return A pointer to the page table entry for this VA, or NULL -*/ -pte_t *vm_getpte( pde_t *pdir, const void *va, bool_t alloc ); - -/** -** Name: vm_mkkvm -** -** Create the kernel's page table hierarchy -*/ -pde_t *vm_mkkvm( void ); - -/** -** Name: vm_mkuvm -** -** Create the page table hierarchy for a user process -*/ -pde_t *vm_mkuvm( void ); - -/** -** Name: vm_set_kvm -** -** Switch the page table register to the kernel's page directory -*/ -void vm_set_kvm( void ); - -/** -** Name: vm_set_uvm -** -** Switch the page table register to the page directory for a user process. -** -** @param p The PCB of the user process -*/ -void vm_set_uvm( pcb_t *p ); - -/** -** Name: vm_add -** -** Add pages to the page hierarchy for a process, copying data into -** them if necessary. -** -** @param pdir Pointer to the page directory to modify -** @param wr "Writable" flag for the PTE -** @param sys "System" flag for the PTE -** @param va Starting VA of the range -** @param size Amount of physical memory to allocate -** @param data Pointer to data to copy, or NULL -** @param bytes Number of bytes to copy -** -** @return status of the allocation attempt -*/ -int vm_add( pde_t *pdir, bool_t wr, bool_t sys, - void *va, uint32_t size, char *data, uint32_t bytes ); - -/** -** Name: vm_free -** -** Deallocate a page table hierarchy and all physical memory frames -** in the user portion. -** -** @param pdir Pointer to the page directory -*/ -void vm_free( pde_t *pdir ); - -/* -** Name: vm_map -** -** Create PTEs for virtual addresses starting at 'va' that refer to -** physical addresses in the range [pa, pa+size-1]. We aren't guaranteed -** that va is page-aligned. -** -** @param pdir Page directory for this address space -** @param va The starting virtual address -** @param size Length of the range to be mapped -** @param pa The starting physical address -** @param perm Permission bits for the PTEs -*/ -int vm_map( pde_t *pdir, void *va, uint_t size, uint_t pa, int perm ); - -/** -** Name: vm_uvmdup -** -** Create a duplicate of the user portio of an existing page table -** hierarchy. We assume that the "new" page directory exists and -** the system portions of it should not be touched. -** -** @param old Existing page directory -** @param new New page directory -** -** @return status of the duplication attempt -*/ -int vm_uvmdup( pde_t *old, pde_t *new ); - -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/vmtables.h b/kernel/old/include/vmtables.h deleted file mode 100644 index 17f6e0a..0000000 --- a/kernel/old/include/vmtables.h +++ /dev/null @@ -1,43 +0,0 @@ -/** -** @file vmtables.h -** -** @author CSCI-452 class of 20245 -** -** @brief Predefined VM tables -*/ - -#ifndef VMTABLES_H_ -#define VMTABLES_H_ - -#include <defs.h> -#include <types.h> -#include <vm.h> - -#ifndef ASM_SRC - -/* -** Initial page directory, for when the kernel is starting up -** -** we use large (4MB) pages here to allow us to use a one-level -** paging hierarchy; the kernel will create a new page table -** hierarchy once memory is initialized -*/ -extern pde_t firstpdir[]; - -/* -** "Identity" page map table. -** -** This just maps the first 4MB of physical memory. It is initialized -** in vm_init(). -*/ -extern pte_t id_map[]; - -/* -** Kernel address mappings, present in every page table -*/ -extern mapping_t kmap[]; -extern const uint32_t n_kmap; - -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/x86/arch.h b/kernel/old/include/x86/arch.h deleted file mode 100644 index 113c76b..0000000 --- a/kernel/old/include/x86/arch.h +++ /dev/null @@ -1,303 +0,0 @@ -/* -** @file arch.h -** -** @author Warren R. Carithers -** @author K. Reek -** -** Definitions of constants and macros for use -** with the x86 architecture and registers. -** -*/ - -#ifndef X86ARCH_H_ -#define X86ARCH_H_ - -/* -** Video stuff -*/ -#define VID_BASE_ADDR 0xB8000 - -/* -** Memory management -*/ -#define SEG_PRESENT 0x80 -#define SEG_PL_0 0x00 -#define SEG_PL_1 0x20 -#define SEG_PL_2 0x40 -#define SEG_PL_3 0x50 -#define SEG_SYSTEM 0x00 -#define SEG_NON_SYSTEM 0x10 -#define SEG_32BIT 0x04 -#define DESC_IGATE 0x06 - -/* -** Exceptions -*/ -#define N_EXCEPTIONS 256 - -/* -** Bit definitions in registers -** -** See IA-32 Intel Architecture SW Dev. Manual, Volume 3: System -** Programming Guide, page 2-8. -*/ - -/* -** EFLAGS -*/ -#define EFL_RSVD 0xffc00000 /* reserved */ -#define EFL_MB0 0x00008020 /* must be zero */ -#define EFL_MB1 0x00000002 /* must be 1 */ - -#define EFL_ID 0x00200000 -#define EFL_VIP 0x00100000 -#define EFL_VIF 0x00080000 -#define EFL_AC 0x00040000 -#define EFL_VM 0x00020000 -#define EFL_RF 0x00010000 -#define EFL_NT 0x00004000 -#define EFL_IOPL 0x00003000 -#define EFL_OF 0x00000800 -#define EFL_DF 0x00000400 -#define EFL_IF 0x00000200 -#define EFL_TF 0x00000100 -#define EFL_SF 0x00000080 -#define EFL_ZF 0x00000040 -#define EFL_AF 0x00000010 -#define EFL_PF 0x00000004 -#define EFL_CF 0x00000001 - -/* -** CR0, CR1, CR2, CR3, CR4 -** -** IA-32 V3, page 2-12. -*/ -#define CR0_RSVD 0x1ffaffc0 -#define CR0_PG 0x80000000 -#define CR0_CD 0x40000000 -#define CR0_NW 0x20000000 -#define CR0_AM 0x00040000 -#define CR0_WP 0x00010000 -#define CR0_NE 0x00000020 -#define CR0_ET 0x00000010 -#define CR0_TS 0x00000008 -#define CR0_EM 0x00000004 -#define CR0_MP 0x00000002 -#define CR0_PE 0x00000001 - -#define CR1_RSVD 0xffffffff - -#define CR2_RSVD 0x00000000 -#define CR2_PF_LIN_ADDR 0xffffffff - -#define CR3_RSVD 0x00000fe7 -#define CR3_PD_BASE 0xfffff000 -#define CR3_PCD 0x00000010 -#define CR3_PWT 0x00000008 - -#define CR4_RSVD 0xfd001000 -#define CR4_UINT 0x02000000 -#define CR4_PKS 0x01000000 -#define CR4_CET 0x00800000 -#define CR4_PKE 0x00400000 -#define CR4_SMAP 0x00200000 -#define CR4_SMEP 0x00100000 -#define CR4_KL 0x00080000 -#define CR4_OSXS 0x00040000 -#define CR4_PCID 0x00020000 -#define CR4_FSGS 0x00010000 -#define CR4_SMXE 0x00004000 -#define CR4_VMXE 0x00002000 -#define CR4_LA57 0x00001000 -#define CR4_UMIP 0x00000800 -#define CR4_OSXMMEXCPT 0x00000400 -#define CR4_OSFXSR 0x00000200 -#define CR4_PCE 0x00000100 -#define CR4_PGE 0x00000080 -#define CR4_MCE 0x00000040 -#define CR4_PAE 0x00000020 -#define CR4_PSE 0x00000010 -#define CR4_DE 0x00000008 -#define CR4_TSD 0x00000004 -#define CR4_PVI 0x00000002 -#define CR4_VME 0x00000001 - -/* -** PMode segment selector field masks -** -** IA-32 V3, page 3-8. -*/ -#define SEG_SEL_IX_MASK 0xfff8 -#define SEG_SEL_TI_MASK 0x0004 -#define SEG_SEL_RPL_MASK 0x0003 - -/* -** Segment descriptor bytes -** -** IA-32 V3, page 3-10. -** -** Bytes: -** 0, 1: segment limit 15:0 -** 2, 3: base address 15:0 -** 4: base address 23:16 -** 7: base address 31:24 -*/ - -/* -** Byte 5: access control bits -** 7: present -** 6-5: DPL -** 4: system/user -** 3-0: type -*/ -#define SEG_ACCESS_P_MASK 0x80 -# define SEG_PRESENT 0x80 -# define SEG_NOT_PRESENT 0x00 - -#define SEG_ACCESS_DPL_MASK 0x60 -# define SEG_DPL_0 0x00 -# define SEG_DPL_1 0x20 -# define SEG_DPL_2 0x40 -# define SEG_DPL_3 0x60 - -#define SEG_ACCESS_S_MASK 0x10 -# define SEG_SYSTEM 0x00 -# define SEG_NON_SYSTEM 0x10 - -#define SEG_TYPE_MASK 0x0f -# define SEG_DATA_A_BIT 0x1 -# define SEG_DATA_W_BIT 0x2 -# define SEG_DATA_E_BIT 0x4 -# define SEG_CODE_A_BIT 0x1 -# define SEG_CODE_R_BIT 0x2 -# define SEG_CODE_C_BIT 0x4 -# define SEG_DATA_RO 0x0 -# define SEG_DATA_ROA 0x1 -# define SEG_DATA_RW 0x2 -# define SEG_DATA_RWA 0x3 -# define SEG_DATA_RO_XD 0x4 -# define SEG_DATA_RO_XDA 0x5 -# define SEG_DATA_RW_XW 0x6 -# define SEG_DATA_RW_XWA 0x7 -# define SEG_CODE_XO 0x8 -# define SEG_CODE_XOA 0x9 -# define SEG_CODE_XR 0xa -# define SEG_CODE_XRA 0xb -# define SEG_CODE_XO_C 0xc -# define SEG_CODE_XO_CA 0xd -# define SEG_CODE_XR_C 0xe -# define SEG_CODE_XR_CA 0xf - -/* -** Byte 6: sizes -** 7: granularity -** 6: d/b -** 5: long mode -** 4: available! -** 3-0: upper 4 bits of limit -** 7: base address 31:24 -*/ -#define SEG_SIZE_G_MASK 0x80 -# define SEG_GRAN_BYTE 0x00 -# define SEG_GRAN_4KBYTE 0x80 - -#define SEG_SIZE_D_B_MASK 0x40 -# define SEG_DB_16BIT 0x00 -# define SEG_DB_32BIT 0x40 - -#define SEG_SIZE_L_MASK 0x20 -# define SEG_L_64BIT 0x20 -# define SEG_L_32BIT 0x00 - -#define SEG_SIZE_AVL_MASK 0x10 - -#define SEG_SIZE_LIM_19_16_MASK 0x0f - - -/* -** System-segment and gate-descriptor types -** -** IA-32 V3, page 3-15. -*/ - // type 0: reserved -#define SEG_SYS_16BIT_TSS_AVAIL 0x1 -#define SEG_SYS_LDT 0x2 -#define SEG_SYS_16BIT_TSS_BUSY 0x3 -#define SEG_SYS_16BIT_CALL_GATE 0x4 -#define SEG_SYS_TASK_GATE 0x5 -#define SEG_SYS_16BIT_INT_GATE 0x6 -#define SEG_SYS_16BIT_TRAP_GATE 0x7 - // type 8: reserved -#define SEG_SYS_32BIT_TSS_AVAIL 0x9 - // type A: reserved -#define SEG_SYS_32BIT_TSS_BUSY 0xb -#define SEG_SYS_32BIT_CALL_GATE 0xc - // type D: reserved -#define SEG_SYS_32BIT_INT_GATE 0xe -#define SEG_SYS_32BIT_TRAP_GATE 0xf - -/* -** IDT Descriptors -** -** IA-32 V3, page 5-13. -** -** All have a segment selector in bytes 2 and 3; Task Gate descriptors -** have bytes 0, 1, 4, 6, and 7 reserved; others have bytes 0, 1, 6, -** and 7 devoted to the 16 bits of the Offset, with the low nybble of -** byte 4 reserved. -*/ -#define IDT_PRESENT 0x8000 -#define IDT_DPL_MASK 0x6000 -# define IDT_DPL_0 0x0000 -# define IDT_DPL_1 0x2000 -# define IDT_DPL_2 0x4000 -# define IDT_DPL_3 0x6000 -#define IDT_GATE_TYPE 0x0f00 -# define IDT_TASK_GATE 0x0500 -# define IDT_INT16_GATE 0x0600 -# define IDT_INT32_GATE 0x0e00 -# define IDT_TRAP16_GATE 0x0700 -# define IDT_TRAP32_GATE 0x0f00 - -/* -** Interrupt vectors -*/ - -// predefined by the architecture -#define VEC_DIVIDE_ERROR 0x00 -#define VEC_DEBUG_EXCEPTION 0x01 -#define VEC_NMI_INTERRUPT 0x02 -#define VEC_BREAKPOINT 0x03 -#define VEC_OVERFLOW 0x04 -#define VEC_BOUND_RANGE_EXCEEDED 0x05 -#define VEC_INVALID_OPCODE 0x06 -#define VEC_DEVICE_NOT_AVAILABLE 0x07 -#define VEC_DOUBLE_FAULT 0x08 -#define VEC_COPROCESSOR_OVERRUN 0x09 -#define VEC_INVALID_TSS 0x0a -#define VEC_SEGMENT_NOT_PRESENT 0x0b -#define VEC_STACK_FAULT 0x0c -#define VEC_GENERAL_PROTECTION 0x0d -#define VEC_PAGE_FAULT 0x0e -// 0x0f is reserved - unused -#define VEC_FPU_ERROR 0x10 -#define VEC_ALIGNMENT_CHECK 0x11 -#define VEC_MACHINE_CHECK 0x12 -#define VEC_SIMD_FP_EXCEPTION 0x13 -#define VEC_VIRT_EXCEPTION 0x14 -#define VEC_CTRL_PROT_EXCEPTION 0x15 -// 0x16 through 0x1f are reserved - -// 0x20 through 0xff are user-defined, non-reserved - -// IRQ0 through IRQ15 will use vectors 0x20 through 0x2f -#define VEC_TIMER 0x20 -#define VEC_KBD 0x21 -#define VEC_COM2 0x23 -#define VEC_COM1 0x24 -#define VEC_PARALLEL 0x25 -#define VEC_FLOPPY 0x26 -#define VEC_MYSTERY 0x27 -#define VEC_MOUSE 0x2c - -#endif diff --git a/kernel/old/include/x86/bios.h b/kernel/old/include/x86/bios.h deleted file mode 100644 index a19e570..0000000 --- a/kernel/old/include/x86/bios.h +++ /dev/null @@ -1,73 +0,0 @@ -/* -** @file bios.h -** -** @author Warren R. Carithers -** -** BIOS-related declarations -*/ - -#ifndef BIOS_H_ -#define BIOS_H_ - -/* -** BIOS-related memory addresses -*/ - -#define BIOS_BDA 0x0400 - -/* -** Selected BIOS interrupt numbers -*/ - -#define BIOS_TIMER 0x08 -#define BIOS_KBD 0x09 -#define BIOS_VIDEO 0x10 -#define BIOS_EQUIP 0x11 -#define BIOS_MSIZ 0x12 -#define BIOS_DISK 0x13 -#define BIOS_SERIAL 0x14 -#define BIOS_MISC 0x15 -#define BIOS_KBDSVC 0x16 -#define BIOS_PRTSVC 0x17 -#define BIOS_BOOT 0x19 -#define BIOS_RTCPCI 0x1a - -// BIOS video commands (AH) -#define BV_W_ADV 0x0e - -// BIOS disk commands (AH) -#define BD_RESET 0x00 -#define BD_CHECK 0x01 -#define BD_RDSECT 0x02 -#define BD_WRSECT 0x03 -#define BD_PARAMS 0x08 - -// BIOS disk commands with parameters (AX) -#define BD_READ(n) ((BD_RDSECT << 8) | (n)) -#define BD_READ1 0x0201 - -// CMOS ports (used for masking NMIs) -#define CMOS_ADDR 0x70 -#define CMOS_DATA 0x71 - -// important related commands -#define NMI_ENABLE 0x00 -#define NMI_DISABLE 0x80 - -/* -** Physical Memory Map Table (0000:2D00 - 0000:7c00) -** -** Primarily used with the BIOS_MISC interrupt -*/ -#define MMAP_SEG 0x02D0 -#define MMAP_DISP 0x0000 -#define MMAP_ADDR ((MMAP_SEG << 4) + MMAP_DISP) -#define MMAP_SECTORS 0x0a - -#define MMAP_ENT 24 /* bytes per entry */ -#define MMAP_MAX_ENTS (BOOT_ADDR - MMAP_ADDR - 4) / 24 - -#define MMAP_CODE 0xE820 /* int 0x15 code */ -#define MMAP_MAGIC_NUM 0x534D4150 /* for 0xE820 interrupt */ - -#endif diff --git a/kernel/old/include/x86/ops.h b/kernel/old/include/x86/ops.h deleted file mode 100644 index ad795b9..0000000 --- a/kernel/old/include/x86/ops.h +++ /dev/null @@ -1,443 +0,0 @@ -/** -** @file ops.h -** -** @author Warren R. Carithers -** -** @brief Inline escapes to assembly for efficiency -** -** Inspiration from: -** Martins Mozeiko, https://gist.github.com/mmozeiko/f68ad2546bd6ab953315 -** MIT's xv6, https://github.com/mit-pdos/xv6-public -** -** Note: normally, GCC doesn't inline unless the optimization level is -** over 1. This can be forced by adding -** -** __attribute__((always_inline)) -** -** after the parameter list on each declaration. This is enabled by -** defining the compile-time CPP symbol FORCE_INLINING. -*/ - -#ifndef OPS_H_ -#define OPS_H_ - -#include <common.h> - -#ifndef ASM_SRC - -// control "forced" inlining -#ifdef FORCE_INLINING -#define OPSINLINED __attribute__((always_inline)) -#else -#define OPSINLINED /* no-op */ -#endif /* FORCE_INLINING */ - -/**************************** -** Data movement -****************************/ - -/** -** Block move functions -** -** Variations: movsb(), movsl(), movsq() -** -** Description: Copy from source buffer to destination buffer -** -** @param dst Destination buffer -** @param src Source buffer -** @param len Byte count -*/ -static inline void -movsb( void* dst, const void* src, uint32_t len ) OPSINLINED -{ - __asm__ __volatile__( "cld; rep movsb" - : "+D"(dst), "+S"(src), "+c"(len) - : : "memory" ); -} - -static inline void -movsw( void* dst, const void* src, uint32_t len ) OPSINLINED -{ - __asm__ __volatile__( "cld; rep movsw" - : "+D"(dst), "+S"(src), "+c"(len) - : : "memory" ); -} - -static inline void -movsl( void* dst, const void* src, uint32_t len ) OPSINLINED -{ - __asm__ __volatile__( "cld; rep movsl" - : "+D"(dst), "+S"(src), "+c"(len) - : : "memory" ); -} - -static inline void -movsq( void* dst, const void* src, uint32_t len ) OPSINLINED -{ - __asm__ __volatile__( "cld; rep movsq" - : "+D"(dst), "+S"(src), "+c"(len) - : : "memory" ); -} - -/** -** Block store functions -** -** Variations: stosb(), stosw(), stosl() -** -** Description: Store a specific value into destination buffer -** -** @param dst Destination buffer -** @param val Data to copy -** @param len Byte count -*/ -static inline void -stosb( void *dst, uint8_t val, uint32_t len ) OPSINLINED -{ - __asm__ __volatile__( "cld; rep stosb" - : "=D" (dst), "=c" (len) - : "0" (dst), "1" (len), "a" (val) - : "memory", "cc" ); -} - -static inline void -stosw( void *dst, uint16_t val, uint32_t len ) OPSINLINED -{ - __asm__ __volatile__( "cld; rep stos2" - : "=D" (dst), "=c" (len) - : "0" (dst), "1" (len), "a" (val) - : "memory", "cc" ); -} - -static inline void -stosl( void *dst, uint32_t val, uint32_t len ) OPSINLINED -{ - __asm__ __volatile__( "cld; rep stosl" - : "=D" (dst), "=c" (len) - : "0" (dst), "1" (len), "a" (val) - : "memory", "cc" ); -} - -/**************************** -** Special register access -****************************/ - -/** -** Register read functions -** -** Variations: r_cr0(), r_cr2(), r_cr3(), r_cr4(), r_eflags(), -** r_ebp(), r_esp() -** -** Description: Reads the register indicated by its name -** -** @return Contents of the register -*/ -static inline uint32_t -r_cr0( void ) OPSINLINED -{ - uint32_t val; - __asm__ __volatile__( "movl %%cr0,%0" : "=r" (val) ); - return val; -} - -static inline uint32_t -r_cr2( void ) OPSINLINED -{ - uint32_t val; - __asm__ __volatile__( "movl %%cr2,%0" : "=r" (val) ); - return val; -} - -static inline uint32_t -r_cr3( void ) OPSINLINED -{ - uint32_t val; - __asm__ __volatile__( "movl %%cr3,%0" : "=r" (val) ); - return val; -} - -static inline uint32_t -r_cr4( void ) OPSINLINED -{ - uint32_t val; - __asm__ __volatile__( "movl %%cr4,%0" : "=r" (val) ); - return val; -} - -static inline uint32_t -r_eflags(void) OPSINLINED -{ - uint32_t val; - __asm__ __volatile__( "pushfl; popl %0" : "=r" (val) ); - return val; -} - -static inline uint32_t -r_ebp(void) OPSINLINED -{ - uint32_t val; - __asm__ __volatile__( "movl %%ebp,%0" : "=r" (val) ); - return val; -} - -static inline uint32_t -r_esp(void) OPSINLINED -{ - uint32_t val; - __asm__ __volatile__( "movl %%esp,%0" : "=r" (val) ); - return val; -} - -/** -** Register write functions -** -** Variations: w_cr0(), w_cr2(), w_cr3(), w_cr4(), w_eflags() -** -** Description: Writes a value into the CR indicated by its name -*/ -static inline void -w_cr0( uint32_t val ) OPSINLINED -{ - __asm__ __volatile__( "movl %0,%%cr0" : : "r" (val) ); -} - -static inline void -w_cr2( uint32_t val ) OPSINLINED -{ - __asm__ __volatile__( "movl %0,%%cr2" : : "r" (val) ); -} - -static inline void -w_cr3( uint32_t val ) OPSINLINED -{ - __asm__ __volatile__( "movl %0,%%cr3" : : "r" (val) ); -} - -static inline void -w_cr4( uint32_t val ) OPSINLINED -{ - __asm__ __volatile__( "movl %0,%%cr4" : : "r" (val) ); -} - -static inline void -w_eflags(uint32_t eflags) OPSINLINED -{ - __asm__ __volatile__( "pushl %0; popfl" : : "r" (eflags) ); -} - -/** -** Descriptor table load functions -** -** Variations: w_gdt(), w_idt() -** -** Description: Load an address into the specified processor register -** -** @param addr The value to be loaded into the register -*/ -static inline void -w_gdt( void *addr ) OPSINLINED -{ - __asm__ __volatile__( "lgdt (%0)" : : "r" (addr) ); -} - -static inline void -w_idt( void *addr ) OPSINLINED -{ - __asm__ __volatile__( "lidt (%0)" : : "r" (addr) ); -} - -/** -** CPU ID access -** -** Description: Retrieve CPUID information -** -** @param op Value to be placed into %eax for the operation -** @param ap Pointer to where %eax contents should be saved, or NULL -** @param bp Pointer to where %ebx contents should be saved, or NULL -** @param cp Pointer to where %ecx contents should be saved, or NULL -** @param dp Pointer to where %edx contents should be saved, or NULL -*/ -static inline void -cpuid( uint32_t op, uint32_t *ap, uint32_t *bp, - uint32_t *cp, uint32_t *dp ) OPSINLINED -{ - uint32_t eax, ebx, ecx, edx; - __asm__ __volatile__( "cpuid" - : "=a" (eax), "=b" (ebx), "=c" (ecx), "=d" (edx) - : "a" (op) ); - - if( ap ) *ap = eax; - if( bp ) *bp = ebx; - if( cp ) *cp = ecx; - if( dp ) *dp = edx; -} - -/**************************** -** TLB management -****************************/ - -/** -** TLB invalidation for one page -** -** Description: Invalidate the TLB entry for an address -** -** @param addr An address within the page to be flushed -*/ -static inline void -invlpg( uint32_t addr ) OPSINLINED -{ - __asm__ __volatile__( "invlpg (%0)" : : "r" (addr) : "memory" ); -} - -/** -** TLB invalidation for all pages -** -** Description: Flush all entries from the TLB -** -** We do this by changing CR3. -*/ -static inline void -flushtlb( void ) OPSINLINED -{ - uint32_t cr3; - __asm__ __volatile__( "movl %%cr3,%0" : "=r" (cr3) ); - __asm__ __volatile__( "movl %0,%%cr2" : : "r" (cr3) ); -} - -/**************************** -** I/O instructions -****************************/ - -/** -** Name: inN -** -** Variations: inb(), inw(), inl() -** -** Description: Read some amount of data from the supplied I/O port -** -** @param port The i/o port to read from -** -** @return The data read from the specified port -*/ -static inline uint8_t -inb( int port ) OPSINLINED -{ - uint8_t data; - __asm__ __volatile__( "inb %w1,%0" : "=a" (data) : "d" (port) ); - return data; -} - -static inline uint16_t -inw( int port ) OPSINLINED -{ - uint16_t data; - __asm__ __volatile__( "inw %w1,%0" : "=a" (data) : "d" (port) ); - return data; -} - -static inline uint32_t -inl( int port ) OPSINLINED -{ - uint32_t data; - __asm__ __volatile__( "inl %w1,%0" : "=a" (data) : "d" (port) ); - return data; -} - -/** -** Name: outN -** -** Variations: outb(), outw(), outl() -** -** Description: Write some data to the specified I/O port -** -** @param port The i/o port to write to -** @param data The data to be written to the port -** -** @return The data read from the specified port -*/ -static inline void -outb( int port, uint8_t data ) OPSINLINED -{ - __asm__ __volatile__( "outb %0,%w1" : : "a" (data), "d" (port) ); -} - -static inline void -outw( int port, uint16_t data ) OPSINLINED -{ - __asm__ __volatile__( "outw %0,%w1" : : "a" (data), "d" (port) ); -} - -static inline void -outl( int port, uint32_t data ) OPSINLINED -{ - __asm__ __volatile__( "outl %0,%w1" : : "a" (data), "d" (port) ); -} - -/**************************** -** Miscellaneous instructions -****************************/ - -/** -** Name: breakpoint -** -** Description: Cause a breakpoint interrupt for debugging purposes -*/ -static inline void -breakpoint( void ) OPSINLINED -{ - __asm__ __volatile__( "int3" ); -} - -/** -** Name: get_ra -** -** Description: Get the return address for the calling function -** (i.e., where whoever called us will go back to) -** -** @return The address the calling routine will return to as a uint32_t -*/ -static inline uint32_t -get_ra( void ) OPSINLINED -{ - uint32_t val; - __asm__ __volatile__( "movl 4(%%ebp),%0" : "=r" (val) ); - return val; -} - -/** -** Name: ev_wait -** -** Description: Pause until something happens -*/ -static inline void -ev_wait( void ) OPSINLINED -{ - __asm__ __volatile__( "sti ; hlt" ); -} - - -/** -** Name: xchgl -** -** Description: Perform an atomic exchange with memory -** -** @param addr Memory location to be modified -** @param data Data to exchange -** -** @return The old contents of the memory location -*/ -static inline uint32_t -xchgl( volatile uint32_t *addr, uint32_t data ) OPSINLINED -{ - uint32_t old; - - // + indicates a read-modify-write operand - __asm__ __volatile__( "lock; xchgl %0, %1" - : "+m" (*addr), "=a" (old) - : "1" (data) - : "cc"); - return old; -} - -#endif /* !ASM_SRC */ - -#endif diff --git a/kernel/old/include/x86/pic.h b/kernel/old/include/x86/pic.h deleted file mode 100644 index d4fa93b..0000000 --- a/kernel/old/include/x86/pic.h +++ /dev/null @@ -1,139 +0,0 @@ -/** -** @file pic.h -** -** @author Warren R. Carithers -** @author K. Reek -** -** Definitions of constants and macros for the Intel 8259 Programmable -** Interrupt Controller. -** -*/ - -#ifndef X86PIC_H_ -#define X86PIC_H_ - -/* -** Our expected configuration is two PICs, with the secondary connected -** through the IRQ2 pin of the primary. -*/ - -/* -** Port addresses for the command port and interrupt mask register port -** for both the primary and secondary PICs. -*/ -#define PIC1_CMD 0x20 // primary command -#define PIC1_DATA (PIC1_CMD + 1) // primary data / int mask register -#define PIC2_CMD 0xA0 // secondary command -#define PIC2_DATA (PIC2_CMD + 1) // secondary data / int mask register - -/* -** Initialization Command Word (ICW) definitions -** -** Initialization sequence: -** ICW1 Init command is sent to each command port. -** ICW2 vector commands are sent to the data ports. -** If "cascade mode" was selected, send ICW3 commands to the data ports. -** If "need ICW4" was selected, send ICW4 commands to the data ports. -** -** Following that sequence, the PIC is ready to accept interrupts; -** it will also accept Output Command Words (OCWs) to the data ports. -** -** PIC1_* defines are intended for the primary PIC -** PIC2_* defines are intended for the secondary PIC -** PIC_* defines are sent to both PICs -*/ - -/* -** ICW1: initialization, send to command port -*/ -#define PIC_CW1_INIT 0x10 // start initialization sequence -#define PIC_CW1_NEED4 0x01 // ICW4 will also be set -#define PIC_CW1_SINGLE 0x02 // select single (vs. cascade) mode -#define PIC_CW1_INTVAL 0x04 // set call interval to 4 (vs. 8) -#define PIC_CW1_LEVEL 0x08 // use level-triggered mode (vs. edge) - -/* -** ICW2: interrupt vector base offsets, send to data port -*/ -#define PIC1_CW2_VECBASE 0x20 // IRQ0 int vector number -#define PIC2_CW2_VECBASE 0x28 // IRQ8 int vector number - -/* -** ICW3: secondary::primary attachment, send to data port -*/ -#define PIC1_CW3_SEC_IRQ2 0x04 // bit mask: secondary is on pin 2 -#define PIC2_CW3_SEC_ID 0x02 // integer: secondary id - -/* -** ICW4: operating mode, send to data port -*/ -#define PIC_CW4_PM86 0x01 // 8086 mode (vs. 8080/8085) -#define PIC_CW4_AUTOEOI 0x02 // do auto eoi's -#define PIC_CW4_UNBUF 0x00 // unbuffered mode -#define PIC_CW4_SEC_BUF 0x08 // put secondary in buffered mode -#define PIC_CW4_PRI_BUF 0x0C // put primary in buffered mode -#define PIC_CW4_SFNMODE 0x10 // "special fully nested" mode - -/* -** Operation Control Words (OCWs) -** -** After the init sequence, can send these -*/ - -/* -** OCW1: interrupt mask; send to data port -*/ -#define PIC_MASK_NONE 0x00 // allow all interrupts -#define PIC_MASK_NO_IRQ0 0x01 // prevent IRQ0 interrupts -#define PIC_MASK_NO_IRQ1 0x02 // prevent IRQ1 interrupts -#define PIC_MASK_NO_IRQ2 0x04 // prevent IRQ2 interrupts -#define PIC_MASK_NO_IRQ3 0x08 // prevent IRQ3 interrupts -#define PIC_MASK_NO_IRQ4 0x10 // prevent IRQ4 interrupts -#define PIC_MASK_NO_IRQ5 0x20 // prevent IRQ5 interrupts -#define PIC_MASK_NO_IRQ6 0x40 // prevent IRQ6 interrupts -#define PIC_MASK_NO_IRQ7 0x80 // prevent IRQ7 interrupts -#define PIC_MASK_ALL 0xff // prevent all interrupts - -/* -** OCW2: EOI control, interrupt level; send to command port -*/ -#define PIC_LVL_0 0x00 // act on IRQ level 0 -#define PIC_LVL_1 0x01 // act on IRQ level 1 -#define PIC_LVL_2 0x02 // act on IRQ level 2 -#define PIC_LVL_3 0x03 // act on IRQ level 3 -#define PIC_LVL_4 0x04 // act on IRQ level 4 -#define PIC_LVL_5 0x05 // act on IRQ level 5 -#define PIC_LVL_6 0x06 // act on IRQ level 6 -#define PIC_LVL_7 0x07 // act on IRQ level 7 - -#define PIC_EOI_NON_SPEC 0x20 // non-specific EOI command -# define PIC_EOI PIC_EOI_NON_SPEC - -#define PIC_EOI_SPEC 0x60 // specific EOI command -# define PIC_SEOI PIC_EOI_SPEC -# define PIC_SEOI_LVL0 (PIC_EOI_SPEC | PIC_LVL_0) -# define PIC_SEOI_LVL1 (PIC_EOI_SPEC | PIC_LVL_1) -# define PIC_SEOI_LVL2 (PIC_EOI_SPEC | PIC_LVL_2) -# define PIC_SEOI_LVL3 (PIC_EOI_SPEC | PIC_LVL_3) -# define PIC_SEOI_LVL4 (PIC_EOI_SPEC | PIC_LVL_4) -# define PIC_SEOI_LVL5 (PIC_EOI_SPEC | PIC_LVL_5) -# define PIC_SEOI_LVL6 (PIC_EOI_SPEC | PIC_LVL_6) -# define PIC_SEOI_LVL7 (PIC_EOI_SPEC | PIC_LVL_7) - -#define PIC_EOI_ROT_NONSP 0xa0 // rotate on non-spec EOI cmd -#define PIC_EOI_SET_ROT_AUTO 0x80 // set "rotate in auto EOI mode" -#define PIC_EOI_CLR_ROT_AUTO 0x00 // clear "rotate in auto EOI mode" -#define PIC_EOI_ROT_SPEC 0xe0 // rotate on spec EOI cmd (+ level) -#define PIC_EOI_SET_PRIO 0xc0 // set priority (+ level) -#define PIC_EOI_NOP 0x40 // no operation - -/* -** OCW3: read requests, special mask mode; send to command port -*/ -#define PIC_READIRR 0x0a // read the IR register -#define PIC_READISR 0x0b // read the IS register -#define PIC_POLL 0x0c // poll -#define PIC_MASK_RESET 0x48 // reset special mask mode -#define PIC_MASK_SET 0x68 // set special mask mode - -#endif diff --git a/kernel/old/include/x86/pit.h b/kernel/old/include/x86/pit.h deleted file mode 100644 index 269fcec..0000000 --- a/kernel/old/include/x86/pit.h +++ /dev/null @@ -1,82 +0,0 @@ -/* -** @file pit.h -** -** @author Warren R. Carithers -** @author K. Reek -** -** Definitions of constants and macros for the -** Intel 8254 Programmable Interval Timer -** -*/ - -#ifndef X86PIT_H_ -#define X86PIT_H_ - - -/* -** Hardware timer (Intel 8254 Programmable Interval Timer) -** -** Control word layout: -** -** Bit 7 6 | 5 4 | 3 2 1 | 0 -** Field SC1 SC0|RW1 RW0|M2 M1 M0 |BCD -** -** SC - select counter -** RW - read/write -** M - mode -** BCD - binary or BCD counter -*/ - -/* Frequency settings */ -#define PIT_DEFAULT_TICKS_PER_SECOND 18 // actually 18.2065Hz -#define PIT_DEFAULT_MS_PER_TICK (1000/PIT_DEFAULT_TICKS_PER_SECOND) -#define PIT_FREQ 1193182 // clock cycles/sec - -/* Port assignments */ -#define PIT_BASE_PORT 0x40 // I/O port for the timer -# define PIT_0_PORT (PIT_BASE_PORT) -# define PIT_1_PORT (PIT_BASE_PORT+1) -# define PIT_2_PORT (PIT_BASE_PORT+2) -# define PIT_CONTROL_PORT (PIT_BASE_PORT+3) - -/* BCD field */ -#define PIT_USE_DECIMAL 0x00 // 16-bit binary counter (default) -#define PIT_USE_BCD 0x01 // BCD counter - -/* Timer modes */ -#define PIT_MODE_0 0x00 // int on terminal count -#define PIT_MODE_1 0x02 // one-shot -#define PIT_MODE_2 0x04 // divide-by-N -#define PIT_MODE_3 0x06 // square-wave -#define PIT_MODE_4 0x08 // software strobe -#define PIT_MODE_5 0x0a // hardware strobe - -/* Timer 0 settings */ -#define PIT_0_SELECT 0x00 // select timer 0 -#define PIT_0_LOAD 0x30 // load LSB, then MSB -#define PIT_0_NDIV PIT_MODE_2 // divide-by-N counter -#define PIT_0_SQUARE PIT_MODE_3 // square-wave mode -#define PIT_0_ENDSIGNAL 0x00 // assert OUT at end of count - -/* Timer 1 settings */ -#define PIT_1_SELECT 0x40 // select timer 1 -#define PIT_1_READ 0x30 // read/load LSB then MSB -#define PIT_1_RATE 0x06 // square-wave, for USART - -/* Timer 2 settings */ -#define PIT_2_SELECT 0x80 // select timer 1 -#define PIT_2_READ 0x30 // read/load LSB then MSB -#define PIT_2_RATE 0x06 // square-wave, for USART - -/* Timer read-back */ -#define PIT_READBACK 0xc0 // perform a read-back -#define PIT_RB_NOT_COUNT 0x20 // don't latch the count -#define PIT_RB_NOT_STATUS 0x10 // don't latch the status -#define PIT_RB_CHAN_2 0x08 // read back channel 2 -#define PIT_RB_CHAN_1 0x04 // read back channel 1 -#define PIT_RB_CHAN_0 0x02 // read back channel 0 -#define PIT_RB_ACCESS_MASK 0x30 // access mode field -#define PIT_RB_OP_MASK 0x0e // oper mode field -#define PIT_RB_BCD_MASK 0x01 // BCD mode field - -#endif diff --git a/kernel/old/include/x86/uart.h b/kernel/old/include/x86/uart.h deleted file mode 100644 index 0c6194b..0000000 --- a/kernel/old/include/x86/uart.h +++ /dev/null @@ -1,349 +0,0 @@ -/* -** @file uart.h -** -** @author M. Reek -** @authors K. Reek, Warren R. Carithers -** -** Definitions for a 16540/16550 compatible UART. Definitions are taken -** from datasheets for the National Semiconductor INS8250, NS16450, and -** NS16550 UART chips, and the PC87309 Super I/O legacy peripheral chip. -** -** The naming convention is UAx_yyy_zzzzz. "x" is either 4 or 5 (see below), -** "yyy" is the name of the register to which this value applies, and -** "zzzzz" is the name of the value or field. -** -** The UA4 prefix denotes 16540 compatible functions, available in both -** chips. The UA5 prefix denotes 16550-only functions (primarily the FIFOs). -** -** For many items there are two names: one short one that matches the name -** in the chip manual, and another that is more readable. -*/ - -#ifndef UART_H -#define UART_H - -/********************************************************************* -***************************** I/O PORTS ****************************** -*********************************************************************/ - -/* -** Base port number assigned to the device -*/ -#define UA4_COM1_PORT 0x3f8 -#define UA4_COM2_PORT 0x2f8 -#define UA4_COM3_PORT 0x3e8 -#define UA4_COM4_PORT 0x2e8 - -// short name for the one we'll use -#define UA4_PORT UA4_COM1_PORT -#define UA5_PORT UA4_COM1_PORT - -/* -** Registers -** -** The 164x0 chips have the following registers. The (RO) and (WO) -** suffixes indicate read-only and write-only access. -** -** Index Register(s) -** ===== ========================================= -** 0 Receiver Data (RO), Transmitter Data (WO) -** 1 Interrupt Enable -** 2 Interrupt ID (RO), FIFO Control (WO) -** 3 Line Control, Divisor Latch -** 4 Modem Control -** 5 Line Status -** 6 Modem Status -** 7 Scratch -** -** Registers indices are relative to the base I/O port for the -** specific UART port being used (e.g., for COM1, the port addresses -** are 0x3f8 through 0x3ff). When two registers share a port and have -** different access methods (RO vs. WO), a read from the port accesses -** the RO register and a write to the port access the WO register. -** -** The Line Control and Divisor Latch registers are accessed by writing -** a byte to the port; the high-order bit determines which register is -** accessed (0 selects Line Control, 1 selects Divisor Latch), with the -** remaining bits selecting fields within the indicated register. -*/ - -/* -** Receiver Data Register (read-only) -*/ -#define UA4_RXD (UA4_PORT+0) -# define UA4_RX_DATA UA4_RXD - -/* -** Transmitter Data Register (write-only) -*/ -#define UA4_TXD (UA4_PORT+0) -# define UA4_TX_DATA UA4_TXD - -/* -** Interrupt Enable Register -*/ -#define UA4_IER (UA4_PORT+1) -# define UA4_INT_ENABLE_REG UA4_IER - -// fields -#define UA4_IER_RX_IE 0x01 // Rcvr High-Data-Level Int Enable -#define UA4_IER_TX_IE 0x02 // Xmitter Low-data-level Int Enable -#define UA4_IER_LS_IE 0x04 // Line Status Int Enable -#define UA4_IER_MS_IE 0x08 // Modem Status Int Enable - -// aliases -#define UA4_IER_RX_INT_ENABLE UA4_IER_RX_IE -#define UA4_IER_TX_INT_ENABLE UA4_IER_TX_IE -#define UA4_IER_LINE_STATUS_INT_ENABLE UA4_IER_LS_IE -#define UA4_IER_MODEM_STATUS_INT_ENABLE UA4_IER_MS_IE - -/* -** Interrupt Identification Register (read-only) -** -** a.k.a. Event Identification Register -*/ -#define UA4_IIR (UA4_PORT+2) -# define UA4_EVENT_ID UA4_IIR - -// fields -#define UA4_IIR_IPF 0x01 // Interrupt Pending flag - -#define UA4_IIR_IPR_MASK 0x06 // Interrupt Priority mask -# define UA4_IIR_IPR0_MASK 0x02 // IPR bit 0 mask -# define UA4_IIR_IPR1_MASK 0x04 // IPR bit 1 mask - -#define UA5_IIR_RXFT 0x08 // RX_FIFO Timeout -#define UA5_IIR_FEN0 0x40 // FIFOs Enabled -#define UA5_IIR_FEN1 0x80 // FIFOs Enabled - -// aliases -#define UA4_IIR_INT_PENDING UA4_IIR_IPF -#define UA4_IIR_INT_PRIORITY UA4_IIR_IPR -#define UA5_IIR_RX_FIFO_TIMEOUT UA5_IIR_RXFT -#define UA5_IIR_FIFO_ENABLED_0 UA5_IIR_FEN0 -#define UA5_IIR_FIFO_ENABLED_1 UA5_IIR_FEN1 - -// IIR interrupt priorities (four-bit values) -#define UA4_IIR_INT_PRI_MASK 0x0f // Mask for extracting int priority -# define UA4_IIR_NO_INT 0x01 // no interrupt -# define UA4_IIR_LINE_STATUS 0x06 // line status interrupt -# define UA4_IIR_RX 0x04 // Receiver High Data Level -# define UA5_IIR_RX_FIFO 0x0c // Receiver FIFO timeout (16550) -# define UA4_IIR_TX 0x02 // Transmitter Low Data level -# define UA4_IIR_MODEM_STATUS 0x00 // Modem Status - -// aliases -#define UA4_IIR_NO_INT_PENDING UA4_IIR_NO_INT -#define UA4_IIR_LINE_STATUS_INT_PENDING UA4_IIR_LINE_STATUS -#define UA4_IIR_RX_INT_PENDING UA4_IIR_RX -#define UA5_IIR_RX_FIFO_TIMEOUT_INT_PENDING UA5_IIR_RX_FIFO -#define UA4_IIR_TX_INT_PENDING UA4_IIR_TX -#define UA4_IIR_MODEM_STATUS_INT_PENDING UA4_IIR_MODEM_STATUS - -/* -** FIFO Control Register (16550 only, write-only) -*/ -#define UA5_FCR (UA5_PORT+2) -# define UA5_FIFO_CTL UA5_FCR - -#define UA5_FCR_FIFO_RESET 0x00 // Reset the FIFO -#define UA5_FCR_FIFO_EN 0x01 // FIFO Enable -#define UA5_FCR_RXSR 0x02 // Receiver Soft Reset -#define UA5_FCR_TXSR 0x04 // Transmitter Soft Reset - -#define UA5_FCR_TXFT_MASK 0x30 // TX_FIFO threshold level mask -# define UA5_FCR_TXFT0_MASK 0x10 // TXFT bit 0 mask -# define UA5_FCR_TXFT1_MASK 0x20 // TXFT bit 1 mask -# define UA5_FCR_TX_FIFO_1 0x00 // 1 char -# define UA5_FCR_TX_FIFO_3 0x10 // 3 char -# define UA5_FCR_TX_FIFO_9 0x20 // 9 char -# define UA5_FCR_TX_FIFO_13 0x30 // 13 char - -#define UA5_FCR_RXFT_MASK 0xc0 // RX_FIFO threshold level mask -# define UA5_FCR_RXFT0_MASK 0x40 // RXFT bit 0 mask -# define UA5_FCR_RXFT1_MASK 0x80 // RXFT bit 1 mask -# define UA5_FCR_RX_FIFO_1 0x00 // 1 char -# define UA5_FCR_RX_FIFO_4 0x40 // 4 char -# define UA5_FCR_RX_FIFO_8 0x80 // 8 char -# define UA5_FCR_RX_FIFO_14 0xc0 // 14 char - -// aliases -#define UA5_FCR_FIFO_ENABLED UA5_FCR_FIFO_EN -#define UA5_FCR_RX_SOFT_RESET UA5_FCR_RXSR -#define UA5_FCR_TX_SOFT_RESET UA5_FCR_TXSR -#define UA5_FCR_TX_FIFO_1_CHAR UA5_FCR_TX_FIFO_1 -#define UA5_FCR_TX_FIFO_3_CHAR UA5_FCR_TX_FIFO_3 -#define UA5_FCR_TX_FIFO_9_CHAR UA5_FCR_TX_FIFO_9 -#define UA5_FCR_TX_FIFO_13_CHAR UA5_FCR_TX_FIFO_13 -#define UA5_FCR_RX_FIFO_1_CHAR UA5_FCR_RX_FIFO_1 -#define UA5_FCR_RX_FIFO_4_CHAR UA5_FCR_RX_FIFO_4 -#define UA5_FCR_RX_FIFO_8_CHAR UA5_FCR_RX_FIFO_8 -#define UA5_FCR_RX_FIFO_14_CHAR UA5_FCR_RX_FIFO_14 - -/* -** Line Control Register (available in all banks) -** -** Selected when bit 7 of the value written to the port is a 0. -*/ -#define UA4_LCR (UA4_PORT+3) -# define UA4_LINE_CTL UA4_LCR - -#define UA4_LCR_WLS_MASK 0x03 // Word Length Select mask -# define UA4_LCR_WLS0_MASK 0x01 // WLS bit 0 mask -# define UA4_LCR_WLS1_MASK 0x02 // WLS bit 1 mask -# define UA4_LCR_WLS_5 0x00 // 5 bits per char -# define UA4_LCR_WLS_6 0x01 // 6 bits per char -# define UA4_LCR_WLS_7 0x02 // 7 bits per char -# define UA4_LCR_WLS_8 0x03 // 8 bits per char - -#define UA4_LCR_STB 0x04 // Stop Bits -# define UA4_LCR_1_STOP_BIT 0x00 -# define UA4_LCR_2_STOP_BIT 0x04 - -#define UA4_LCR_PEN 0x08 // Parity Enable -#define UA4_LCR_EPS 0x10 // Even Parity Select -#define UA4_LCR_STKP 0x20 // Sticky Parity -# define UA4_LCR_NO_PARITY 0x00 -# define UA4_LCR_ODD_PARITY UA4_LCR_PEN -# define UA4_LCR_EVEN_PARITY (UA4_LCR_PEN|UA4_LCR_EPS) -# define UA4_LCR_PARITY_LOGIC_1 (UA4_LCR_PEN|UA4_LCR_STKP) -# define UA4_LCR_PARITY_LOGIC_0 (UA4_LCR_PEN|UA4_LCR_EPS|UA4_LCR_STKP) - -#define UA4_LCR_SBRK 0x40 // Set Break -#define UA4_LCR_DLAB 0x80 // Divisor Latch select bit - -// aliases -# define UA4_LCR_STOP_BITS UA4_LCR_STB -# define UA4_LCR_PARITY_ENABLE UA4_LCR_PEN -# define UA4_LCR_SET_BREAK UA4_LCR_SBRK -# define UA4_LCR_BANK_SELECT_ENABLE UA4_LCR_BKSE - -/* -** Divisor Latch Registers -** Divisor Latch Least Significant (DLL) -** Divisor Latch Most Significant (DLM) -** -** These contain the lower and upper halves of the 16-bit divisor for -** baud rate generation. -** -** Accessing them requires sending a command to LCR with the most -** significant bit (0x80, the DLAB field) set. This "unlocks" the -** Divisor Latch registers, which are accessed at UA4_PORT+0 and -** UA4_PORT+1 (i.e., in place of the RXD/TXD and IE registers). To -** "re-lock" the Divisor Latch registers, write a command byte to -** LCR with 0 in the DLAB bit. -*/ -#define UA4_DLL (UA4_PORT+0) // Divisor Latch (least sig.) -#define UA4_DLM (UA4_PORT+1) // Divisor Latch (most sig.) - -// aliases -#define UA4_DIVISOR_LATCH_LS UA4_DLL -#define UA4_DIVISOR_LATCH_MS UA4_DLM - -// Baud rate divisor high and low bytes -#define BAUD_HIGH_BYTE(x) (((x) >> 8) & 0xff) -#define BAUD_LOW_BYTE(x) ((x) & 0xff) - -// Baud rate divisors -#define DL_BAUD_50 2304 -#define DL_BAUD_75 1536 -#define DL_BAUD_110 1047 -#define DL_BAUD_150 768 -#define DL_BAUD_300 384 -#define DL_BAUD_600 192 -#define DL_BAUD_1200 96 -#define DL_BAUD_1800 64 -#define DL_BAUD_2000 58 -#define DL_BAUD_2400 48 -#define DL_BAUD_3600 32 -#define DL_BAUD_4800 24 -#define DL_BAUD_7200 16 -#define DL_BAUD_9600 12 -#define DL_BAUD_14400 8 -#define DL_BAUD_19200 6 -#define DL_BAUD_28800 4 -#define DL_BAUD_38400 3 -#define DL_BAUD_57600 2 -#define DL_BAUD_115200 1 - -/* -** Modem Control Register -*/ -#define UA4_MCR (UA4_PORT+4) -# define UA4_MODEM_CTL UA4_MCR - -#define UA4_MCR_DTR 0x01 // Data Terminal Ready -#define UA4_MCR_RTS 0x02 // Ready to Send -#define UA4_MCR_RILP 0x04 // Loopback Interrupt Request -#define UA4_MCR_ISEN 0x08 // Interrupt Signal Enable -#define UA4_MCR_DCDLP 0x08 // DCD Loopback -#define UA4_MCR_LOOP 0x10 // Loopback Enable - -// aliases -#define UA4_MCR_DATA_TERMINAL_READY UA4_MCR_DTR -#define UA4_MCR_READY_TO_SEND UA4_MCR_RTS -#define UA4_MCR_LOOPBACK_INT_REQ UA4_MCR_RILP -#define UA4_MCR_INT_SIGNAL_ENABLE UA4_MCR_ISEN -#define UA4_MCR_LOOPBACK_DCD UA4_MCR_DCDLP -#define UA4_MCR_LOOPBACK_ENABLE UA4_MCR_LOOP - -/* -** Line Status Register -*/ -#define UA4_LSR (UA4_PORT+5) -# define UA4_LINE_STATUS UA4_LSR - -#define UA4_LSR_RXDA 0x01 // Receiver Data Available -#define UA4_LSR_OE 0x02 // Overrun Error -#define UA4_LSR_PE 0x04 // Parity Error -#define UA4_LSR_FE 0x08 // Framing Error -#define UA4_LSR_BRK 0x10 // Break Event Detected -#define UA4_LSR_TXRDY 0x20 // Transmitter Ready -#define UA4_LSR_TXEMP 0x40 // Transmitter Empty -#define UA4_LSR_ER_INF 0x80 // Error in RX_FIFO - -// aliases -#define UA4_LSR_RX_DATA_AVAILABLE UA4_LSR_RXDA -#define UA4_LSR_OVERRUN_ERROR UA4_LSR_OE -#define UA4_LSR_PARITY_ERROR UA4_LSR_PE -#define UA4_LSR_FRAMING_ERROR UA4_LSR_FE -#define UA4_LSR_BREAK_DETECTED UA4_LSR_BRK -#define UA4_LSR_TX_READY UA4_LSR_TXRDY -#define UA4_LSR_TX_EMPTY UA4_LSR_TXEMP -#define UA4_LSR_RX_FIFO_ERROR UA4_LSR_ER_INF - -/* -** Modem Status Register -*/ -#define UA4_MSR (UA4_PORT+6) -# define UA4_MODEM_STATUS UA4_MSR - -#define UA4_MSR_DCTS 0x01 // Delta Clear to Send -#define UA4_MSR_DDSR 0x02 // Delta Data Set Ready -#define UA4_MSR_TERI 0x04 // Trailing Edge Ring Indicate -#define UA4_MSR_DDCD 0x08 // Delta Data Carrier Detect -#define UA4_MSR_CTS 0x10 // Clear to Send -#define UA4_MSR_DSR 0x20 // Data Set Ready -#define UA4_MSR_RI 0x40 // Ring Indicate -#define UA4_MSR_DCD 0x80 // Data Carrier Detect - -// aliases -#define UA4_MSR_DELTA_CLEAR_TO_SEND UA4_MSR_DCTS -#define UA4_MSR_DELTA_DATA_SET_READY UA4_MSR_DDSR -#define UA4_MSR_TRAILING_EDGE_RING UA4_MSR_TERI -#define UA4_MSR_DELTA_DATA_CARRIER_DETECT UA4_MSR_DDCD -#define UA4_MSR_CLEAR_TO_SEND UA4_MSR_CTS -#define UA4_MSR_DATA_SET_READY UA4_MSR_DSR -#define UA4_MSR_RING_INDICATE UA4_MSR_RI -#define UA4_MSR_DATA_CARRIER_DETECT UA4_MSR_DCD - -/* -** Scratch Register -** -** Not used by the UART; usable as a "scratchpad" register for -** temporary storage. -*/ -#define UA4_SCR (UA4_PORT+7) -# define UA4_SCRATCH UA4_UA5_SCR - -#endif /* uart.h */ diff --git a/kernel/old/isrs.S b/kernel/old/isrs.S deleted file mode 100644 index f6bd662..0000000 --- a/kernel/old/isrs.S +++ /dev/null @@ -1,374 +0,0 @@ -/* -** @file isrs.S -** -** @author K. Reek -** @authors Jon Coles, Warren R. Carithers, Margaret Reek -** @author numerous Systems Programming classes -** -** Stubs for ISRs. -** -** This module provides the stubs needed for interrupts to save -** the machine state before calling the ISR. All interrupts have -** their own stub which pushes the interrupt number on the stack. -** This makes it possible for a common ISR to determine which -** interrupted occurred. -*/ - -#define ASM_SRC - -# .arch i386 - -#include <bootstrap.h> - -/* -** Configuration options - define in Makefile -** -** TRACE_CX include context restore debugging code -*/ - - .text - -/* -** Macros for the isr stubs. Some interrupts push an error code on -** the stack and others don't; for those that don't we simply push -** a zero so that cleaning up from either type is identical. -** -** Note: these are not marked as global symbols, as they are never -** accessed directly outside of this file. This could be changed -** if need be by adding this line to each macro definition right -** after the #define line: -** -** .global isr_##vector -*/ - -#define ISR(vector) \ -isr_##vector: ; \ - pushl $0 ; \ - pushl $vector ; \ - jmp isr_save - -#define ERR_ISR(vector) \ -isr_##vector: ; \ - pushl $vector ; \ - jmp isr_save - - .globl isr_table - .globl isr_restore - -/* -** This routine saves the machine state, calls the ISR, and then -** restores the machine state and returns from the interrupt. -** -******************************************************************** -******************************************************************** -** NOTE: this code is highly application-specific, and will most ** -** probably require modification to tailor it. ** -** ** -** Examples of mods: switch to/from user stack, context switch ** -** changes, etc. ** -******************************************************************** -******************************************************************** -*/ - -isr_save: - -/* -** Begin by saving the CPU state (except for the FP context information). -** -** At this point, the stack looks like this: -** -** esp -> vector # saved by the entry macro -** error code, or 0 saved by the hardware, or the entry macro -** saved EIP saved by the hardware -** saved CS saved by the hardware -** saved EFLAGS saved by the hardware -*/ - pusha // save E*X, ESP, EBP, ESI, EDI - pushl %ds // save segment registers - pushl %es - pushl %fs - pushl %gs - pushl %ss - -/* -** Stack contents (all 32-bit longwords) and offsets from ESP: -** -** SS GS FS ES DS EDI ESI EBP ESP EBX EDX ECX EAX vec cod EIP CS EFL -** 0 4 8 12 16 20 24 28 32 36 40 44 48 52 56 60 64 68 -** -** Note that the saved ESP is the contents before the PUSHA. -** -** Set up parameters for the ISR call. -*/ - movl 52(%esp),%eax // get vector number and error code - movl 56(%esp),%ebx - -/* -*********************** -** MOD FOR 20245 ** -*********************** -*/ - -/* -** We need to switch to the system stack. This requires that we save -** the user context pointer into the current PCB, then load ESP with -** the initial system stack pointer. -*/ - - .globl current - .globl kernel_esp - - // save the context pointer - movl current, %edx - movl %esp, (%edx) - - // also save the page directory pointer - movl %cr3, %ecx - movl %ecx, 4(%edx) - - // switch to the system stack - // - // NOTE: this is inherently non-reentrant! If/when the OS - // is converted from monolithic to something that supports - // reentrant or interruptable ISRs, this code will need to - // be changed to support that! - - movl kernel_esp, %esp - - // we don't change CR3 because all the user PDIRs are - // set up with mappings for the OS in the upper half - -/* -*********************** -** END MOD FOR 20245 ** -*********************** -*/ - - pushl %ebx // put them on the top of the stack ... - pushl %eax // ... as parameters for the ISR - -/* -** Call the ISR -*/ - movl isr_table(,%eax,4),%ebx - call *%ebx - addl $8,%esp // pop the two parameters - -/* -** Context restore begins here -*/ - -isr_restore: - -/* -*********************** -** MOD FOR 20245 ** -*********************** -*/ - movl current, %ebx // return to the user stack - movl (%ebx), %esp // ESP --> context save area - movl 4(%ebx), %ecx // page directory pointer - movl %ecx, %cr3 - - // now we're operating with the user process' - // page directory and stack - -/* -*********************** -** END MOD FOR 20245 ** -*********************** -*/ - -#ifdef TRACE_CX -/* -** DEBUGGING CODE PART 1 -** -** This code will execute during each context restore, and -** should be modified to print out whatever debugging information -** is desired. -** -** By default, it prints out the CPU context being restored; it -** relies on the standard save sequence (see above). -*/ - .globl cio_printf_at - - pushl $fmt - pushl $1 - pushl $0 - call cio_printf_at - addl $12,%esp -/* -** END OF DEBUGGING CODE PART 1 -*/ -#endif - -/* -** Restore the context. -*/ - popl %ss // restore the segment registers - popl %gs - popl %fs - popl %es - popl %ds - popa // restore others - addl $8, %esp // discard the error code and vector - iret // and return - -#ifdef TRACE_CX -/* -** DEBUGGING CODE PART 2 -** -** This format string is arranged according to the ordering of values -** in the context save area on the stack. -*/ -fmt: .ascii " ss=%08x gs=%08x fs=%08x es=%08x ds=%08x\n" - .ascii "edi=%08x esi=%08x ebp=%08x esp=%08x ebx=%08x\n" - .ascii "edx=%08x ecx=%08x eax=%08x vec=%08x cod=%08x\n" - .string "eip=%08x cs=%08x efl=%08x\n" - -/* -** END OF DEBUGGING CODE PART 2 -*/ -#endif - -/* -** Here we generate the individual stubs for each interrupt. -*/ -ISR(0x00); ISR(0x01); ISR(0x02); ISR(0x03); -ISR(0x04); ISR(0x05); ISR(0x06); ISR(0x07); -ERR_ISR(0x08); ISR(0x09); ERR_ISR(0x0a); ERR_ISR(0x0b); -ERR_ISR(0x0c); ERR_ISR(0x0d); ERR_ISR(0x0e); ISR(0x0f); -ISR(0x10); ERR_ISR(0x11); ISR(0x12); ISR(0x13); -ISR(0x14); ERR_ISR(0x15); ISR(0x16); ISR(0x17); -ISR(0x18); ISR(0x19); ISR(0x1a); ISR(0x1b); -ISR(0x1c); ISR(0x1d); ISR(0x1e); ISR(0x1f); -ISR(0x20); ISR(0x21); ISR(0x22); ISR(0x23); -ISR(0x24); ISR(0x25); ISR(0x26); ISR(0x27); -ISR(0x28); ISR(0x29); ISR(0x2a); ISR(0x2b); -ISR(0x2c); ISR(0x2d); ISR(0x2e); ISR(0x2f); -ISR(0x30); ISR(0x31); ISR(0x32); ISR(0x33); -ISR(0x34); ISR(0x35); ISR(0x36); ISR(0x37); -ISR(0x38); ISR(0x39); ISR(0x3a); ISR(0x3b); -ISR(0x3c); ISR(0x3d); ISR(0x3e); ISR(0x3f); -ISR(0x40); ISR(0x41); ISR(0x42); ISR(0x43); -ISR(0x44); ISR(0x45); ISR(0x46); ISR(0x47); -ISR(0x48); ISR(0x49); ISR(0x4a); ISR(0x4b); -ISR(0x4c); ISR(0x4d); ISR(0x4e); ISR(0x4f); -ISR(0x50); ISR(0x51); ISR(0x52); ISR(0x53); -ISR(0x54); ISR(0x55); ISR(0x56); ISR(0x57); -ISR(0x58); ISR(0x59); ISR(0x5a); ISR(0x5b); -ISR(0x5c); ISR(0x5d); ISR(0x5e); ISR(0x5f); -ISR(0x60); ISR(0x61); ISR(0x62); ISR(0x63); -ISR(0x64); ISR(0x65); ISR(0x66); ISR(0x67); -ISR(0x68); ISR(0x69); ISR(0x6a); ISR(0x6b); -ISR(0x6c); ISR(0x6d); ISR(0x6e); ISR(0x6f); -ISR(0x70); ISR(0x71); ISR(0x72); ISR(0x73); -ISR(0x74); ISR(0x75); ISR(0x76); ISR(0x77); -ISR(0x78); ISR(0x79); ISR(0x7a); ISR(0x7b); -ISR(0x7c); ISR(0x7d); ISR(0x7e); ISR(0x7f); -ISR(0x80); ISR(0x81); ISR(0x82); ISR(0x83); -ISR(0x84); ISR(0x85); ISR(0x86); ISR(0x87); -ISR(0x88); ISR(0x89); ISR(0x8a); ISR(0x8b); -ISR(0x8c); ISR(0x8d); ISR(0x8e); ISR(0x8f); -ISR(0x90); ISR(0x91); ISR(0x92); ISR(0x93); -ISR(0x94); ISR(0x95); ISR(0x96); ISR(0x97); -ISR(0x98); ISR(0x99); ISR(0x9a); ISR(0x9b); -ISR(0x9c); ISR(0x9d); ISR(0x9e); ISR(0x9f); -ISR(0xa0); ISR(0xa1); ISR(0xa2); ISR(0xa3); -ISR(0xa4); ISR(0xa5); ISR(0xa6); ISR(0xa7); -ISR(0xa8); ISR(0xa9); ISR(0xaa); ISR(0xab); -ISR(0xac); ISR(0xad); ISR(0xae); ISR(0xaf); -ISR(0xb0); ISR(0xb1); ISR(0xb2); ISR(0xb3); -ISR(0xb4); ISR(0xb5); ISR(0xb6); ISR(0xb7); -ISR(0xb8); ISR(0xb9); ISR(0xba); ISR(0xbb); -ISR(0xbc); ISR(0xbd); ISR(0xbe); ISR(0xbf); -ISR(0xc0); ISR(0xc1); ISR(0xc2); ISR(0xc3); -ISR(0xc4); ISR(0xc5); ISR(0xc6); ISR(0xc7); -ISR(0xc8); ISR(0xc9); ISR(0xca); ISR(0xcb); -ISR(0xcc); ISR(0xcd); ISR(0xce); ISR(0xcf); -ISR(0xd0); ISR(0xd1); ISR(0xd2); ISR(0xd3); -ISR(0xd4); ISR(0xd5); ISR(0xd6); ISR(0xd7); -ISR(0xd8); ISR(0xd9); ISR(0xda); ISR(0xdb); -ISR(0xdc); ISR(0xdd); ISR(0xde); ISR(0xdf); -ISR(0xe0); ISR(0xe1); ISR(0xe2); ISR(0xe3); -ISR(0xe4); ISR(0xe5); ISR(0xe6); ISR(0xe7); -ISR(0xe8); ISR(0xe9); ISR(0xea); ISR(0xeb); -ISR(0xec); ISR(0xed); ISR(0xee); ISR(0xef); -ISR(0xf0); ISR(0xf1); ISR(0xf2); ISR(0xf3); -ISR(0xf4); ISR(0xf5); ISR(0xf6); ISR(0xf7); -ISR(0xf8); ISR(0xf9); ISR(0xfa); ISR(0xfb); -ISR(0xfc); ISR(0xfd); ISR(0xfe); ISR(0xff); - - .data - -/* -** This table contains the addresses where each of the preceding -** stubs begins. This information is needed to initialize the -** Interrupt Descriptor Table in support.c -*/ - .globl isr_stub_table -isr_stub_table: - .long isr_0x00, isr_0x01, isr_0x02, isr_0x03 - .long isr_0x04, isr_0x05, isr_0x06, isr_0x07 - .long isr_0x08, isr_0x09, isr_0x0a, isr_0x0b - .long isr_0x0c, isr_0x0d, isr_0x0e, isr_0x0f - .long isr_0x10, isr_0x11, isr_0x12, isr_0x13 - .long isr_0x14, isr_0x15, isr_0x16, isr_0x17 - .long isr_0x18, isr_0x19, isr_0x1a, isr_0x1b - .long isr_0x1c, isr_0x1d, isr_0x1e, isr_0x1f - .long isr_0x20, isr_0x21, isr_0x22, isr_0x23 - .long isr_0x24, isr_0x25, isr_0x26, isr_0x27 - .long isr_0x28, isr_0x29, isr_0x2a, isr_0x2b - .long isr_0x2c, isr_0x2d, isr_0x2e, isr_0x2f - .long isr_0x30, isr_0x31, isr_0x32, isr_0x33 - .long isr_0x34, isr_0x35, isr_0x36, isr_0x37 - .long isr_0x38, isr_0x39, isr_0x3a, isr_0x3b - .long isr_0x3c, isr_0x3d, isr_0x3e, isr_0x3f - .long isr_0x40, isr_0x41, isr_0x42, isr_0x43 - .long isr_0x44, isr_0x45, isr_0x46, isr_0x47 - .long isr_0x48, isr_0x49, isr_0x4a, isr_0x4b - .long isr_0x4c, isr_0x4d, isr_0x4e, isr_0x4f - .long isr_0x50, isr_0x51, isr_0x52, isr_0x53 - .long isr_0x54, isr_0x55, isr_0x56, isr_0x57 - .long isr_0x58, isr_0x59, isr_0x5a, isr_0x5b - .long isr_0x5c, isr_0x5d, isr_0x5e, isr_0x5f - .long isr_0x60, isr_0x61, isr_0x62, isr_0x63 - .long isr_0x64, isr_0x65, isr_0x66, isr_0x67 - .long isr_0x68, isr_0x69, isr_0x6a, isr_0x6b - .long isr_0x6c, isr_0x6d, isr_0x6e, isr_0x6f - .long isr_0x70, isr_0x71, isr_0x72, isr_0x73 - .long isr_0x74, isr_0x75, isr_0x76, isr_0x77 - .long isr_0x78, isr_0x79, isr_0x7a, isr_0x7b - .long isr_0x7c, isr_0x7d, isr_0x7e, isr_0x7f - .long isr_0x80, isr_0x81, isr_0x82, isr_0x83 - .long isr_0x84, isr_0x85, isr_0x86, isr_0x87 - .long isr_0x88, isr_0x89, isr_0x8a, isr_0x8b - .long isr_0x8c, isr_0x8d, isr_0x8e, isr_0x8f - .long isr_0x90, isr_0x91, isr_0x92, isr_0x93 - .long isr_0x94, isr_0x95, isr_0x96, isr_0x97 - .long isr_0x98, isr_0x99, isr_0x9a, isr_0x9b - .long isr_0x9c, isr_0x9d, isr_0x9e, isr_0x9f - .long isr_0xa0, isr_0xa1, isr_0xa2, isr_0xa3 - .long isr_0xa4, isr_0xa5, isr_0xa6, isr_0xa7 - .long isr_0xa8, isr_0xa9, isr_0xaa, isr_0xab - .long isr_0xac, isr_0xad, isr_0xae, isr_0xaf - .long isr_0xb0, isr_0xb1, isr_0xb2, isr_0xb3 - .long isr_0xb4, isr_0xb5, isr_0xb6, isr_0xb7 - .long isr_0xb8, isr_0xb9, isr_0xba, isr_0xbb - .long isr_0xbc, isr_0xbd, isr_0xbe, isr_0xbf - .long isr_0xc0, isr_0xc1, isr_0xc2, isr_0xc3 - .long isr_0xc4, isr_0xc5, isr_0xc6, isr_0xc7 - .long isr_0xc8, isr_0xc9, isr_0xca, isr_0xcb - .long isr_0xcc, isr_0xcd, isr_0xce, isr_0xcf - .long isr_0xd0, isr_0xd1, isr_0xd2, isr_0xd3 - .long isr_0xd4, isr_0xd5, isr_0xd6, isr_0xd7 - .long isr_0xd8, isr_0xd9, isr_0xda, isr_0xdb - .long isr_0xdc, isr_0xdd, isr_0xde, isr_0xdf - .long isr_0xe0, isr_0xe1, isr_0xe2, isr_0xe3 - .long isr_0xe4, isr_0xe5, isr_0xe6, isr_0xe7 - .long isr_0xe8, isr_0xe9, isr_0xea, isr_0xeb - .long isr_0xec, isr_0xed, isr_0xee, isr_0xef - .long isr_0xf0, isr_0xf1, isr_0xf2, isr_0xf3 - .long isr_0xf4, isr_0xf5, isr_0xf6, isr_0xf7 - .long isr_0xf8, isr_0xf9, isr_0xfa, isr_0xfb - .long isr_0xfc, isr_0xfd, isr_0xfe, isr_0xff diff --git a/kernel/old/kernel.c b/kernel/old/kernel.c deleted file mode 100644 index 14e8b02..0000000 --- a/kernel/old/kernel.c +++ /dev/null @@ -1,384 +0,0 @@ -/** -** @file kernel.c -** -** @author CSCI-452 class of 20245 -** -** @brief Kernel support routines -*/ - -#define KERNEL_SRC - -#include <common.h> -#include <cio.h> -#include <clock.h> -#include <kmem.h> -#include <procs.h> -#include <sio.h> -#include <syscalls.h> -#include <user.h> -#include <userids.h> -#include <vm.h> - -/* -** PRIVATE DEFINITIONS -*/ - -/* -** PRIVATE DATA TYPES -*/ - -/* -** PRIVATE GLOBAL VARIABLES -*/ - -/* -** PUBLIC GLOBAL VARIABLES -*/ - -// character buffers, usable throughout the OS -// nto guaranteed to retain their contents across an exception return -char b256[256]; // primarily used for message creation -char b512[512]; // used by PANIC macro - -/* -** PRIVATE FUNCTIONS -*/ - -/* -** PRIVATE FUNCTIONS -*/ - -/** -** report - report the system configuration -** -** Prints configuration information about the OS on the console monitor. -** -** @param dtrace Decode the TRACE options -*/ -static void kreport( bool_t dtrace ) { - - cio_puts( "\n-------------------------------\n" ); - cio_printf( "Config: N_PROCS = %d", N_PROCS ); - cio_printf( " N_PRIOS = %d", N_PRIOS ); - cio_printf( " N_STATES = %d", N_STATES ); - cio_printf( " CLOCK = %dHz\n", CLOCK_FREQ ); - - // This code is ugly, but it's the simplest way to - // print out the values of compile-time options - // without spending a lot of execution time at it. - - cio_puts( "Options: " -#ifdef RPT_INT_UNEXP - " R-uint" -#endif -#ifdef RPT_INT_MYSTERY - " R-mint" -#endif -#ifdef TRACE_CX - " CX" -#endif -#ifdef CONSOLE_STATS - " Cstats" -#endif - ); // end of cio_puts() call - -#ifdef SANITY - cio_printf( " SANITY = %d", SANITY ); -#endif -#ifdef STATUS - cio_printf( " STATUS = %d", STATUS ); -#endif - -#if TRACE > 0 - cio_printf( " TRACE = 0x%04x\n", TRACE ); - - // decode the trace settings if that was requested - if( TRACING_SOMETHING && dtrace ) { - - // this one is simpler - we rely on string literal - // concatenation in the C compiler to create one - // long string to print out - - cio_puts( "Tracing:" -#if TRACING_PCB - " PCB" -#endif -#if TRACING_VM - " VM" -#endif -#if TRACING_QUEUE - " QUE" -#endif -#if TRACING_SCHED - " SCHED" -#endif -#if TRACING_DISPATCH - " DISPATCH" -#endif -#if TRACING_SYSCALLS - " SCALL" -#endif -#if TRACING_SYSRETS - " SRET" -#endif -#if TRACING_EXIT - " EXIT" -#endif -#if TRACING_INIT - " INIT" -#endif -#if TRACING_KMEM - " KM" -#endif -#if TRACING_KMEM_FREELIST - " KMFL" -#endif -#if TRACING_KMEM_INIT - " KMIN" -#endif -#if TRACING_FORK - " FORK" -#endif -#if TRACING_EXEC - " EXEC" -#endif -#if TRACING_SIO_STAT - " S_STAT" -#endif -#if TRACING_SIO_ISR - " S_ISR" -#endif -#if TRACING_SIO_RD - " S_RD" -#endif -#if TRACING_SIO_WR - " S_WR" -#endif -#if TRACING_USER - " USER" -#endif -#if TRACING_ELF - " ELF" -#endif - ); // end of cio_puts() call - } -#endif /* TRACE > 0 */ - - cio_puts( "\n-------------------------------\n" ); -} - - -#if defined(CONSOLE_STATS) -/** -** stats - callback routine for console statistics -** -** Called by the CIO module when a key is pressed on the -** console keyboard. Depending on the key, it will print -** statistics on the console display, or will cause the -** user shell process to be dispatched. -** -** This code runs as part of the CIO ISR. -*/ -static void stats( int code ) { - - switch( code ) { - - case 'a': // dump the active table - ptable_dump( "\nActive processes", false ); - break; - - case 'c': // dump context info for all active PCBs - ctx_dump_all( "\nContext dump" ); - break; - - case 'p': // dump the active table and all PCBs - ptable_dump( "\nActive processes", true ); - break; - - case 'q': // dump the queues - // code to dump out any/all queues - pcb_queue_dump( "R", ready ); - pcb_queue_dump( "W", waiting ); - pcb_queue_dump( "S", sleeping ); - pcb_queue_dump( "Z", zombie ); - pcb_queue_dump( "I", sioread ); - break; - - case 'r': // print system configuration information - report( true ); - break; - - // ignore CR and LF - case '\r': // FALL THROUGH - case '\n': - break; - - default: - cio_printf( "console: unknown request '0x%02x'\n", code ); - // FALL THROUGH - - case 'h': // help message - cio_puts( "\nCommands:\n" - " a -- dump the active table\n" - " c -- dump contexts for active processes\n" - " h -- this message\n" - " p -- dump the active table and all PCBs\n" - " q -- dump the queues\n" - " r -- print system configuration\n" - ); - break; - } -} -#endif - -/* -** PUBLIC FUNCTIONS -*/ - -/** -** main - system initialization routine -** -** Called by the startup code immediately before returning into the -** first user process. -** -** Making this type 'int' keeps the compiler happy. -*/ -int main( void ) { - - /* - ** BOILERPLATE CODE - taken from basic framework - ** - ** Initialize interrupt stuff. - */ - - init_interrupts(); // IDT and PIC initialization - - /* - ** Console I/O system. - ** - ** Does not depend on the other kernel modules, so we can - ** initialize it before we initialize the kernel memory - ** and queue modules. - */ - -#if defined(CONSOLE_STATS) - cio_init( stats ); -#else - cio_init( NULL ); // no console callback routine -#endif - - cio_clearscreen(); // wipe out whatever is there - - /* - ** TERM-SPECIFIC CODE STARTS HERE - */ - - /* - ** Initialize various OS modules - ** - ** Other modules (clock, SIO, syscall, etc.) are expected to - ** install their own ISRs in their initialization routines. - */ - - cio_puts( "System initialization starting.\n" ); - cio_puts( "-------------------------------\n" ); - - cio_puts( "Modules:" ); - - // call the module initialization functions, being - // careful to follow any module precedence requirements - - km_init(); // MUST BE FIRST -#if TRACING_KMEM || TRACING_KMEM_FREE - delay( DELAY_2_SEC ); // approximately -#endif - - // other module initialization calls here - clk_init(); // clock - pcb_init(); // process (PCBs, queues, scheduler) -#if TRACING_PCB - delay( DELAY_2_SEC ); -#endif - sio_init(); // serial i/o - sys_init(); // system call -#if TRACING_SYSCALLS || TRACING_SYSRETS - delay( DELAY_2_SEC ); -#endif - vm_init(); // virtual memory - user_init(); // user code handling - - cio_puts( "\nModule initialization complete.\n" ); - cio_puts( "-------------------------------\n" ); - - // report our configuration options - kreport( true ); - - delay( DELAY_3_SEC ); - - /* - ** Other tasks typically performed here: - ** - ** Enabling any I/O devices (e.g., SIO xmit/rcv) - */ - - /* - ** Create the initial user process - ** - ** This code is largely stolen from the fork() and exec() - ** implementations in syscalls.c; if those change, this must - ** also change. - */ - - // if we can't get a PCB, there's no use continuing! - assert( pcb_alloc(&init_pcb) == SUCCESS ); - - // fill in the necessary details - init_pcb->pid = PID_INIT; - init_pcb->state = STATE_NEW; - init_pcb->priority = PRIO_HIGH; - - // find the 'init' program - prog_t *prog = user_locate( Init ); - assert( prog != NULL ); - - // command-line arguments for 'init' - const char *args[2] = { "init", NULL }; - - // load it - assert( user_load(prog,init_pcb,args) == SUCCESS ); - - // send it on its merry way - schedule( init_pcb ); - -#ifdef TRACE_CX - // if we're using a scrolling region, wait a bit more and then set it up - delay( DELAY_7_SEC ); - - // define a scrolling region in the top 7 lines of the screen - cio_setscroll( 0, 7, 99, 99 ); - - // clear it - cio_clearscroll(); - - // clear the top line - cio_puts_at( 0, 0, "* " ); - // separator - cio_puts_at( 0, 6, "================================================================================" ); -#endif - - // switch to the "real" kernel page directory - vm_set_kvm(); - - /* - ** END OF TERM-SPECIFIC CODE - ** - ** Finally, report that we're all done. - */ - - cio_puts( "System initialization complete.\n" ); - cio_puts( "-------------------------------\n" ); - - sio_enable( SIO_RX ); - - return 0; -} diff --git a/kernel/old/kernel.ld b/kernel/old/kernel.ld deleted file mode 100644 index 1534aad..0000000 --- a/kernel/old/kernel.ld +++ /dev/null @@ -1,71 +0,0 @@ -/* -** Simple linker script for the 20245 kernel. -*/ - -OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386") -OUTPUT_ARCH(i386) -ENTRY(_start) - -SECTIONS -{ - /* Link the kernel at this address. */ - /* Must match what is defined in vm.h! */ - . = 0x80010000; - - .text : AT(0x10000) { - *(.text .stub .text.* .gnu.linkonce.t.*) - } - - /* standard symbols */ - PROVIDE(etext = .); - PROVIDE(_etext = .); - - /* put read-only data next */ - .rodata : { - *(.rodata .rodata.* .gnu.linkonce.r.*) - } - - /* Could put STABs here */ - .stab : { - PROVIDE(__STAB_BEGIN__ = .); - *(.stab); - PROVIDE(__STAB_END__ = .); - } - .stabstr : { - PROVIDE(__STABSTR_BEGIN__ = .); - *(.stabstr); - PROVIDE(__STABSTR_END__ = .); - } - - /* Align the data segment at the next page boundary */ - . = ALIGN(0x1000); - - PROVIDE(data = .); - PROVIDE(_data = .); - - /* The data segment */ - .data : { - *(.data .data.*) - } - - PROVIDE(edata = .); - PROVIDE(_edata = .); - - /* page-align the BSS */ - . = ALIGN(0x1000); - - PROVIDE(__bss_start = .); - - .bss : { - *(.bss .bss.*) - *(COMMON) - } - - PROVIDE(end = .); - PROVIDE(_end = .); - - /DISCARD/ : { - /* *(.stab .stab_info .stabstr) */ - *(.eh_frame .note.GNU-stack .note.gnu.property .comment) - } -} diff --git a/kernel/old/kmem.c b/kernel/old/kmem.c deleted file mode 100644 index febc6b9..0000000 --- a/kernel/old/kmem.c +++ /dev/null @@ -1,699 +0,0 @@ -/** -** @file kmem.c -** -** @author Warren R. Carithers -** @author Kenneth Reek -** @author 4003-506 class of 20013 -** -** @brief Functions to perform dynamic memory allocation in the OS. -** -** NOTE: these should NOT be called by user processes! -** -** This allocator functions as a simple "slab" allocator; it allows -** allocation of either 4096-byte ("page") or 1024-byte ("slice") -** chunks of memory from the free pool. The free pool is initialized -** using the memory map provided by the BIOS during the boot sequence, -** and contains a series of blocks which are each one page of memory -** (4KB, and aligned at 4KB boundaries); they are held in the free list -** in LIFO order, as all pages are created equal. -** -** By default, the addresses used are virtual addresses rather than -** physical addresses. Define the symbol USE_PADDRS when compiling to -** change this. -** -** Each allocator ("page" and "slice") allocates the first block from -** the appropriate free list. On deallocation, the block is added back -** to the free list. -** -** The "slice" allocator operates by taking blocks from the "page" -** allocator and splitting them into four 1K slices, which it then -** manages. Requests are made for slices one at a time. If the free -** list contains an available slice, it is unlinked and returned; -** otherwise, a page is requested from the page allocator, split into -** slices, and the slices are added to the free list, after which the -** first one is returned. The slice free list is a simple linked list -** of these 1K blocks; because they are all the same size, no ordering -** is done on the free list, and no coalescing is performed. -** -** This could be converted into a bitmap-based allocator pretty easily. -** A 4GB address space contains 2^20 (1,048,576) pages; at one bit per -** page frame, that's 131,072 (2^17) bytes to cover all of the address -** space, and that could be reduced by restricting allocatable space -** to a subset of the 4GB space. -** -** Compilation options: -** -** ALLOC_FAIL_PANIC if an internal slice allocation fails, panic -** USE_PADDRS build the free list using physical, not -** virtual, addresses -*/ - -#define KERNEL_SRC - -#include <common.h> - -// all other framework includes are next -#include <lib.h> - -#include <kmem.h> - -#include <list.h> -#include <x86/arch.h> -#include <x86/bios.h> -#include <bootstrap.h> -#include <cio.h> -#include <vm.h> - -/* -** PRIVATE DEFINITIONS -*/ - -// combination tracing tests -#define ANY_KMEM (TRACING_KMEM|TRACING_KMEM_INIT|TRACING_KMEM_FREELIST) -#define KMEM_OR_INIT (TRACING_KMEM|TRACING_KMEM_INIT) - -// parameters related to word and block sizes - -#define WORD_SIZE sizeof(int) -#define LOG2_OF_WORD_SIZE 2 - -#define LOG2_OF_PAGE_SIZE 12 - -#define LOG2_OF_SLICE_SIZE 10 - -// converters: pages to bytes, bytes to pages - -#define P2B(x) ((x) << LOG2_OF_PAGE_SIZE) -#define B2P(x) ((x) >> LOG2_OF_PAGE_SIZE) - -/* -** Name: adjacent -** -** Arguments: addresses of two blocks -** -** Description: Determines whether the second block immediately -** follows the first one. -*/ -#define adjacent(first,second) \ - ( (void *) (first) + P2B((first)->pages) == (void *) (second) ) - -/* -** PRIVATE DATA TYPES -*/ - -/* -** Memory region information returned by the BIOS -** -** This data consists of a 32-bit integer followed -** by an array of region descriptor structures. -*/ - -// a handy union for playing with 64-bit addresses -typedef union b64_u { - uint32_t part[2]; - uint64_t all; -} b64_t; - -// the halves of a 64-bit address -#define LOW part[0] -#define HIGH part[1] - -// memory region descriptor -typedef struct memregion_s { - b64_t base; // base address - b64_t length; // region length - uint32_t type; // type of region - uint32_t acpi; // ACPI 3.0 info -} ATTR_PACKED region_t; - -/* -** Region types -*/ - -#define REGION_USABLE 1 -#define REGION_RESERVED 2 -#define REGION_ACPI_RECL 3 -#define REGION_ACPI_NVS 4 -#define REGION_BAD 5 - -/* -** ACPI 3.0 bit fields -*/ - -#define REGION_IGNORE 0x01 -#define REGION_NONVOL 0x02 - -/* -** 32-bit and 64-bit address values as 64-bit literals -*/ - -#define ADDR_BIT_32 0x0000000100000000LL -#define ADDR_LOW_HALF 0x00000000ffffffffLL -#define ADDR_HIGH_HALR 0xffffffff00000000LL - -#define ADDR_32_MAX ADDR_LOW_HALF -#define ADDR_64_FIRST ADDR_BIT_32 - -/* -** PRIVATE GLOBAL VARIABLES -*/ - -// freespace pools -static list_t free_pages; -static list_t free_slices; - -// block counts -static uint32_t n_pages; -static uint32_t n_slices; - -// initialization status -static int km_initialized; - -/* -** IMPORTED GLOBAL VARIABLES -*/ - -// this is no longer used; for simple situations, it can be used as -// the KM_LOW_CUTOFF value -// -// extern int _end; // end of the BSS section - provided by the linker - -/* -** FUNCTIONS -*/ - -/* -** FREE LIST MANAGEMENT -*/ - -/** -** Name: add_block -** -** Add a block to the free list. The block will be split into separate -** page-sized fragments which will each be added to the free_pages -** list; each of these will also be modified. -** -** @param[in] base Base physical address of the block -** @param[in] length Block length, in bytes -*/ -static void add_block( uint32_t base, uint32_t length ) { - - // don't add it if it isn't at least 4K - if( length < SZ_PAGE ) { - return; - } - -#if ANY_KMEM - cio_printf( " add(%08x,%08x): ", base, length ); -#endif - - // verify that the base address is a 4K boundary - if( (base & MOD4K_BITS) != 0 ) { - // nope - how many bytes will we lose from the beginning - uint_t loss = base & MOD4K_BITS; - // adjust the starting address: (n + 4K - 1) / 4K - base = (base + MOD4K_BITS) & MOD4K_MASK; - // adjust the length - length -= loss; - } - - // only want to add multiples of 4K; check the lower bits - if( (length & MOD4K_BITS) != 0 ) { - // round it down to 4K - length &= MOD4K_MASK; - } - - // determine the starting and ending addresses for the block -#ifndef USE_PADDRS - // starting and ending addresses as virtual addresses - base = P2V(base); -#endif - // endpoint of the block - uint32_t blend = base + length; - - // page count for this block - int npages = 0; - -#if ANY_KMEM - cio_printf( "-> base %08x len %08x: ", base, length ); -#endif - - // iterate through the block page by page - while( base < blend ) { - list_add( &free_pages, (void *) base ); - ++npages; - base += SZ_PAGE; - } - - // add the count to our running total - n_pages += npages; - -#if ANY_KMEM - cio_printf( " -> %d pages\n", npages ); -#endif -} - -/** -** Name: km_init -** -** Find what memory is present on the system and -** construct the list of free memory blocks. -** -** Dependencies: -** Must be called before any other init routine that uses -** dynamic storage is called. -*/ -void km_init( void ) { - int32_t entries; - region_t *region; - -#if TRACING_INIT - // announce that we're starting initialization - cio_puts( " Kmem" ); -#endif - - // initially, nothing in the free lists - free_slices.next = NULL; - free_pages.next = NULL; - n_pages = n_slices = 0; - km_initialized = 0; - - // get the list length - entries = *((int32_t *) MMAP_ADDR); - -#if KMEM_OR_INIT - cio_printf( "\nKmem: %d regions\n", entries ); -#endif - - // if there are no entries, we have nothing to do! - if( entries < 1 ) { // note: entries == -1 could occur! - return; - } - - // iterate through the entries, adding things to the freelist - - region = ((region_t *) (MMAP_ADDR + 4)); - - for( int i = 0; i < entries; ++i, ++region ) { - -#if KMEM_OR_INIT - // report this region - cio_printf( "%3d: ", i ); - cio_printf( " B %08x%08x", - region->base.HIGH, region->base.LOW ); - cio_printf( " L %08x%08x", - region->length.HIGH, region->length.LOW ); - cio_printf( " T %08x A %08x", - region->type, region->acpi ); -#endif - - /* - ** Determine whether or not we should ignore this region. - ** - ** We ignore regions for several reasons: - ** - ** ACPI indicates it should be ignored - ** ACPI indicates it's non-volatile memory - ** Region type isn't "usable" - ** Region is above our address limit - ** - ** Currently, only "normal" (type 1) regions are considered - ** "usable" for our purposes. We could potentially expand - ** this to include ACPI "reclaimable" memory. - */ - - // first, check the ACPI one-bit flags - - if( ((region->acpi) & REGION_IGNORE) == 0 ) { -#if KMEM_OR_INIT - cio_puts( " IGN\n" ); -#endif - continue; - } - - if( ((region->acpi) & REGION_NONVOL) != 0 ) { -#if KMEM_OR_INIT - cio_puts( " NVOL\n" ); -#endif - continue; // we'll ignore this, too - } - - // next, the region type - - if( (region->type) != REGION_USABLE ) { -#if KMEM_OR_INIT - cio_puts( " RCLM\n" ); -#endif - continue; // we won't attempt to reclaim ACPI memory (yet) - } - - /* - ** We have a "normal" memory region. We need to verify - ** that it's within our constraints. - ** - ** We ignore anything below our KM_LOW_CUTOFF address. (In theory, - ** we should be able to re-use much of that space; in practice, - ** this is safer.) We won't add anything to the free list if it is: - ** - ** * below our KM_LOW_CUTOFF value - ** * above out KM_HIGH_CUTOFF value. - ** - ** For blocks which straddle one of those limits, we will - ** split it, and only use the portion that's within those - ** bounds. - */ - - // grab the two 64-bit values to simplify things - uint64_t base = region->base.all; - uint64_t length = region->length.all; - uint64_t endpt = base + length; - - // ignore it if it's above our high cutoff point - if( base >= KM_HIGH_CUTOFF || endpt >= KM_HIGH_CUTOFF ) { - - // is the whole thing too high, or just part? - if( base >= KM_HIGH_CUTOFF ) { - // it's all too high! -#if KMEM_OR_INIT - cio_puts( " HIGH\n" ); -#endif - continue; - } - - // some of it is usable - fix the end point - endpt = KM_HIGH_CUTOFF; - } - - // see if it's below our low cutoff point - if( base < KM_LOW_CUTOFF || endpt < KM_LOW_CUTOFF ) { - - // is the whole thing too low, or just part? - if( endpt < KM_LOW_CUTOFF ) { - // it's all below the cutoff! -#if KMEM_OR_INIT - cio_puts( " LOW\n" ); -#endif - continue; - } - - // some of it is usable - reset the base address - base = KM_LOW_CUTOFF; - - // recalculate the length - length = endpt - base; - } - - // we survived the gauntlet - add the new block - // - // we may have changed the base or endpoint, so - // we should recalculate the length - length = endpt - base; - -#if KMEM_OR_INIT - cio_puts( " OK\n" ); -#endif - - uint32_t b32 = base & ADDR_LOW_HALF; - uint32_t l32 = length & ADDR_LOW_HALF; - - add_block( b32, l32 ); - } - - // record the initialization - km_initialized = 1; - -#if KMEM_OR_INIT - delay( DELAY_3_SEC ); -#endif -} - -/** -** Name: km_dump -** -** Dump information about the free lists to the console. By default, -** prints only the list sizes; if 'addrs' is true, also dumps the list -** of page addresses; if 'all' is also true, dumps page addresses and -** slice addresses. -** -** @param addrs Also dump page addresses -** @param both Also dump slice addresses -*/ -void km_dump( bool_t addrs, bool_t both ) { - - // report the sizes - cio_printf( "&free_pages %08x, &free_slices %08x, %u pages, %u slices\n", - (uint32_t) &free_pages, (uint32_t) &free_slices, - n_pages, n_slices ); - - // was that all? - if( !addrs ) { - return; - } - - // dump the addresses of the pages in the free list - uint32_t n = 0; - list_t *block = free_pages.next; - while( block != NULL ) { - if( n && !(n & MOD4_BITS) ) { - // four per line - cio_putchar( '\n' ); - } - cio_printf( " page @ 0x%08x", (uint32_t) block ); - block = block->next; - ++n; - } - - // sanity check - verify that the counts match - if( n != n_pages ) { - sprint( b256, "km_dump: n_pages %u, counted %u!!!\n", - n_pages, n ); - WARNING( b256); - } - - if( !both ) { - return; - } - - // but wait - there's more! - - // also dump the addresses of slices in the slice free list - n = 0; - block = free_slices.next; - while( block != NULL ) { - if( n && !(n & MOD4_BITS) ) { - // four per line - cio_putchar( '\n' ); - } - cio_printf( " slc @ 0x%08x", (uint32_t) block ); - block = block->next; - ++n; - } - - // sanity check - verify that the counts match - if( n != n_slices ) { - sprint( b256, "km_dump: n_slices %u, counted %u!!!\n", - n_slices, n ); - WARNING( b256); - } -} - -/* -** PAGE MANAGEMENT -*/ - -/** -** Name: km_page_alloc -** -** Allocate a page of memory from the free list. -** -** @return a pointer to the beginning of the allocated page, -** or NULL if no memory is available -*/ -void *km_page_alloc( void ) { - - // if km_init() wasn't called first, stop us in our tracks - assert( km_initialized ); - -#if TRACING_KMEM_FREELIST - cio_puts( "KM: pg_alloc()" ); -#endif - - // pointer to the first block - void *page = list_remove( &free_pages ); - - // was a page available? - if( page == NULL ){ - // nope! -#if TRACING_KMEM_FREELIST - cio_puts( " FAIL\n" ); -#endif -#if ALLOC_FAIL_PANIC - PANIC( 0, "page alloc failed" ); -#else - return NULL; -#endif - } - - // fix the count of available pages - --n_pages; - -#if TRACING_KMEM_FREELIST - cio_printf( " -> %08x\n", (uint32_t) page ); -#endif - - return( page ); -} - -/** -** Name: km_page_free -** -** Returns a page to the list of available pages. -** -** @param[in] page Pointer to the page to be returned to the free list -*/ -void km_page_free( void *page ){ - - // verify that km_init() was called first - assert( km_initialized ); - -#if TRACING_KMEM_FREELIST - cio_printf( "KM: pg_free(%08x)\n", (uint32_t) page ); -#endif - - /* - ** Don't do anything if the address is NULL. - */ - if( page == NULL ){ - return; - } - - - /* - ** CRITICAL ASSUMPTION - ** - ** We assume that the block pointer given to us points to a single - ** page-sized block of memory. We make this assumption because we - ** don't track allocation sizes. We can't use the simple "allocate - ** four extra bytes before the returned pointer" scheme to do this - ** because we're managing pages, and the pointers we return must point - ** to page boundaries, so we would wind up allocating an extra page - ** for each allocation. - ** - ** Alternatively, we could keep an array of addresses and block - ** sizes ourselves, but that feels clunky, and would risk running out - ** of table entries if there are lots of allocations (assuming we use - ** a 4KB page to hold the table, at eight bytes per entry we would have - ** 512 entries per page). - ** - ** IF THIS ASSUMPTION CHANGES, THIS CODE MUST BE FIXED!!! - */ - - // link this into the free list - list_add( &free_pages, page ); - - // one more in the pool - ++n_pages; -} - -/* -** SLICE MANAGEMENT -*/ - -/* -** Slices are 1024-byte fragments from pages. We maintain a free list of -** slices for those parts of the OS which don't need full 4096-byte chunks -** of space. -*/ - -/** -** Name: carve_slices -** -** Split an allocated page into four slices and add -** them to the "free slices" list. -** -** @param page Pointer to the page to be carved up -*/ -static void carve_slices( void *page ) { - - // sanity check - assert1( page != NULL ); - -#if TRACING_KMEM_FREELIST - cio_printf( "KM: carve_slices(%08x)\n", (uint32_t) page ); -#endif - - // create the four slices from it - uint8_t *ptr = (uint8_t *) page; - for( int i = 0; i < 4; ++i ) { - km_slice_free( (void *) ptr ); - ptr += SZ_SLICE; - ++n_slices; - } -} - -/** -** Name: km_slice_alloc -** -** Dynamically allocates a slice (1/4 of a page). If no -** memory is available, we return NULL (unless ALLOC_FAIL_PANIC -** was defined, in which case we panic). -** -** @return a pointer to the allocated slice -*/ -void *km_slice_alloc( void ) { - - // verify that km_init() was called first - assert( km_initialized ); - -#if TRACING_KMEM_FREELIST - cio_printf( "KM: sl_alloc()\n" ); -#endif - - // if we are out of slices, create a few more - if( free_slices.next == NULL ) { - void *new = km_page_alloc(); - if( new == NULL ) { - // can't get any more space -#if ALLOC_FAIL_PANIC - PANIC( 0, "slice new alloc failed" ); -#else - return NULL; -#endif - } - carve_slices( new ); - } - - // take the first one from the free list - void *slice = list_remove( &free_slices ); - assert( slice != NULL ); - --n_slices; - - // make it nice and shiny for the caller - memclr( (void *) slice, SZ_SLICE ); - - return( slice ); -} - -/** -** Name: km_slice_free -** -** Returns a slice to the list of available slices. -** -** We make no attempt to merge slices, as we treat them as -** independent blocks of memory (like pages). -** -** @param[in] block Pointer to the slice (1/4 page) to be freed -*/ -void km_slice_free( void *block ) { - - // verify that km_init() was called first - assert( km_initialized ); - -#if TRACING_KMEM_FREELIST - cio_printf( "KM: sl_free(%08x)\n", (uint32_t) block ); -#endif - - // just add it to the front of the free list - list_add( &free_slices, block ); - --n_slices; -} diff --git a/kernel/old/list.c b/kernel/old/list.c deleted file mode 100644 index 084000a..0000000 --- a/kernel/old/list.c +++ /dev/null @@ -1,64 +0,0 @@ -/** -** @file list.c -** -** @author Warren R. Carithers -** -** @brief Support for a basic linked list data type. -** -** This module provides a very basic linked list data structure. -** A list can contain anything that has a pointer field in the first -** four bytes; these routines assume those bytes contain a pointer to -** the following entry in the list, whatever that may be. -*/ - -#define KERNEL_SRC - -#include <common.h> - -#include <list.h> - -/* -** FUNCTIONS -*/ - -/** -** Name: list_add -** -** Add the supplied data to the beginning of the specified list. -** -** @param[in,out] list The address of a list_t variable -** @param[in] data The data to prepend to the list -*/ -void list_add( list_t *list, void *data ) { - - // sanity checks - assert1( list != NULL ); - assert1( data != NULL ); - - list_t *tmp = (list_t *)data; - tmp->next = list->next; - list->next = tmp; -} - -/** -** Name: list_remove -** -** Remove the first entry from a linked list. -** -** @param[in,out] list The address of a list_t variable -** -** @return a pointer to the removed data, or NULL if the list was empty -*/ -void *list_remove( list_t *list ) { - - assert1( list != NULL ); - - list_t *data = list->next; - if( data != NULL ) { - list->next = data->next; - data->next = NULL; - } - - return (void *)data; -} - diff --git a/kernel/old/procs.c b/kernel/old/procs.c deleted file mode 100644 index 96bb3fd..0000000 --- a/kernel/old/procs.c +++ /dev/null @@ -1,1136 +0,0 @@ -/* -** @file procs.c -** -** @author CSCI-452 class of 20245 -** -** @brief Process-related implementations -*/ - -#define KERNEL_SRC - -#include <common.h> - -#include <procs.h> -#include <user.h> - -/* -** PRIVATE DEFINITIONS -*/ - -// determine if a queue is empty; assumes 'q' is a valid pointer -#define PCB_QUEUE_EMPTY(q) ((q)->head == NULL) - -/* -** PRIVATE DATA TYPES -*/ - -/* -** PCB Queue structure -** -** Opaque to the rest of the kernel -** -** Typedef'd in the header: typedef struct pcb_queue_s *pcb_queue_t; -*/ -struct pcb_queue_s { - pcb_t *head; - pcb_t *tail; - enum pcb_queue_order_e order; -}; - -/* -** PRIVATE GLOBAL VARIABLES -*/ - -// collection of queues -static struct pcb_queue_s pcb_freelist_queue; -static struct pcb_queue_s ready_queue; -static struct pcb_queue_s waiting_queue; -static struct pcb_queue_s sleeping_queue; -static struct pcb_queue_s zombie_queue; -static struct pcb_queue_s sioread_queue; - -/* -** PUBLIC GLOBAL VARIABLES -*/ - -// public-facing queue handles -pcb_queue_t pcb_freelist; -pcb_queue_t ready; -pcb_queue_t waiting; -pcb_queue_t sleeping; -pcb_queue_t zombie; -pcb_queue_t sioread; - -// pointer to the currently-running process -pcb_t *current; - -// the process table -pcb_t ptable[N_PROCS]; - -// next available PID -uint_t next_pid; - -// pointer to the PCB for the 'init' process -pcb_t *init_pcb; - -// table of state name strings -const char *state_str[N_STATES] = { - [ STATE_UNUSED ] = "Unu", // "Unused" - [ STATE_NEW ] = "New", - [ STATE_READY ] = "Rdy", // "Ready" - [ STATE_RUNNING ] = "Run", // "Running" - [ STATE_SLEEPING ] = "Slp", // "Sleeping" - [ STATE_BLOCKED ] = "Blk", // "Blocked" - [ STATE_WAITING ] = "Wat", // "Waiting" - [ STATE_KILLED ] = "Kil", // "Killed" - [ STATE_ZOMBIE ] = "Zom" // "Zombie" -}; - -// table of priority name strings -const char *prio_str[N_PRIOS] = { - [ PRIO_HIGH ] = "High", - [ PRIO_STD ] = "User", - [ PRIO_LOW ] = "Low ", - [ PRIO_DEFERRED ] = "Def " -}; - -// table of queue ordering name strings -const char *ord_str[N_PRIOS] = { - [ O_FIFO ] = "FIFO", - [ O_PRIO ] = "PRIO", - [ O_PID ] = "PID ", - [ O_WAKEUP ] = "WAKE" -}; - -/* -** PRIVATE FUNCTIONS -*/ - -/** -** Priority search functions. These are used to traverse a supplied -** queue looking for the queue entry that would precede the supplied -** PCB when that PCB is inserted into the queue. -** -** Variations: -** find_prev_wakeup() compares wakeup times -** find_prev_priority() compares process priorities -** find_prev_pid() compares PIDs -** -** Each assumes the queue should be in ascending order by the specified -** comparison value. -** -** @param[in] queue The queue to search -** @param[in] pcb The PCB to look for -** -** @return a pointer to the predecessor in the queue, or NULL if -** this PCB would be at the beginning of the queue. -*/ -static pcb_t *find_prev_wakeup( pcb_queue_t queue, pcb_t *pcb ) { - - // sanity checks! - assert1( queue != NULL ); - assert1( pcb != NULL ); - - pcb_t *prev = NULL; - pcb_t *curr = queue->head; - - while( curr != NULL && curr->wakeup <= pcb->wakeup ) { - prev = curr; - curr = curr->next; - } - - return prev; -} - -static pcb_t *find_prev_priority( pcb_queue_t queue, pcb_t *pcb ) { - - // sanity checks! - assert1( queue != NULL ); - assert1( pcb != NULL ); - - pcb_t *prev = NULL; - pcb_t *curr = queue->head; - - while( curr != NULL && curr->priority <= pcb->priority ) { - prev = curr; - curr = curr->next; - } - - return prev; -} - -static pcb_t *find_prev_pid( pcb_queue_t queue, pcb_t *pcb ) { - - // sanity checks! - assert1( queue != NULL ); - assert1( pcb != NULL ); - - pcb_t *prev = NULL; - pcb_t *curr = queue->head; - - while( curr != NULL && curr->pid <= pcb->pid ) { - prev = curr; - curr = curr->next; - } - - return prev; -} - -/* -** PUBLIC FUNCTIONS -*/ - -// a macro to simplify queue setup -#define QINIT(q,s) \ - q = &q##_queue; \ - if( pcb_queue_reset(q,s) != SUCCESS ) { \ - PANIC( 0, "pcb_init can't reset " # q ); \ - } - -/** -** Name: pcb_init -** -** Initialization for the Process module. -*/ -void pcb_init( void ) { - -#if TRACING_INIT - cio_puts( " Procs" ); -#endif - - // there is no current process - current = NULL; - - // set up the external links to the queues - QINIT( pcb_freelist, O_FIFO ); - QINIT( ready, O_PRIO ); - QINIT( waiting, O_PID ); - QINIT( sleeping, O_WAKEUP ); - QINIT( zombie, O_PID ); - QINIT( sioread, O_FIFO ); - - /* - ** We statically allocate our PCBs, so we need to add them - ** to the freelist before we can use them. If this changes - ** so that we dynamicallyl allocate PCBs, this step either - ** won't be required, or could be used to pre-allocate some - ** number of PCB structures for future use. - */ - - pcb_t *ptr = ptable; - for( int i = 0; i < N_PROCS; ++i ) { - pcb_free( ptr ); - ++ptr; - } -} - -/** -** Name: pcb_alloc -** -** Allocate a PCB from the list of free PCBs. -** -** @param pcb Pointer to a pcb_t * where the PCB pointer will be returned. -** -** @return status of the allocation attempt -*/ -int pcb_alloc( pcb_t **pcb ) { - - // sanity check! - assert1( pcb != NULL ); - - // remove the first PCB from the free list - pcb_t *tmp; - if( pcb_queue_remove(pcb_freelist,&tmp) != SUCCESS ) { - return E_NO_PCBS; - } - - *pcb = tmp; - return SUCCESS; -} - -/** -** Name: pcb_free -** -** Return a PCB to the list of free PCBs. -** -** @param pcb Pointer to the PCB to be deallocated. -*/ -void pcb_free( pcb_t *pcb ) { - - if( pcb != NULL ) { - // mark the PCB as available - pcb->state = STATE_UNUSED; - - // add it to the free list - int status = pcb_queue_insert( pcb_freelist, pcb ); - - // if that failed, we're in trouble - if( status != SUCCESS ) { - sprint( b256, "pcb_free(0x%08x) status %d", (uint32_t) pcb, - status ); - PANIC( 0, b256 ); - } - } -} - -/** -** Name: pcb_zombify -** -** Turn the indicated process into a Zombie. This function -** does most of the real work for exit() and kill() calls. -** Is also called from the scheduler and dispatcher. -** -** @param pcb Pointer to the newly-undead PCB -*/ -void pcb_zombify( register pcb_t *victim ) { - - // should this be an error? - if( victim == NULL ) { - return; - } - - // every process must have a parent, even if it's 'init' - assert( victim->parent != NULL ); - - /* - ** We need to locate the parent of this process. We also need - ** to reparent any children of this process. We do these in - ** a single loop. - */ - pcb_t *parent = victim->parent; - pcb_t *zchild = NULL; - - // two PIDs we will look for - uint_t vicpid = victim->pid; - - // speed up access to the process table entries - register pcb_t *curr = ptable; - - for( int i = 0; i < N_PROCS; ++i, ++curr ) { - - // make sure this is a valid entry - if( curr->state == STATE_UNUSED ) { - continue; - } - - // if this is our parent, just keep going - we continue - // iterating to find all the children of this process. - if( curr == parent ) { - continue; - } - - if( curr->parent == victim ) { - - // found a child - reparent it - curr->parent = init_pcb; - - // see if this child is already undead - if( curr->state == STATE_ZOMBIE ) { - // if it's already a zombie, remember it, so we - // can pass it on to 'init'; also, if there are - // two or more zombie children, it doesn't matter - // which one we pick here, as the others will be - // collected when 'init' loops - zchild = curr; - } - - } - } - - /* - ** If we found a child that was already terminated, we need to - ** wake up the init process if it's already waiting. - ** - ** Note: we only need to do this for one Zombie child process - - ** init will loop and collect the others after it finishes with - ** this one. - ** - ** Also note: it's possible that the exiting process' parent is - ** also init, which means we're letting one of zombie children - ** of the exiting process be cleaned up by init before the - ** existing process itself is cleaned up by init. This will work, - ** because after init cleans up the zombie, it will loop and - ** call waitpid() again, by which time this exiting process will - ** be marked as a zombie. - */ - if( zchild != NULL && init_pcb->state == STATE_WAITING ) { - - // dequeue the zombie - assert( pcb_queue_remove_this(zombie,zchild) == SUCCESS ); - - assert( pcb_queue_remove_this(waiting,init_pcb) == SUCCESS ); - - // intrinsic return value is the PID - RET(init_pcb) = zchild->pid; - - // may also want to return the exit status - int32_t *ptr = (int32_t *) ARG(init_pcb,2); - - if( ptr != NULL ) { - // ******************************************************** - // ** Potential VM issue here! This code assigns the exit - // ** status into a variable in the parent's address space. - // ** This works in the baseline because we aren't using - // ** any type of memory protection. If address space - // ** separation is implemented, this code will very likely - // ** STOP WORKING, and will need to be fixed. - // ******************************************************** - *ptr = zchild->exit_status; - } - - // all done - schedule 'init', and clean up the zombie - schedule( init_pcb ); - pcb_cleanup( zchild ); - } - - /* - ** Now, deal with the parent of this process. If the parent is - ** already waiting, just wake it up and clean up this process. - ** Otherwise, this process becomes a zombie. - ** - ** Note: if the exiting process' parent is init and we just woke - ** init up to deal with a zombie child of the exiting process, - ** init's status won't be Waiting any more, so we don't have to - ** worry about it being scheduled twice. - */ - - if( parent->state == STATE_WAITING ) { - - // verify that the parent is either waiting for this process - // or is waiting for any of its children - uint32_t target = ARG(parent,1); - - if( target == 0 || target == vicpid ) { - - // the parent is waiting for this child or is waiting - // for any of its children, so we can wake it up. - - // intrinsic return value is the PID - RET(parent) = vicpid; - - // may also want to return the exit status - int32_t *ptr = (int32_t *) ARG(parent,2); - - if( ptr != NULL ) { - // ******************************************************** - // ** Potential VM issue here! This code assigns the exit - // ** status into a variable in the parent's address space. - // ** This works in the baseline because we aren't using - // ** any type of memory protection. If address space - // ** separation is implemented, this code will very likely - // ** STOP WORKING, and will need to be fixed. - // ******************************************************** - *ptr = victim->exit_status; - } - - // all done - schedule the parent, and clean up the zombie - schedule( parent ); - pcb_cleanup( victim ); - - return; - } - } - - /* - ** The parent isn't waiting OR is waiting for a specific child - ** that isn't this exiting process, so we become a Zombie. - ** - ** This code assumes that Zombie processes are *not* in - ** a queue, but instead are just in the process table with - ** a state of 'Zombie'. This simplifies life immensely, - ** because we won't need to dequeue it when it is collected - ** by its parent. - */ - - victim->state = STATE_ZOMBIE; - assert( pcb_queue_insert(zombie,victim) == SUCCESS ); - - /* - ** Note: we don't call _dispatch() here - we leave that for - ** the calling routine, as it's possible we don't need to - ** choose a new current process. - */ -} - -/** -** Name: pcb_cleanup -** -** Reclaim a process' data structures -** -** @param pcb The PCB to reclaim -*/ -void pcb_cleanup( pcb_t *pcb ) { - -#if TRACING_PCB - cio_printf( "** pcb_cleanup(0x%08x)\n", (uint32_t) pcb ); -#endif - - // avoid deallocating a NULL pointer - if( pcb == NULL ) { - // should this be an error? - return; - } - - // we need to release all the VM data structures and frames - user_cleanup( pcb ); - - // release the PCB itself - pcb_free( pcb ); -} - -/** -** Name: pcb_find_pid -** -** Locate the PCB for the process with the specified PID -** -** @param pid The PID to be located -** -** @return Pointer to the PCB, or NULL -*/ -pcb_t *pcb_find_pid( uint_t pid ) { - - // must be a valid PID - if( pid < 1 ) { - return NULL; - } - - // scan the process table - pcb_t *p = ptable; - - for( int i = 0; i < N_PROCS; ++i, ++p ) { - if( p->pid == pid && p->state != STATE_UNUSED ) { - return p; - } - } - - // didn't find it! - return NULL; -} - -/** -** Name: pcb_find_ppid -** -** Locate the PCB for the process with the specified parent -** -** @param pid The PID to be located -** -** @return Pointer to the PCB, or NULL -*/ -pcb_t *pcb_find_ppid( uint_t pid ) { - - // must be a valid PID - if( pid < 1 ) { - return NULL; - } - - // scan the process table - pcb_t *p = ptable; - - for( int i = 0; i < N_PROCS; ++i, ++p ) { - assert1( p->parent != NULL ); - if( p->parent->pid == pid && p->parent->state != STATE_UNUSED ) { - return p; - } - } - - // didn't find it! - return NULL; -} - -/** -** Name: pcb_queue_reset -** -** Initialize a PCB queue. We assume that whatever data may be -** in the queue structure can be overwritten. -** -** @param queue[out] The queue to be initialized -** @param order[in] The desired ordering for the queue -** -** @return status of the init request -*/ -int pcb_queue_reset( pcb_queue_t queue, enum pcb_queue_order_e style ) { - - // sanity check - assert1( queue != NULL ); - - // make sure the style is valid - if( style < O_FIRST_STYLE || style > O_LAST_STYLE ) { - return E_BAD_PARAM; - } - - // reset the queue - queue->head = queue->tail = NULL; - queue->order = style; - - return SUCCESS; -} - -/** -** Name: pcb_queue_empty -** -** Determine whether a queue is empty. Essentially just a wrapper -** for the PCB_QUEUE_EMPTY() macro, for use outside this module. -** -** @param[in] queue The queue to check -** -** @return true if the queue is empty, else false -*/ -bool_t pcb_queue_empty( pcb_queue_t queue ) { - - // if there is no queue, blow up - assert1( queue != NULL ); - - return PCB_QUEUE_EMPTY(queue); -} - -/** -** Name: pcb_queue_length -** -** Return the count of elements in the specified queue. -** -** @param[in] queue The queue to check -** -** @return the count (0 if the queue is empty) -*/ -uint_t pcb_queue_length( const pcb_queue_t queue ) { - - // sanity check - assert1( queue != NULL ); - - // this is pretty simple - register pcb_t *tmp = queue->head; - register int num = 0; - - while( tmp != NULL ) { - ++num; - tmp = tmp->next; - } - - return num; -} - -/** -** Name: pcb_queue_insert -** -** Inserts a PCB into the indicated queue. -** -** @param queue[in,out] The queue to be used -** @param pcb[in] The PCB to be inserted -** -** @return status of the insertion request -*/ -int pcb_queue_insert( pcb_queue_t queue, pcb_t *pcb ) { - - // sanity checks - assert1( queue != NULL ); - assert1( pcb != NULL ); - - // if this PCB is already in a queue, we won't touch it - if( pcb->next != NULL ) { - // what to do? we let the caller decide - return E_BAD_PARAM; - } - - // is the queue empty? - if( queue->head == NULL ) { - queue->head = queue->tail = pcb; - return SUCCESS; - } - assert1( queue->tail != NULL ); - - // no, so we need to search it - pcb_t *prev = NULL; - - // find the predecessor node - switch( queue->order ) { - case O_FIFO: - prev = queue->tail; - break; - case O_PRIO: - prev = find_prev_priority(queue,pcb); - break; - case O_PID: - prev = find_prev_pid(queue,pcb); - break; - case O_WAKEUP: - prev = find_prev_wakeup(queue,pcb); - break; - default: - // do we need something more specific here? - return E_BAD_PARAM; - } - - // OK, we found the predecessor node; time to do the insertion - - if( prev == NULL ) { - - // there is no predecessor, so we're - // inserting at the front of the queue - pcb->next = queue->head; - if( queue->head == NULL ) { - // empty queue!?! - should we panic? - queue->tail = pcb; - } - queue->head = pcb; - - } else if( prev->next == NULL ) { - - // append at end - prev->next = pcb; - queue->tail = pcb; - - } else { - - // insert between prev & prev->next - pcb->next = prev->next; - prev->next = pcb; - - } - - return SUCCESS; -} - -/** -** Name: pcb_queue_remove -** -** Remove the first PCB from the indicated queue. -** -** @param queue[in,out] The queue to be used -** @param pcb[out] Pointer to where the PCB pointer will be saved -** -** @return status of the removal request -*/ -int pcb_queue_remove( pcb_queue_t queue, pcb_t **pcb ) { - - //sanity checks - assert1( queue != NULL ); - assert1( pcb != NULL ); - - // can't get anything if there's nothing to get! - if( PCB_QUEUE_EMPTY(queue) ) { - return E_EMPTY_QUEUE; - } - - // take the first entry from the queue - pcb_t *tmp = queue->head; - queue->head = tmp->next; - - // disconnect it completely - tmp->next = NULL; - - // was this the last thing in the queue? - if( queue->head == NULL ) { - // yes, so clear the tail pointer for consistency - queue->tail = NULL; - } - - // save the pointer - *pcb = tmp; - - return SUCCESS; -} - -/** -** Name: pcb_queue_remove_this -** -** Remove the specified PCB from the indicated queue. -** -** We don't return the removed pointer, because the calling -** routine must already have it (because it was supplied -** to us in the call). -** -** @param queue[in,out] The queue to be used -** @param pcb[in] Pointer to the PCB to be removed -** -** @return status of the removal request -*/ -int pcb_queue_remove_this( pcb_queue_t queue, pcb_t *pcb ) { - - //sanity checks - assert1( queue != NULL ); - assert1( pcb != NULL ); - - // can't get anything if there's nothing to get! - if( PCB_QUEUE_EMPTY(queue) ) { - return E_EMPTY_QUEUE; - } - - // iterate through the queue until we find the desired PCB - pcb_t *prev = NULL; - pcb_t *curr = queue->head; - - while( curr != NULL && curr != pcb ) { - prev = curr; - curr = curr->next; - } - - // case prev curr next interpretation - // ==== ==== ==== ==== ============================ - // 1. 0 0 -- *** CANNOT HAPPEN *** - // 2. 0 !0 0 removing only element - // 3. 0 !0 !0 removing first element - // 4. !0 0 -- *** NOT FOUND *** - // 5. !0 !0 0 removing from end - // 6. !0 !0 !0 removing from middle - - if( curr == NULL ) { - // case 1 - assert( prev != NULL ); - // case 4 - return E_NOT_FOUND; - } - - // connect predecessor to successor - if( prev != NULL ) { - // not the first element - // cases 5 and 6 - prev->next = curr->next; - } else { - // removing first element - // cases 2 and 3 - queue->head = curr->next; - } - - // if this was the last node (cases 2 and 5), - // also need to reset the tail pointer - if( curr->next == NULL ) { - // if this was the only entry (2), prev is NULL, - // so this works for that case, too - queue->tail = prev; - } - - // unlink current from queue - curr->next = NULL; - - // there's a possible consistancy problem here if somehow - // one of the queue pointers is NULL and the other one - // is not NULL - - assert1( - (queue->head == NULL && queue->tail == NULL) || - (queue->head != NULL && queue->tail != NULL) - ); - - return SUCCESS; -} - -/** -** Name: pcb_queue_peek -** -** Return the first PCB from the indicated queue, but don't -** remove it from the queue. -** -** @param queue[in] The queue to be used -** -** @return the PCB poiner, or NULL if the queue is empty -*/ -pcb_t *pcb_queue_peek( const pcb_queue_t queue ) { - - //sanity check - assert1( queue != NULL ); - - // can't get anything if there's nothing to get! - if( PCB_QUEUE_EMPTY(queue) ) { - return NULL; - } - - // just return the first entry from the queue - return queue->head; -} - -/* -** Scheduler routines -*/ - -/** -** schedule(pcb) -** -** Schedule the supplied process -** -** @param pcb Pointer to the PCB of the process to be scheduled -*/ -void schedule( pcb_t *pcb ) { - - // sanity check - assert1( pcb != NULL ); - - // check for a killed process - if( pcb->state == STATE_KILLED ) { - // TODO figure out what to do now - return; - } - - // mark it as ready - pcb->state = STATE_READY; - - // add it to the ready queue - if( pcb_queue_insert(ready,pcb) != SUCCESS ) { - PANIC( 0, "schedule insert fail" ); - } -} - -/** -** dispatch() -** -** Select the next process to receive the CPU -*/ -void dispatch( void ) { - - // verify that there is no current process - assert( current == NULL ); - - // grab whoever is at the head of the queue - int status = pcb_queue_remove( ready, ¤t ); - if( status != SUCCESS ) { - sprint( b256, "dispatch queue remove failed, code %d", status ); - PANIC( 0, b256 ); - } - - // set the process up for success - current->state = STATE_RUNNING; - current->ticks = QUANTUM_STANDARD; -} - - -/* -** Debugging/tracing routines -*/ - -/** -** ctx_dump(msg,context) -** -** Dumps the contents of this process context to the console -** -** @param msg[in] An optional message to print before the dump -** @param c[in] The context to dump out -*/ -void ctx_dump( const char *msg, register context_t *c ) { - - // first, the message (if there is one) - if( msg ) { - cio_puts( msg ); - } - - // the pointer - cio_printf( " @ %08x: ", (uint32_t) c ); - - // if it's NULL, why did you bother calling me? - if( c == NULL ) { - cio_puts( " NULL???\n" ); - return; - } - - // now, the contents - cio_printf( "ss %04x gs %04x fs %04x es %04x ds %04x cs %04x\n", - c->ss & 0xff, c->gs & 0xff, c->fs & 0xff, - c->es & 0xff, c->ds & 0xff, c->cs & 0xff ); - cio_printf( " edi %08x esi %08x ebp %08x esp %08x\n", - c->edi, c->esi, c->ebp, c->esp ); - cio_printf( " ebx %08x edx %08x ecx %08x eax %08x\n", - c->ebx, c->edx, c->ecx, c->eax ); - cio_printf( " vec %08x cod %08x eip %08x eflags %08x\n", - c->vector, c->code, c->eip, c->eflags ); -} - -/** -** ctx_dump_all(msg) -** -** dump the process context for all active processes -** -** @param msg[in] Optional message to print -*/ -void ctx_dump_all( const char *msg ) { - - if( msg != NULL ) { - cio_puts( msg ); - } - - int n = 0; - register pcb_t *pcb = ptable; - for( int i = 0; i < N_PROCS; ++i, ++pcb ) { - if( pcb->state != STATE_UNUSED ) { - ++n; - cio_printf( "%2d(%d): ", n, pcb->pid ); - ctx_dump( NULL, pcb->context ); - } - } -} - -/** -** _pcb_dump(msg,pcb) -** -** Dumps the contents of this PCB to the console -** -** @param msg[in] An optional message to print before the dump -** @param pcb[in] The PCB to dump -** @param all[in] Dump all the contents? -*/ -void pcb_dump( const char *msg, register pcb_t *pcb, bool_t all ) { - - // first, the message (if there is one) - if( msg ) { - cio_puts( msg ); - } - - // the pointer - cio_printf( " @ %08x:", (uint32_t) pcb ); - - // if it's NULL, why did you bother calling me? - if( pcb == NULL ) { - cio_puts( " NULL???\n" ); - return; - } - - cio_printf( " %d", pcb->pid ); - cio_printf( " %s", - pcb->state >= N_STATES ? "???" : state_str[pcb->state] ); - - if( !all ) { - // just printing IDs and states on one line - return; - } - - // now, the rest of the contents - cio_printf( " %s", - pcb->priority >= N_PRIOS ? "???" : prio_str[pcb->priority] ); - - cio_printf( " ticks %u xit %d wake %08x\n", - pcb->ticks, pcb->exit_status, pcb->wakeup ); - - cio_printf( " parent %08x", (uint32_t)pcb->parent ); - if( pcb->parent != NULL ) { - cio_printf( " (%u)", pcb->parent->pid ); - } - - cio_printf( " next %08x context %08x pde %08x", (uint32_t) pcb->next, - (uint32_t) pcb->context, (uint32_t) pcb->pdir ); - - cio_putchar( '\n' ); -} - -/** -** pcb_queue_dump(msg,queue,contents) -** -** Dump the contents of the specified queue to the console -** -** @param msg[in] Optional message to print -** @param queue[in] The queue to dump -** @param contents[in] Also dump (some) contents? -*/ -void pcb_queue_dump( const char *msg, pcb_queue_t queue, bool_t contents ) { - - // report on this queue - cio_printf( "%s: ", msg ); - if( queue == NULL ) { - cio_puts( "NULL???\n" ); - return; - } - - // first, the basic data - cio_printf( "head %08x tail %08x", - (uint32_t) queue->head, (uint32_t) queue->tail ); - - // next, how the queue is ordered - cio_printf( " order %s\n", - queue->order >= N_ORDERINGS ? "????" : ord_str[queue->order] ); - - // if there are members in the queue, dump the first few PIDs - if( contents && queue->head != NULL ) { - cio_puts( " PIDs: " ); - pcb_t *tmp = queue->head; - for( int i = 0; i < 5 && tmp != NULL; ++i, tmp = tmp->next ) { - cio_printf( " [%u]", tmp->pid ); - } - - if( tmp != NULL ) { - cio_puts( " ..." ); - } - - cio_putchar( '\n' ); - } -} - -/** -** ptable_dump(msg,all) -** -** dump the contents of the "active processes" table -** -** @param msg[in] Optional message to print -** @param all[in] Dump all or only part of the relevant data -*/ -void ptable_dump( const char *msg, bool_t all ) { - - if( msg ) { - cio_puts( msg ); - } - cio_putchar( ' ' ); - - int used = 0; - int empty = 0; - - register pcb_t *pcb = ptable; - for( int i = 0; i < N_PROCS; ++i ) { - if( pcb->state == STATE_UNUSED ) { - - // an empty slot - ++empty; - - } else { - - // a non-empty slot - ++used; - - // if not dumping everything, add commas if needed - if( !all && used ) { - cio_putchar( ',' ); - } - - // report the table slot # - cio_printf( " #%d:", i ); - - // and dump the contents - pcb_dump( NULL, pcb, all ); - } - } - - // only need this if we're doing one-line output - if( !all ) { - cio_putchar( '\n' ); - } - - // sanity check - make sure we saw the correct number of table slots - if( (used + empty) != N_PROCS ) { - cio_printf( "Table size %d, used %d + empty %d = %d???\n", - N_PROCS, used, empty, used + empty ); - } -} - -/** -** Name: ptable_dump_counts -** -** Prints basic information about the process table (number of -** entries, number with each process state, etc.). -*/ -void ptable_dump_counts( void ) { - uint_t nstate[N_STATES] = { 0 }; - uint_t unknown = 0; - - int n = 0; - pcb_t *ptr = ptable; - while( n < N_PROCS ) { - if( ptr->state < 0 || ptr->state >= N_STATES ) { - ++unknown; - } else { - ++nstate[ptr->state]; - } - ++n; - ++ptr; - } - - cio_printf( "Ptable: %u ***", unknown ); - for( n = 0; n < N_STATES; ++n ) { - cio_printf( " %u %s", nstate[n], - state_str[n] != NULL ? state_str[n] : "???" ); - } - cio_putchar( '\n' ); -} diff --git a/kernel/old/sio.c b/kernel/old/sio.c deleted file mode 100644 index a5c7b75..0000000 --- a/kernel/old/sio.c +++ /dev/null @@ -1,694 +0,0 @@ -/** -** @file sio.c -** -** @author Warren R. Carithers -** -** @brief SIO module -** -** For maximum compatibility from semester to semester, this code uses -** several "stand-in" type names and macros which should be defined -** in the accompanying "compat.h" header file if they're not part of -** the baseline system: -** -** standard-sized integer types: intN_t, uintN_t -** other types: PCBTYPE, QTYPE -** scheduler functions: SCHED, DISPATCH -** queue functions: QCREATE, QLENGTH, QDEQUE -** other functions: SLENGTH -** sio read queue: QNAME -** -** Our SIO scheme is very simple: -** -** Input: We maintain a buffer of incoming characters that haven't -** yet been read by processes. When a character comes in, if -** there is no process waiting for it, it goes in the buffer; -** otherwise, the first waiting process is awakeneda and it -** gets the character. -** -** When a process invokes readch(), if there is a character in -** the input buffer, the process gets it; otherwise, it is -** blocked until input appears -** -** Communication with system calls is via two routines. -** sio_readc() returns the first available character (if -** there is one), resetting the input variables if this was -** the last character in the buffer. If there are no -** characters in the buffer, sio_read() returns a -1 -** (presumably so the requesting process can be blocked). -** -** sio_read() copies the contents of the input buffer into -** a user-supplied buffer. It returns the number of characters -** copied. If there are no characters available, return a -1. -** -** Output: We maintain a buffer of outgoing characters that haven't -** yet been sent to the device, and an indication of whether -** or not we are in the middle of a transmit sequence. When -** an interrupt comes in, if there is another character to -** send we copy it to the transmitter buffer; otherwise, we -** end the transmit sequence. -** -** Communication with user processes is via three functions. -** sio_writec() writes a single character; sio_write() -** writes a sized buffer full of characters; sio_puts() -** prints a NUL-terminated string. If we are in the middle -** of a transmit sequence, all characters will be added -** to the output buffer (from where they will be sent -** automatically); otherwise, we send the first character -** directly, add the rest of the characters (if there are -** any) to the output buffer, and set the "sending" flag -** to indicate that we're expecting a transmitter interrupt. -*/ - -#define KERNEL_SRC - -// this should do all includes required for this OS -#include <compat.h> - -// all other framework includes are next -#include <x86/uart.h> -#include <x86/arch.h> -#include <x86/pic.h> - -#include <sio.h> -#include <lib.h> - -/* -** PRIVATE DEFINITIONS -*/ - -#define BUF_SIZE 2048 - -/* -** PRIVATE GLOBALS -*/ - - // input character buffer -static char inbuffer[ BUF_SIZE ]; -static char *inlast; -static char *innext; -static uint32_t incount; - - // output character buffer -static char outbuffer[ BUF_SIZE ]; -static char *outlast; -static char *outnext; -static uint32_t outcount; - - // output control flag -static int sending; - - // interrupt register status -static uint8_t ier; - -/* -** PUBLIC GLOBAL VARIABLES -*/ - -// queue for read-blocked processes -#ifdef QNAME -QTYPE QNAME; -#endif - -/* -** PRIVATE FUNCTIONS -*/ - -/** -** sio_isr(vector,ecode) -** -** Interrupt handler for the SIO module. Handles all pending -** events (as described by the SIO controller). -** -** @param vector The interrupt vector number for this interrupt -** @param ecode The error code associated with this interrupt -*/ -static void sio_isr( int vector, int ecode ) { - int ch; - -#if TRACING_SIO_ISR - cio_puts( "SIO: int:" ); -#endif - // - // Must process all pending events; loop until the IRR - // says there's nothing else to do. - // - - for(;;) { - - // get the "pending event" indicator - int iir = inb( UA4_IIR ) & UA4_IIR_INT_PRI_MASK; - - // process this event - switch( iir ) { - - case UA4_IIR_LINE_STATUS: - // shouldn't happen, but just in case.... - cio_printf( "** SIO int, LSR = %02x\n", inb(UA4_LSR) ); - break; - - case UA4_IIR_RX: -#if TRACING_SIO_ISR - cio_puts( " RX" ); -#endif - // get the character - ch = inb( UA4_RXD ); - if( ch == '\r' ) { // map CR to LF - ch = '\n'; - } -#if TRACING_SIO_ISR - cio_printf( " ch %02x", ch ); -#endif - -#ifdef QNAME - // - // If there is a waiting process, this must be - // the first input character; give it to that - // process and awaken the process. - // - - if( !QEMPTY(QNAME) ) { - PCBTYPE *pcb; - - QDEQUE( QNAME, pcb ); - // make sure we got a non-NULL result - assert( pcb ); - - // return char via arg #2 and count in EAX - char *buf = (char *) ARG(pcb,2); - *buf = ch & 0xff; - RET(pcb) = 1; - SCHED( pcb ); - - } else { -#endif /* QNAME */ - - // - // Nobody waiting - add to the input buffer - // if there is room, otherwise just ignore it. - // - - if( incount < BUF_SIZE ) { - *inlast++ = ch; - ++incount; - } - -#ifdef QNAME - } -#endif /* QNAME */ - break; - - case UA5_IIR_RX_FIFO: - // shouldn't happen, but just in case.... - ch = inb( UA4_RXD ); - cio_printf( "** SIO FIFO timeout, RXD = %02x\n", ch ); - break; - - case UA4_IIR_TX: -#if TRACING_SIO_ISR - cio_puts( " TX" ); -#endif - // if there is another character, send it - if( sending && outcount > 0 ) { -#if TRACING_SIO_ISR - cio_printf( " ch %02x", *outnext ); -#endif - outb( UA4_TXD, *outnext ); - ++outnext; - // wrap around if necessary - if( outnext >= (outbuffer + BUF_SIZE) ) { - outnext = outbuffer; - } - --outcount; -#if TRACING_SIO_ISR - cio_printf( " (outcount %d)", outcount ); -#endif - } else { -#if TRACING_SIO_ISR - cio_puts( " EOS" ); -#endif - // no more data - reset the output vars - outcount = 0; - outlast = outnext = outbuffer; - sending = 0; - // disable TX interrupts - sio_disable( SIO_TX ); - } - break; - - case UA4_IIR_NO_INT: -#if TRACING_SIO_ISR - cio_puts( " EOI\n" ); -#endif - // nothing to do - tell the PIC we're done - outb( PIC1_CMD, PIC_EOI ); - return; - - case UA4_IIR_MODEM_STATUS: - // shouldn't happen, but just in case.... - cio_printf( "** SIO int, MSR = %02x\n", inb(UA4_MSR) ); - break; - - default: - // uh-oh.... - sprint( b256, "sio isr: IIR %02x\n", ((uint32_t) iir) & 0xff ); - PANIC( 0, b256 ); - } - - } - - // should never reach this point! - assert( false ); -} - -/* -** PUBLIC FUNCTIONS -*/ - -/** -** sio_init() -** -** Initialize the UART chip. -*/ -void sio_init( void ) { - -#if TRACING_INIT - cio_puts( " Sio" ); -#endif - - /* - ** Initialize SIO variables. - */ - - memclr( (void *) inbuffer, sizeof(inbuffer) ); - inlast = innext = inbuffer; - incount = 0; - - memclr( (void *) outbuffer, sizeof(outbuffer) ); - outlast = outnext = outbuffer; - outcount = 0; - sending = 0; - - // queue of read-blocked processes - QCREATE( QNAME ); - - /* - ** Next, initialize the UART. - ** - ** Initialize the FIFOs - ** - ** this is a bizarre little sequence of operations - */ - - outb( UA5_FCR, 0x20 ); - outb( UA5_FCR, UA5_FCR_FIFO_RESET ); // 0x00 - outb( UA5_FCR, UA5_FCR_FIFO_EN ); // 0x01 - outb( UA5_FCR, UA5_FCR_FIFO_EN | UA5_FCR_RXSR ); // 0x03 - outb( UA5_FCR, UA5_FCR_FIFO_EN | UA5_FCR_RXSR | UA5_FCR_TXSR ); // 0x07 - - /* - ** disable interrupts - ** - ** note that we leave them disabled; sio_enable() must be - ** called to switch them back on - */ - - outb( UA4_IER, 0 ); - ier = 0; - - /* - ** select the divisor latch registers and set the data rate - */ - - outb( UA4_LCR, UA4_LCR_DLAB ); - outb( UA4_DLL, BAUD_LOW_BYTE( DL_BAUD_9600 ) ); - outb( UA4_DLM, BAUD_HIGH_BYTE( DL_BAUD_9600 ) ); - - /* - ** deselect the latch registers, by setting the data - ** characteristics in the LCR - */ - - outb( UA4_LCR, UA4_LCR_WLS_8 | UA4_LCR_1_STOP_BIT | UA4_LCR_NO_PARITY ); - - /* - ** Set the ISEN bit to enable the interrupt request signal, - ** and the DTR and RTS bits to enable two-way communication. - */ - - outb( UA4_MCR, UA4_MCR_ISEN | UA4_MCR_DTR | UA4_MCR_RTS ); - - /* - ** Install our ISR - */ - - install_isr( VEC_COM1, sio_isr ); -} - -/** -** sio_enable() -** -** Enable SIO interrupts -** -** usage: uint8_t old = sio_enable( uint8_t which ) -** -** @param which Bit mask indicating which interrupt(s) to enable -** -** @return the prior IER setting -*/ -uint8_t sio_enable( uint8_t which ) { - uint8_t old; - - // remember the current status - - old = ier; - - // figure out what to enable - - if( which & SIO_TX ) { - ier |= UA4_IER_TX_IE; - } - - if( which & SIO_RX ) { - ier |= UA4_IER_RX_IE; - } - - // if there was a change, make it - - if( old != ier ) { - outb( UA4_IER, ier ); - } - - // return the prior settings - - return( old ); -} - -/** -** sio_disable() -** -** Disable SIO interrupts -** -** usage: uint8_t old = sio_disable( uint8_t which ) -** -** @param which Bit mask indicating which interrupt(s) to disable -** -** @return the prior IER setting -*/ -uint8_t sio_disable( uint8_t which ) { - uint8_t old; - - // remember the current status - - old = ier; - - // figure out what to disable - - if( which & SIO_TX ) { - ier &= ~UA4_IER_TX_IE; - } - - if( which & SIO_RX ) { - ier &= ~UA4_IER_RX_IE; - } - - // if there was a change, make it - - if( old != ier ) { - outb( UA4_IER, ier ); - } - - // return the prior settings - - return( old ); -} - -/** -** sio_inq_length() -** -** Get the input queue length -** -** usage: int num = sio_inq_length() -** -** @return the count of characters still in the input queue -*/ -int sio_inq_length( void ) { - return( incount ); -} - -/** -** sio_readc() -** -** Get the next input character -** -** usage: int ch = sio_readc() -** -** @return the next character, or -1 if no character is available -*/ -int sio_readc( void ) { - int ch; - - // assume there is no character available - ch = -1; - - // - // If there is a character, return it - // - - if( incount > 0 ) { - - // take it out of the input buffer - ch = ((int)(*innext++)) & 0xff; - --incount; - - // reset the buffer variables if this was the last one - if( incount < 1 ) { - inlast = innext = inbuffer; - } - - } - - return( ch ); - -} - -/** -** sio_read(buf,length) -** -** Read the entire input buffer into a user buffer of a specified size -** -** usage: int num = sio_read( char *buffer, int length ) -** -** @param buf The destination buffer -** @param length Length of the buffer -** -** @return the number of bytes copied, or 0 if no characters were available -*/ - -int sio_read( char *buf, int length ) { - char *ptr = buf; - int copied = 0; - - // if there are no characters, just return 0 - - if( incount < 1 ) { - return( 0 ); - } - - // - // We have characters. Copy as many of them into the user - // buffer as will fit. - // - - while( incount > 0 && copied < length ) { - *ptr++ = *innext++ & 0xff; - if( innext > (inbuffer + BUF_SIZE) ) { - innext = inbuffer; - } - --incount; - ++copied; - } - - // reset the input buffer if necessary - - if( incount < 1 ) { - inlast = innext = inbuffer; - } - - // return the copy count - - return( copied ); -} - - -/** -** sio_writec( ch ) -** -** Write a character to the serial output -** -** usage: sio_writec( int ch ) -** -** @param ch Character to be written (in the low-order 8 bits) -*/ -void sio_writec( int ch ){ - - - // - // Must do LF -> CRLF mapping - // - - if( ch == '\n' ) { - sio_writec( '\r' ); - } - - // - // If we're currently transmitting, just add this to the buffer - // - - if( sending ) { - *outlast++ = ch; - ++outcount; - return; - } - - // - // Not sending - must prime the pump - // - - sending = 1; - outb( UA4_TXD, ch ); - - // Also must enable transmitter interrupts - - sio_enable( SIO_TX ); - -} - -/** -** sio_write( buffer, length ) -** -** Write a buffer of characters to the serial output -** -** usage: int num = sio_write( const char *buffer, int length ) -** -** @param buffer Buffer containing characters to write -** @param length Number of characters to write -** -** @return the number of characters copied into the SIO output buffer -*/ -int sio_write( const char *buffer, int length ) { - int first = *buffer; - const char *ptr = buffer; - int copied = 0; - - // - // If we are currently sending, we want to append all - // the characters to the output buffer; else, we want - // to append all but the first character, and then use - // sio_writec() to send the first one out. - // - - if( !sending ) { - ptr += 1; - copied++; - } - - while( copied < length && outcount < BUF_SIZE ) { - *outlast++ = *ptr++; - // wrap around if necessary - if( outlast >= (outbuffer + BUF_SIZE) ) { - outlast = outbuffer; - } - ++outcount; - ++copied; - } - - // - // We use sio_writec() to send out the first character, - // as it will correctly set all the other necessary - // variables for us. - // - - if( !sending ) { - sio_writec( first ); - } - - // Return the transfer count - - - return( copied ); - -} - -/** -** sio_puts( buf ) -** -** Write a NUL-terminated buffer of characters to the serial output -** -** usage: int num = sio_puts( const char *buffer ) -** -** @param buffer The buffer containing a NUL-terminated string -** -** @return the count of bytes transferred -*/ -int sio_puts( const char *buffer ) { - int n; // must be outside the loop so we can return it - - n = SLENGTH( buffer ); - sio_write( buffer, n ); - - return( n ); -} - -/** -** sio_dump( full ) -** -** dump the contents of the SIO buffers to the console -** -** usage: sio_dump(true) or sio_dump(false) -** -** @param full Boolean indicating whether or not a "full" dump -** is being requested (which includes the contents -** of the queues) -*/ - -void sio_dump( bool_t full ) { - int n; - char *ptr; - - // dump basic info into the status region - - cio_printf_at( 48, 0, - "SIO: IER %02x (%c%c%c) in %d ot %d", - ((uint32_t)ier) & 0xff, sending ? '*' : '.', - (ier & UA4_IER_TX_IE) ? 'T' : 't', - (ier & UA4_IER_RX_IE) ? 'R' : 'r', - incount, outcount ); - - // if we're not doing a full dump, stop now - - if( !full ) { - return; - } - - // also want the queue contents, but we'll - // dump them into the scrolling region - - if( incount ) { - cio_puts( "SIO input queue: \"" ); - ptr = innext; - for( n = 0; n < incount; ++n ) { - put_char_or_code( *ptr++ ); - } - cio_puts( "\"\n" ); - } - - if( outcount ) { - cio_puts( "SIO output queue: \"" ); - cio_puts( " ot: \"" ); - ptr = outnext; - for( n = 0; n < outcount; ++n ) { - put_char_or_code( *ptr++ ); - } - cio_puts( "\"\n" ); - } -} diff --git a/kernel/old/startup.S b/kernel/old/startup.S deleted file mode 100644 index 73a081e..0000000 --- a/kernel/old/startup.S +++ /dev/null @@ -1,153 +0,0 @@ -/* -** @file startup.S -** -** @author Jon Coles -** @authors Warren R. Carithers, K. Reek -** -** SP startup code. -** -** This code prepares the various registers for execution of -** the program. It sets up all the segment registers and the -** runtime stack. By the time this code is running, we're in -** protected mode already. -*/ - -#define KERNEL_SRC -#define ASM_SRC - -# .arch i386 - -#include <common.h> -#include <bootstrap.h> -#include <x86/arch.h> -#include <x86/bios.h> -#include <vm.h> - -/* -** Configuration options - define in Makefile -** -** CLEAR_BSS include code to clear all BSS space -** OS_CONFIG OS-related (vs. just standalone) variations -*/ - -/* -** A symbol for locating the beginning of the code. -*/ - .globl begtext - - .text -begtext: - -/* -** The entry point. When we get here, we have just entered protected -** mode, so all the segment registers are incorrect except for CS. -*/ - .globl _start - -_start: - cli /* seems to be reset on entry to p. mode */ - movb $NMI_ENABLE, %al /* re-enable NMIs (bootstrap */ - outb $CMOS_ADDR /* turned them off) */ - -/* -** Set the data and stack segment registers (code segment register -** was set by the long jump that switched us into protected mode). -*/ - xorl %eax, %eax /* clear EAX */ - movw $GDT_DATA, %ax /* GDT entry #3 - data segment */ - movw %ax, %ds /* for all four data segment registers */ - movw %ax, %es - movw %ax, %fs - movw %ax, %gs - - movw $GDT_STACK, %ax /* entry #4 is the stack segment */ - movw %ax, %ss - - movl $TARGET_STACK, %esp /* set up the system stack pointer */ - -#ifdef CLEAR_BSS -/* -** Zero the BSS segment -** -** These symbols are defined automatically by the linker, but they're -** defined at their virtual addresses rather than their physical addresses, -** and we haven't enabled paging yet. -*/ - .globl __bss_start, _end - - movl $V2PNC(__bss_start), %edi -clearbss: - movl $0, (%edi) - addl $4, %edi - cmpl $V2PNC(_end), %edi - jb clearbss -#endif /* CLEAR_BSS */ - -/* -** Enable paging. We use "large" pages for the initial page directory -** so that a one-level hierarchy will work for us. Once we have set -** up our memory freelist, we'll create a two-level hierarchy using -** "normal" 4KB pages. -*/ - # enable large pages - movl %cr4, %eax - orl $(CR4_PSE), %eax - movl %eax, %cr4 - - # set the page directory - .globl firstpdir - movl $(V2PNC(firstpdir)), %eax - movl %eax, %cr3 - - # turn on paging - movl %cr0, %eax - orl $(CR0_PG), %eax - movl %eax, %cr0 - - # reset our stack pointer - movl $(kstack + SZ_KSTACK), %esp - - # set the initial frame pointer - xorl %ebp, %ebp - -/* -** Call the system initialization routine, and switch to -** executing at high addresses. We use an indirect jump -** here to avoid getting a PC-relative 'jmp' instruction. -** -** Alternate idea: push the address of isr_restore -** and just do an indirect jump? -*/ - .globl main - - movl $main, %eax - call *%eax - -/* -** At this point, main() must have created the first user -** process, and we're ready to shift into user mode. The user -** stack for that process must have the initial context in it; -** we treat this as a "return from interrupt" event, and just -** transfer to the code that restores the user context. -*/ - - .globl isr_restore - jmp isr_restore - - .data - -/* -** Define the kernel stack here, at a multiple-of-16 address -*/ - .p2align 4 - .globl kstack -kstack: .space SZ_KSTACK, 0 - -/* -** Define the initial kernel ESP here, as well. It should point -** to the first byte after the stack. -*/ - - .globl kernel_esp -kernel_esp: - .long kstack + SZ_KSTACK diff --git a/kernel/old/support.c b/kernel/old/support.c deleted file mode 100644 index d48ce59..0000000 --- a/kernel/old/support.c +++ /dev/null @@ -1,279 +0,0 @@ -/* -** SCCS ID: @(#)support.c 2.6 1/22/25 -** -** @file support.c -** -** @author 4003-506 class of 20003 -** @authors K. Reek, Warren R. Carithers -** -** Miscellaneous system initialization functions, interrupt -** support routines, and data structures. -*/ - -#include <common.h> - -#include <support.h> -#include <cio.h> -#include <x86/arch.h> -#include <x86/pic.h> -#include <x86/ops.h> -#include <bootstrap.h> -#include <syscalls.h> - -/* -** Global variables and local data types. -*/ - -/* -** This is the table that contains pointers to the C-language ISR for -** each interrupt. These functions are called from the isr stub based -** on the interrupt number. -*/ -void ( *isr_table[ 256 ] )( int vector, int code ); - -/* -** Format of an IDT entry. -*/ -typedef struct { - short offset_15_0; - short segment_selector; - short flags; - short offset_31_16; -} IDT_Gate; - -/* -** LOCAL ROUTINES - not intended to be used outside this module. -*/ - -/** -** unexpected_handler -** -** This routine catches interrupts that we do not expect to ever occur. -** It handles them by (optionally) reporting them and then calling panic(). -** -** @param vector vector number for the interrupt that occurred -** @param code error code, or a dummy value -** -** Does not return. -*/ -#ifdef RPT_INT_UNEXP -/* add any header includes you need here */ -#endif -static void unexpected_handler( int vector, int code ) { -#ifdef RPT_INT_UNEXP - cio_printf( "\n** UNEXPECTED vector %d code %d\n", vector, code ); -#endif - panic( "Unexpected interrupt" ); -} - -/** -** default_handler -** -** Default handler for interrupts we expect may occur but are not -** handling (yet). We just reset the PIC and return. -** -** @param vector vector number for the interrupt that occurred -** @param code error code, or a dummy value -*/ -static void default_handler( int vector, int code ) { -#ifdef RPT_INT_UNEXP - cio_printf( "\n** vector %d code %d\n", vector, code ); -#endif - if( vector >= 0x20 && vector < 0x30 ) { - if( vector > 0x27 ) { - // must also ACK the secondary PIC - outb( PIC2_CMD, PIC_EOI ); - } - outb( PIC1_CMD, PIC_EOI ); - } else { - /* - ** All the "expected" interrupts will be handled by the - ** code above. If we get down here, the isr table may - ** have been corrupted. Print a message and don't return. - */ - panic( "Unexpected \"expected\" interrupt!" ); - } -} - -/** -** mystery_handler -** -** Default handler for the "mystery" interrupt that comes through vector -** 0x27. This is a non-repeatable interrupt whose source has not been -** identified, but it appears to be the famous "spurious level 7 interrupt" -** source. -** -** @param vector vector number for the interrupt that occurred -** @param code error code, or a dummy value -*/ -static void mystery_handler( int vector, int code ) { -#if defined(RPT_INT_MYSTERY) || defined(RPT_INT_UNEXP) - cio_printf( "\nMystery interrupt!\nVector=0x%02x, code=%d\n", - vector, code ); -#endif - outb( PIC1_CMD, PIC_EOI ); -} - -/** -** init_pic -** -** Initialize the 8259 Programmable Interrupt Controller. -*/ -static void init_pic( void ) { - /* - ** ICW1: start the init sequence, update ICW4 - */ - outb( PIC1_CMD, PIC_CW1_INIT | PIC_CW1_NEED4 ); - outb( PIC2_CMD, PIC_CW1_INIT | PIC_CW1_NEED4 ); - - /* - ** ICW2: primary offset of 0x20 in the IDT, secondary offset of 0x28 - */ - outb( PIC1_DATA, PIC1_CW2_VECBASE ); - outb( PIC2_DATA, PIC2_CW2_VECBASE ); - - /* - ** ICW3: secondary attached to line 2 of primary, bit mask is 00000100 - ** secondary id is 2 - */ - outb( PIC1_DATA, PIC1_CW3_SEC_IRQ2 ); - outb( PIC2_DATA, PIC2_CW3_SEC_ID ); - - /* - ** ICW4: want 8086 mode, not 8080/8085 mode - */ - outb( PIC1_DATA, PIC_CW4_PM86 ); - outb( PIC2_DATA, PIC_CW4_PM86 ); - - /* - ** OCW1: allow interrupts on all lines - */ - outb( PIC1_DATA, PIC_MASK_NONE ); - outb( PIC2_DATA, PIC_MASK_NONE ); -} - -/** -** set_idt_entry -** -** Construct an entry in the IDT -** -** @param entry the vector number of the interrupt -** @param handler ISR address to be put into the IDT entry -** -** Note: generally, the handler invoked from the IDT will be a "stub" -** that calls the second-level C handler via the isr_table array. -*/ -static void set_idt_entry( int entry, void ( *handler )( void ) ) { - IDT_Gate *g = (IDT_Gate *)IDT_ADDR + entry; - - g->offset_15_0 = (int)handler & 0xffff; - g->segment_selector = 0x0010; - g->flags = IDT_PRESENT | IDT_DPL_0 | IDT_INT32_GATE; - g->offset_31_16 = (int)handler >> 16 & 0xffff; -} - -/** -** Name: init_idt -** -** Initialize the Interrupt Descriptor Table (IDT). This makes each of -** the entries in the IDT point to the isr stub for that entry, and -** installs a default handler in the handler table. Temporary handlers -** are then installed for those interrupts we may get before a real -** handler is set up. -*/ -static void init_idt( void ) { - int i; - extern void ( *isr_stub_table[ 256 ] )( void ); - - /* - ** Make each IDT entry point to the stub for that vector. Also - ** make each entry in the ISR table point to the default handler. - */ - for ( i=0; i < 256; i++ ) { - set_idt_entry( i, isr_stub_table[ i ] ); - install_isr( i, unexpected_handler ); - } - - /* - ** Install the handlers for interrupts that have (or will have) a - ** specific handler. Comments indicate which module init function - ** will eventually install the "real" handler. - */ - - install_isr( VEC_KBD, default_handler ); // cio_init() - install_isr( VEC_COM1, default_handler ); // sio_init() - install_isr( VEC_TIMER, default_handler ); // clk_init() - install_isr( VEC_SYSCALL, default_handler ); // sys_init() - install_isr( VEC_PAGE_FAULT, default_handler ); // vm_init() - - install_isr( VEC_MYSTERY, mystery_handler ); -} - -/* -** END OF LOCAL ROUTINES. -** -** Full documentation for globally-visible routines is in the corresponding -** header file. -*/ - -/* -** panic -** -** Called when we find an unrecoverable error. -*/ -void panic( char *reason ) { - __asm__( "cli" ); - cio_printf( "\nPANIC: %s\nHalting...", reason ); - for(;;) { - ; - } -} - -/* -** init_interrupts -** -** (Re)initilizes the interrupt system. -*/ -void init_interrupts( void ) { - init_idt(); - init_pic(); -} - -/* -** install_isr -** -** Installs a second-level handler for a specific interrupt. -*/ -void (*install_isr( int vector, - void (*handler)(int,int) ) ) ( int, int ) { - - void ( *old_handler )( int vector, int code ); - - old_handler = isr_table[ vector ]; - isr_table[ vector ] = handler; - return old_handler; -} - -/* -** Name: delay -** -** Notes: The parameter to the delay() function is ambiguous; it -** purports to indicate a delay length, but that isn't really tied -** to any real-world time measurement. -** -** On the original systems we used (dual 500MHz Intel P3 CPUs), each -** "unit" was approximately one tenth of a second, so delay(10) would -** delay for about one second. -** -** On the current machines (Intel Core i5-7500), delay(100) is about -** 2.5 seconds, so each "unit" is roughly 0.025 seconds. -** -** Ultimately, just remember that DELAY VALUES ARE APPROXIMATE AT BEST. -*/ -void delay( int length ) { - - while( --length >= 0 ) { - for( int i = 0; i < 10000000; ++i ) - ; - } -} diff --git a/kernel/old/syscalls.c b/kernel/old/syscalls.c deleted file mode 100644 index 7176cda..0000000 --- a/kernel/old/syscalls.c +++ /dev/null @@ -1,829 +0,0 @@ -/** -** @file syscalls.c -** -** @author CSCI-452 class of 20245 -** -** @brief System call implementations -*/ - -#define KERNEL_SRC - -#include <common.h> - -#include <cio.h> -#include <clock.h> -#include <procs.h> -#include <sio.h> -#include <syscalls.h> -#include <user.h> -#include <vm.h> -#include <x86/pic.h> - -/* -** PRIVATE DEFINITIONS -*/ - -/* -** Macros to simplify tracing a bit -** -** TRACING_SYSCALLS and TRACING_SYSRETS are defined in debug.h, -** controlled by the TRACE ** macro. If not tracing these, SYSCALL_ENTER -** is a no-op, and SYSCALL_EXIT just does a return. -*/ - -#if TRACING_SYSCALLS - -#define SYSCALL_ENTER(x) do { \ - cio_printf( "--> %s, pid %08x", __func__, (uint32_t) (x) ); \ - } while(0) - -#else - -#define SYSCALL_ENTER(x) /* */ - -#endif /* TRACING_SYSCALLS */ - -#if TRACING_SYSRETS - -#define SYSCALL_EXIT(x) do { \ - cio_printf( "<-- %s %08x\n", __func__, (uint32_t) (x) ); \ - return; \ - } while(0) - -#else - -#define SYSCALL_EXIT(x) return - -#endif /* TRACING_SYSRETS */ - -/* -** PRIVATE DATA TYPES -*/ - -/* -** PUBLIC GLOBAL VARIABLES -*/ - -/* -** IMPLEMENTATION FUNCTIONS -*/ - -// a macro to simplify syscall entry point specification -// we don't declare these static because we may want to call -// some of them from other parts of the kernel -#define SYSIMPL(x) void sys_##x( pcb_t * pcb ) - -/* -** Second-level syscall handlers -** -** All have this prototype: -** -** static void sys_NAME( pcb_t *pcb ); -** -** where the parameter 'pcb' is a pointer to the PCB of the process -** making the system call. -** -** Values being returned to the user are placed into the EAX -** field in the context save area for that process. -*/ - -/** -** sys_exit - terminate the calling process -** -** Implements: -** void exit( int32_t status ); -** -** Does not return -*/ -SYSIMPL(exit) { - - // sanity check - assert( pcb != NULL ); - - SYSCALL_ENTER( pcb->pid ); - - // retrieve the exit status of this process - pcb->exit_status = (int32_t) ARG(pcb,1); - - // now, we need to do the following: - // reparent any children of this process and wake up init if need be - // find this process' parent and wake it up if it's waiting - - pcb_zombify( pcb ); - - // pick a new winner - dispatch(); - - SYSCALL_EXIT( 0 ); -} - -/** -** sys_waitpid - wait for a child process to terminate -** -** Implements: -** int waitpid( uint_t pid, int32_t *status ); -** -** Blocks the calling process until the specified child (or any child) -** of the caller terminates. Intrinsic return is the PID of the child that -** terminated, or an error code; on success, returns the child's termination -** status via 'status' if that pointer is non-NULL. -*/ -SYSIMPL(waitpid) { - - // sanity check - assert( pcb != NULL ); - - SYSCALL_ENTER( pcb->pid ); - - /* - ** We need to do two things here: (1) find out whether or - ** not this process has any children in the system, and (2) - ** find out whether the desired child (or any child, if the - ** target PID is 0) has terminated. - ** - ** To do this, we loop until we find a the requested PID or - ** a Zombie child process, or have gone through all of the - ** slots in the process table. - ** - ** If the target PID is 0, we don't care which child process - ** we reap here; there could be several, but we only need to - ** find one. - */ - - // verify that we aren't looking for ourselves! - uint_t target = ARG(pcb,1); - - if( target == pcb->pid ) { - RET(pcb) = E_BAD_PARAM; - SYSCALL_EXIT( E_BAD_PARAM ); - } - - // Good. Now, figure out what we're looking for. - - pcb_t *child = NULL; - - if( target != 0 ) { - - // we're looking for a specific child - child = pcb_find_pid( target ); - - if( child != NULL ) { - - // found the process; is it one of our children: - if( child->parent != pcb ) { - // NO, so we can't wait for it - RET(pcb) = E_BAD_PARAM; - SYSCALL_EXIT( E_BAD_PARAM ); - } - - // yes! is this one ready to be collected? - if( child->state != STATE_ZOMBIE ) { - // no, so we'll have to block for now - child = NULL; - } - - } else { - - // no such child - RET(pcb) = E_BAD_PARAM; - SYSCALL_EXIT( E_BAD_PARAM ); - - } - - } else { - - // looking for any child - - // we need to find a process that is our child - // and has already exited - - child = NULL; - bool_t found = false; - - // unfortunately, we can't stop at the first child, - // so we need to do the iteration ourselves - register pcb_t *curr = ptable; - - for( int i = 0; i < N_PROCS; ++i, ++curr ) { - - if( curr->parent == pcb ) { - - // found one! - found = true; - - // has it already exited? - if( curr->state == STATE_ZOMBIE ) { - // yes, so we're done here - child = curr; - break; - } - } - } - - if( !found ) { - // got through the loop without finding a child! - RET(pcb) = E_NO_CHILDREN; - SYSCALL_EXIT( E_NO_CHILDREN ); - } - - } - - /* - ** At this point, one of these situations is true: - ** - ** * we are looking for a specific child and found it - ** * we are looking for any child and found one - ** - ** Either way, 'child' will be non-NULL if the selected - ** process has already become a Zombie. If that's the - ** case, we collect its status and clean it up; otherwise, - ** we block this process. - */ - - // did we find one to collect? - if( child == NULL ) { - - // no - mark the parent as "Waiting" - pcb->state = STATE_WAITING; - assert( pcb_queue_insert(waiting,pcb) == SUCCESS ); - - // select a new current process - dispatch(); - SYSCALL_EXIT( (uint32_t) current ); - } - - // found a Zombie; collect its information and clean it up - RET(pcb) = child->pid; - - // get "status" pointer from parent - int32_t *stat = (int32_t *) ARG(pcb,2); - - // if stat is NULL, the parent doesn't want the status - if( stat != NULL ) { - // ******************************************************** - // ** Potential VM issue here! This code assigns the exit - // ** status into a variable in the parent's address space. - // ** This works in the baseline because we aren't using - // ** any type of memory protection. If address space - // ** separation is implemented, this code will very likely - // ** STOP WORKING, and will need to be fixed. - // ******************************************************** - *stat = child->exit_status; - } - - // clean up the child - pcb_cleanup( child ); - - SYSCALL_EXIT( RET(pcb) ); -} - -/** -** sys_fork - create a new process -** -** Implements: -** int fork( void ); -** -** Creates a new process that is a duplicate of the calling process. -** Returns the child's PID to the parent, and 0 to the child, on success; -** else, returns an error code to the parent. -*/ -SYSIMPL(fork) { - - // sanity check - assert( pcb != NULL ); - - SYSCALL_ENTER( pcb->pid ); - - // Make sure there's room for another process! - pcb_t *new; - if( pcb_alloc(&new) != SUCCESS || new == NULL ) { - RET(pcb) = E_NO_PROCS; - SYSCALL_EXIT( RET(pcb) ); - } - - // duplicate the memory image of the parent - int status = user_duplicate( new, pcb ); - if( status != SUCCESS ) { - pcb_free( new ); - RET(pcb) = status; - SYSCALL_EXIT( status ); - } - - // Set the child's identity. - new->pid = next_pid++; - new->parent = pcb; - new->state = STATE_NEW; - - // replicate other things inherited from the parent - new->priority = pcb->priority; - - // Set the return values for the two processes. - RET(pcb) = new->pid; - RET(new) = 0; - - // Schedule the child, and let the parent continue. - schedule( new ); - - SYSCALL_EXIT( new->pid ); -} - -/** -** sys_exec - replace the memory image of a process -** -** Implements: -** void exec( uint_t what, char **args ); -** -** Replaces the memory image of the calling process with that of the -** indicated program. -** -** Returns only on failure. -*/ -SYSIMPL(exec) -{ - // sanity check - assert( pcb != NULL ); - - uint_t what = ARG(pcb,1); - const char **args = (const char **) ARG(pcb,2); - - SYSCALL_ENTER( pcb->pid ); - - // locate the requested program - prog_t *prog = user_locate( what ); - if( prog == NULL ) { - RET(pcb) = E_NOT_FOUND; - SYSCALL_EXIT( E_NOT_FOUND ); - } - - // we have located the program, but before we can load it, - // we need to clean up the existing VM hierarchy - vm_free( pcb->pdir ); - pcb->pdir = NULL; - - // "load" it and set up the VM tables for this process - int status = user_load( prog, pcb, args ); - if( status != SUCCESS ) { - RET(pcb) = status; - SYSCALL_EXIT( status ); - } - - /* - ** Decision: - ** (A) schedule this process and dispatch another, - ** (B) let this one continue in its current time slice - ** (C) reset this one's time slice and let it continue - ** - ** We choose option A. - ** - ** If scheduling the process fails, the exec() has failed. However, - ** all trace of the old process is gone by now, so we can't return - ** an error status to it. - */ - - schedule( pcb ); - - dispatch(); -} - -/** -** sys_read - read into a buffer from an input channel -** -** Implements: -** int read( uint_t chan, void *buffer, uint_t length ); -** -** Reads up to 'length' bytes from 'chan' into 'buffer'. Returns the -** count of bytes actually transferred. -*/ -SYSIMPL(read) { - - // sanity check - assert( pcb != NULL ); - - SYSCALL_ENTER( pcb->pid ); - - // grab the arguments - uint_t chan = ARG(pcb,1); - char *buf = (char *) ARG(pcb,2); - uint_t len = ARG(pcb,3); - - // if the buffer is of length 0, we're done! - if( len == 0 ) { - RET(pcb) = 0; - SYSCALL_EXIT( 0 ); - } - - // try to get the next character(s) - int n = 0; - - if( chan == CHAN_CIO ) { - - // console input is non-blocking - if( cio_input_queue() < 1 ) { - RET(pcb) = 0; - SYSCALL_EXIT( 0 ); - } - // at least one character - n = cio_gets( buf, len ); - RET(pcb) = n; - SYSCALL_EXIT( n ); - - } else if( chan == CHAN_SIO ) { - - // SIO input is blocking, so if there are no characters - // available, we'll block this process - n = sio_read( buf, len ); - RET(pcb) = n; - SYSCALL_EXIT( n ); - - } - - // bad channel code - RET(pcb) = E_BAD_PARAM; - SYSCALL_EXIT( E_BAD_PARAM ); -} - -/** -** sys_write - write from a buffer to an output channel -** -** Implements: -** int write( uint_t chan, const void *buffer, uint_t length ); -** -** Writes 'length' bytes from 'buffer' to 'chan'. Returns the -** count of bytes actually transferred. -*/ -SYSIMPL(write) { - - // sanity check - assert( pcb != NULL ); - - SYSCALL_ENTER( pcb->pid ); - - // grab the parameters - uint_t chan = ARG(pcb,1); - char *buf = (char *) ARG(pcb,2); - uint_t length = ARG(pcb,3); - - // this is almost insanely simple, but it does separate the - // low-level device access fromm the higher-level syscall implementation - - // assume we write the indicated amount - int rval = length; - - // simplest case - if( length >= 0 ) { - - if( chan == CHAN_CIO ) { - - cio_write( buf, length ); - - } else if( chan == CHAN_SIO ) { - - sio_write( buf, length ); - - } else { - - rval = E_BAD_CHAN; - - } - - } - - RET(pcb) = rval; - - SYSCALL_EXIT( rval ); -} - -/** -** sys_getpid - returns the PID of the calling process -** -** Implements: -** uint_t getpid( void ); -*/ -SYSIMPL(getpid) { - - // sanity check! - assert( pcb != NULL ); - - SYSCALL_ENTER( pcb->pid ); - - // return the time - RET(pcb) = pcb->pid; -} - -/** -** sys_getppid - returns the PID of the parent of the calling process -** -** Implements: -** uint_t getppid( void ); -*/ -SYSIMPL(getppid) { - - // sanity check! - assert( pcb != NULL ); - assert( pcb->parent != NULL ); - - SYSCALL_ENTER( pcb->pid ); - - // return the time - RET(pcb) = pcb->parent->pid; -} - -/** -** sys_gettime - returns the current system time -** -** Implements: -** uint32_t gettime( void ); -*/ -SYSIMPL(gettime) { - - // sanity check! - assert( pcb != NULL ); - - SYSCALL_ENTER( pcb->pid ); - - // return the time - RET(pcb) = system_time; -} - -/** -** sys_getprio - the scheduling priority of the calling process -** -** Implements: -** int getprio( void ); -*/ -SYSIMPL(getprio) { - - // sanity check! - assert( pcb != NULL ); - - SYSCALL_ENTER( pcb->pid ); - - // return the time - RET(pcb) = pcb->priority; -} - -/** -** sys_setprio - sets the scheduling priority of the calling process -** -** Implements: -** int setprio( int new ); -*/ -SYSIMPL(setprio) { - - // sanity check! - assert( pcb != NULL ); - - SYSCALL_ENTER( pcb->pid ); - - // remember the old priority - int old = pcb->priority; - - // set the priority - pcb->priority = ARG(pcb,1); - - // return the old value - RET(pcb) = old; -} - -/** -** sys_kill - terminate a process with extreme prejudice -** -** Implements: -** int32_t kill( uint_t pid ); -** -** Marks the specified process (or the calling process, if PID is 0) -** as "killed". Returns 0 on success, else an error code. -*/ -SYSIMPL(kill) { - - // sanity check - assert( pcb != NULL ); - - SYSCALL_ENTER( pcb->pid ); - - // who is the victim? - uint_t pid = ARG(pcb,1); - - // if it's this process, convert this into a call to exit() - if( pid == pcb->pid ) { - pcb->exit_status = EXIT_KILLED; - pcb_zombify( pcb ); - dispatch(); - SYSCALL_EXIT( EXIT_KILLED ); - } - - // must be a valid "ordinary user" PID - // QUESTION: what if it's the idle process? - if( pid < FIRST_USER_PID ) { - RET(pcb) = E_FAILURE; - SYSCALL_EXIT( E_FAILURE ); - } - - // OK, this is an acceptable victim; see if it exists - pcb_t *victim = pcb_find_pid( pid ); - if( victim == NULL ) { - // nope! - RET(pcb) = E_NOT_FOUND; - SYSCALL_EXIT( E_NOT_FOUND ); - } - - // must have a state that is possible - assert( victim->state >= FIRST_VIABLE && victim->state < N_STATES ); - - // how we perform the kill depends on the victim's state - int32_t status = SUCCESS; - - switch( victim->state ) { - - case STATE_KILLED: // FALL THROUGH - case STATE_ZOMBIE: - // you can't kill it if it's already dead - RET(pcb) = SUCCESS; - break; - - case STATE_READY: // FALL THROUGH - case STATE_SLEEPING: // FALL THROUGH - case STATE_BLOCKED: // FALL THROUGH - // here, the process is on a queue somewhere; mark - // it as "killed", and let the scheduler deal with it - victim->state = STATE_KILLED; - RET(pcb) = SUCCESS; - break; - - case STATE_RUNNING: - // we have met the enemy, and it is us! - pcb->exit_status = EXIT_KILLED; - pcb_zombify( pcb ); - status = EXIT_KILLED; - // we need a new current process - dispatch(); - break; - - case STATE_WAITING: - // similar to the 'running' state, but we don't need - // to dispatch a new process - victim->exit_status = EXIT_KILLED; - status = pcb_queue_remove_this( waiting, victim ); - pcb_zombify( victim ); - RET(pcb) = status; - break; - - default: - // this is a really bad potential problem - we have an - // unexpected or bogus process state, but we didn't - // catch that earlier. - sprint( b256, "*** kill(): victim %d, odd state %d\n", - victim->pid, victim->state ); - PANIC( 0, b256 ); - } - - SYSCALL_EXIT( status ); -} - - -/** -** sys_sleep - put the calling process to sleep for some length of time -** -** Implements: -** uint_t sleep( uint_t ms ); -** -** Puts the calling process to sleep for 'ms' milliseconds (or just yields -** the CPU if 'ms' is 0). ** Returns the time the process spent sleeping. -*/ -SYSIMPL(sleep) { - - // sanity check - assert( pcb != NULL ); - - SYSCALL_ENTER( pcb->pid ); - - // get the desired duration - uint_t length = ARG( pcb, 1 ); - - if( length == 0 ) { - - // just yield the CPU - // sleep duration is 0 - RET(pcb) = 0; - - // back on the ready queue - schedule( pcb ); - - } else { - - // sleep for a while - pcb->wakeup = system_time + length; - - if( pcb_queue_insert(sleeping,pcb) != SUCCESS ) { - // something strange is happening - WARNING( "sleep pcb insert failed" ); - // if this is the current process, report an error - if( current == pcb ) { - RET(pcb) = -1; - } - // return without dispatching a new process - return; - } - } - - // only dispatch if the current process called us - if( pcb == current ) { - current = NULL; - dispatch(); - } -} - -/* -** PRIVATE FUNCTIONS GLOBAL VARIABLES -*/ - -/* -** The system call jump table -** -** Initialized using designated initializers to ensure the entries -** are correct even if the syscall code values should happen to change. -** This also makes it easy to add new system call entries, as their -** position in the initialization list is irrelevant. -*/ - -static void (* const syscalls[N_SYSCALLS])( pcb_t * ) = { - [ SYS_exit ] = sys_exit, - [ SYS_waitpid ] = sys_waitpid, - [ SYS_fork ] = sys_fork, - [ SYS_exec ] = sys_exec, - [ SYS_read ] = sys_read, - [ SYS_write ] = sys_write, - [ SYS_getpid ] = sys_getpid, - [ SYS_getppid ] = sys_getppid, - [ SYS_gettime ] = sys_gettime, - [ SYS_getprio ] = sys_getprio, - [ SYS_setprio ] = sys_setprio, - [ SYS_kill ] = sys_kill, - [ SYS_sleep ] = sys_sleep -}; - -/** -** Name: sys_isr -** -** System call ISR -** -** @param vector Vector number for this interrupt -** @param code Error code (0 for this interrupt) -*/ -static void sys_isr( int vector, int code ) { - - // keep the compiler happy - (void) vector; - (void) code; - - // sanity check! - assert( current != NULL ); - assert( current->context != NULL ); - - // retrieve the syscall code - int num = REG( current, eax ); - -#if TRACING_SYSCALLS - cio_printf( "** --> SYS pid %u code %u\n", current->pid, num ); -#endif - - // validate it - if( num < 0 || num >= N_SYSCALLS ) { - // bad syscall number - // could kill it, but we'll just force it to exit - num = SYS_exit; - ARG(current,1) = EXIT_BAD_SYSCALL; - } - - // call the handler - syscalls[num]( current ); - -#if TRACING_SYSCALLS - cio_printf( "** <-- SYS pid %u ret %u\n", current->pid, RET(current) ); -#endif - - // tell the PIC we're done - outb( PIC1_CMD, PIC_EOI ); -} - -/* -** PUBLIC FUNCTIONS -*/ - -/** -** Name: sys_init -** -** Syscall module initialization routine -** -** Dependencies: -** Must be called after cio_init() -*/ -void sys_init( void ) { - -#if TRACING_INIT - cio_puts( " Sys" ); -#endif - - // install the second-stage ISR - install_isr( VEC_SYSCALL, sys_isr ); -} diff --git a/kernel/old/user.c b/kernel/old/user.c deleted file mode 100644 index c41867e..0000000 --- a/kernel/old/user.c +++ /dev/null @@ -1,783 +0,0 @@ -/** -** @file user.c -** -** @author CSCI-452 class of 20245 -** -** @brief User-level code manipulation routines -*/ - -#define KERNEL_SRC - -#include <common.h> - -#include <bootstrap.h> -#include <elf.h> -#include <user.h> -#include <vm.h> - -/* -** PRIVATE DEFINITIONS -*/ - -/* -** PRIVATE DATA TYPES -*/ - -/* -** PRIVATE GLOBAL VARIABLES -*/ - -/* -** PUBLIC GLOBAL VARIABLES -*/ - -/* -** Location of the "user blob" in memory. -** -** These variables are filled in by the code in startup.S using values -** passed to it from the bootstrap. -** -** These are visible so that the startup code can find them. -*/ -uint16_t user_offset; // byte offset from the segment base -uint16_t user_segment; // segment base address -uint16_t user_sectors; // number of 512-byte sectors it occupies - -header_t *user_header; // filled in by the user_init routine -prog_t *prog_table; // filled in by the user_init routine - -/* -** PRIVATE FUNCTIONS -*/ - -#if TRACING_ELF - -/* -** This is debugging support code; if not debugging the ELF -** handling code, it won't be compiled into the kernel. -*/ - -// buffer used by some of these functions -static char ebuf[16]; - -/* -** File header functions -*/ - -// interpret the file class -static const char *fh_eclass( e32_si class ) { - switch( class ) { - case ELF_CLASS_NONE: return( "None" ); break; - case ELF_CLASS_32: return( "EC32" ); break; - case ELF_CLASS_64: return( "EC64" ); break; - } - return( "????" ); -} - -// interpret the data encoding -static const char *fh_edata( e32_si data ) { - switch( data ) { - case ELF_DATA_NONE: return( "Invd" ); break; - case ELF_DATA_2LSB: return( "2CLE" ); break; - case ELF_DATA_2MSB: return( "2CBE" ); break; - } - return( "????" ); -} - -// interpret the file type -static const char *fh_htype( e32_h type ) { - switch( type ) { - case ET_NONE: return( "none" ); break; - case ET_REL: return( "rel" ); break; - case ET_EXEC: return( "exec" ); break; - case ET_DYN: return( "dyn" ); break; - case ET_CORE: return( "core" ); break; - default: - if( type >= ET_LO_OS && type <= ET_HI_OS ) - return( "OSsp" ); - else if( type >= ET_LO_CP && type <= ET_HI_CP ) - return( "CPsp" ); - } - sprint( ebuf, "0x%04x", type ); - return( (const char *) ebuf ); -} - -// interpret the machine type -static const char *fh_mtype( e32_h machine ) { - switch( machine ) { - case EM_NONE: return( "None" ); break; - case EM_386: return( "386" ); break; - case EM_ARM: return( "ARM" ); break; - case EM_X86_64: return( "AMD64" ); break; - case EM_AARCH64: return( "AARCH64" ); break; - case EM_RISCV: return( "RISC-V" ); break; - } - return( "Other" ); -} - -// dump the program header -static void dump_fhdr( elfhdr_t *hdr ) { - cio_puts( "File header: magic " ); - for( int i = EI_MAG0; i <= EI_MAG3; ++i ) - put_char_or_code( hdr->e_ident.bytes[i] ); - cio_printf( " class %s", fh_eclass(hdr->e_ident.f.class) ); - cio_printf( " enc %s", fh_edata(hdr->e_ident.f.data) ); - cio_printf( " ver %u\n", hdr->e_ident.f.version ); - cio_printf( " type %s", fh_htype(hdr->e_type) ); - cio_printf( " mach %s", fh_mtype(hdr->e_machine) ); - cio_printf( " vers %d", hdr->e_version ); - cio_printf( " entr %08x\n", hdr->e_entry ); - - cio_printf( " phoff %08x", hdr->e_phoff ); - cio_printf( " shoff %08x", hdr->e_shoff ); - cio_printf( " flags %08x", (uint32_t) hdr->e_flags ); - cio_printf( " ehsize %u\n", hdr->e_ehsize ); - cio_printf( " phentsize %u", hdr->e_phentsize ); - cio_printf( " phnum %u", hdr->e_phnum ); - cio_printf( " shentsize %u", hdr->e_shentsize ); - cio_printf( " shnum %u", hdr->e_shnum ); - cio_printf( " shstrndx %u\n", hdr->e_shstrndx ); -} - -/* -** Program header functions -*/ - -// categorize the header type -static const char *ph_type( e32_w type ) { - switch( type ) { - case PT_NULL: return( "Unused" ); break; - case PT_LOAD: return( "Load" ); break; - case PT_DYNAMIC: return( "DLI" ); break; - case PT_INTERP: return( "Interp" ); break; - case PT_NOTE: return( "Aux" ); break; - case PT_SHLIB: return( "RSVD" ); break; - case PT_PHDR: return( "PTentry" ); break; - case PT_TLS: return( "TLS" ); break; - default: - if( type >= PT_LO_OS && type <= PT_HI_OS ) - return( "OSsp" ); - else if( type >= PT_LO_CP && type <= PT_HI_CP ) - return( "CPsp" ); - } - sprint( ebuf, "0x%08x", type ); - return( (const char *) ebuf ); -} - -// report the individual flags -static void ph_flags( e32_w flags ) { - if( (flags & PF_R) != 0 ) cio_putchar( 'R' ); - if( (flags & PF_W) != 0 ) cio_putchar( 'W' ); - if( (flags & PF_E) != 0 ) cio_putchar( 'X' ); -} - -// dump a program header -static void dump_phdr( elfproghdr_t *hdr, int n ) { - cio_printf( "Prog header %d, type %s\n", n, ph_type(hdr->p_type) ); - cio_printf( " offset %08x", hdr->p_offset ); - cio_printf( " va %08x", hdr->p_va ); - cio_printf( " pa %08x\n", hdr->p_pa ); - cio_printf( " filesz %08x", hdr->p_filesz ); - cio_printf( " memsz %08x", hdr->p_memsz ); - cio_puts( " flags " ); - ph_flags( hdr->p_flags ); - cio_printf( " align %08x", hdr->p_align ); - cio_putchar( '\n' ); -} - -/* -** Section header functions -*/ - -// interpret the header type -static const char *sh_type( e32_w type ) { - switch( type ) { - case SHT_NULL: return( "Unused" ); break; - case SHT_PROGBITS: return( "Progbits" ); break; - case SHT_SYMTAB: return( "Symtab" ); break; - case SHT_STRTAB: return( "Strtab" ); break; - case SHT_RELA: return( "Rela" ); break; - case SHT_HASH: return( "Hash" ); break; - case SHT_DYNAMIC: return( "Dynamic" ); break; - case SHT_NOTE: return( "Note" ); break; - case SHT_NOBITS: return( "Nobits" ); break; - case SHT_REL: return( "Rel" ); break; - case SHT_SHLIB: return( "Shlib" ); break; - case SHT_DYNSYM: return( "Dynsym" ); break; - default: - if( type >= SHT_LO_CP && type <= SHT_HI_CP ) - return( "CCsp" ); - else if( type >= SHT_LO_US && type <= SHT_HI_US ) - return( "User" ); - } - sprint( ebuf, "0x%08x", type ); - return( (const char *) ebuf ); -} - -// report the various flags -static void sh_flags( unsigned int flags ) { - if( (flags & SHF_WRITE) != 0 ) cio_putchar( 'W' ); - if( (flags & SHF_ALLOC) != 0 ) cio_putchar( 'A' ); - if( (flags & SHF_EXECINSTR) != 0 ) cio_putchar( 'X' ); - if( (flags & SHF_MERGE) != 0 ) cio_putchar( 'M' ); - if( (flags & SHF_STRINGS) != 0 ) cio_putchar( 'S' ); - if( (flags & SHF_INFO_LINK) != 0 ) cio_putchar( 'L' ); - if( (flags & SHF_LINK_ORDER) != 0 ) cio_putchar( 'o' ); - if( (flags & SHF_OS_NONCON) != 0 ) cio_putchar( 'n' ); - if( (flags & SHF_GROUP) != 0 ) cio_putchar( 'g' ); - if( (flags & SHF_TLS) != 0 ) cio_putchar( 't' ); -} - -// dump a section header -ATTR_UNUSED -static void dump_shdr( elfsecthdr_t *hdr, int n ) { - cio_printf( "Sect header %d, type %d (%s), name %s\n", - n, hdr->sh_type, sh_type(hdr->sh_type) ); - cio_printf( " flags %08x ", (uint32_t) hdr->sh_flags ); - sh_flags( hdr->sh_flags ); - cio_printf( " addr %08x", hdr->sh_addr ); - cio_printf( " offset %08x", hdr->sh_offset ); - cio_printf( " size %08x\n", hdr->sh_size ); - cio_printf( " link %08x", hdr->sh_link ); - cio_printf( " info %08x", hdr->sh_info ); - cio_printf( " align %08x", hdr->sh_addralign ); - cio_printf( " entsz %08x\n", hdr->sh_entsize ); -} -#endif - -/** -** read_phdrs(addr,phoff,phentsize,phnum) -** -** Parses the ELF program headers and each segment described into memory. -** -** @param hdr Pointer to the program header -** @param pcb Pointer to the PCB (and its PDE) -** -** @return status of the attempt: -** SUCCESS everything loaded correctly -** E_LOAD_LIMIT more than N_LOADABLE PT_LOAD sections -** other status returned from vm_add() -*/ -static int read_phdrs( elfhdr_t *hdr, pcb_t *pcb ) { - - // sanity check - assert1( hdr != NULL ); - assert2( pcb != NULL ); - -#if TRACING_USER - cio_printf( "read_phdrs(%08x,%08x)\n", (uint32_t) hdr, (uint32_t) pcb ); -#endif - - // iterate through the program headers - uint_t nhdrs = hdr->e_phnum; - - // pointer to the first header table entry - elfproghdr_t *curr = (elfproghdr_t *) ((uint32_t) hdr + hdr->e_phoff); - - // process them all - int loaded = 0; - for( uint_t i = 0; i < nhdrs; ++i, ++curr ) { - -#if TRACING_ELF - dump_phdr( curr, i ); -#endif - if( curr->p_type != PT_LOAD ) { - // not loadable --> we'll skip it - continue; - } - - if( loaded >= N_LOADABLE ) { -#if TRACING_USER - cio_puts( " LIMIT\n" ); -#endif - return E_LOAD_LIMIT; - } - - // set a pointer to the bytes within the object file - char *data = (char *) (((uint32_t)hdr) + curr->p_offset); -#if TRACING_USER - cio_printf( " data @ %08x", (uint32_t) data ); -#endif - - // copy the pages into memory - int stat = vm_add( pcb->pdir, curr->p_flags & PF_W, false, - (char *) curr->p_va, curr->p_memsz, data, curr->p_filesz ); - if( stat != SUCCESS ) { - // TODO what else should we do here? check for memory leak? - return stat; - } - - // set the section table entry in the PCB - pcb->sects[loaded].length = curr->p_memsz; - pcb->sects[loaded].addr = curr->p_va; -#if TRACING_USER - cio_printf( " loaded %u @ %08x\n", - pcb->sects[loaded].length, pcb->sects[loaded].addr ); -#endif - ++loaded; - } - - return SUCCESS; -} - -/** -** Name: stack_setup -** -** Set up the stack for a new process -** -** @param pcb Pointer to the PCB for the process -** @param entry Entry point for the new process -** @param args Argument vector to be put in place -** -** @return A pointer to the context_t on the stack, or NULL -*/ -static context_t *stack_setup( pcb_t *pcb, uint32_t entry, const char **args ) { - - /* - ** First, we need to count the space we'll need for the argument - ** vector and strings. - */ - - int argbytes = 0; - int argc = 0; - - while( args[argc] != NULL ) { - int n = strlen( args[argc] ) + 1; - // can't go over one page in size - if( (argbytes + n) > SZ_PAGE ) { - // oops - ignore this and any others - break; - } - argbytes += n; - ++argc; - } - - // Round up the byte count to the next multiple of four. - argbytes = (argbytes + 3) & MOD4_MASK; - - /* - ** Allocate the arrays. We are safe using dynamic arrays here - ** because we're using the OS stack, not the user stack. - ** - ** We want the argstrings and argv arrays to contain all zeroes. - ** The C standard states, in section 6.7.8, that - ** - ** "21 If there are fewer initializers in a brace-enclosed list - ** than there are elements or members of an aggregate, or - ** fewer characters in a string literal used to initialize an - ** array of known size than there are elements in the array, - ** the remainder of the aggregate shall be initialized - ** implicitly the same as objects that have static storage - ** duration." - ** - ** Sadly, because we're using variable-sized arrays, we can't - ** rely on this, so we have to call memclr() instead. :-( In - ** truth, it doesn't really cost us much more time, but it's an - ** annoyance. - */ - - char argstrings[ argbytes ]; - char *argv[ argc + 1 ]; - - CLEAR( argstrings ); - CLEAR( argv ); - - // Next, duplicate the argument strings, and create pointers to - // each one in our argv. - char *tmp = argstrings; - for( int i = 0; i < argc; ++i ) { - int nb = strlen(args[i]) + 1; // bytes (incl. NUL) in this string - strcpy( tmp, args[i] ); // add to our buffer - argv[i] = tmp; // remember where it was - tmp += nb; // move on - } - - // trailing NULL pointer - argv[argc] = NULL; - - /* - ** The pages for the stack were cleared when they were allocated, - ** so we don't need to remember to do that. - ** - ** We reserve one longword at the bottom of the stack to hold a - ** pointer to where argv is on the stack. - ** - ** The user code was linked with a startup function that defines - ** the entry point (_start), calls main(), and then calls exit() - ** if main() returns. We need to set up the stack this way: - ** - ** esp -> context <- context save area - ** ... <- context save area - ** context <- context save area - ** entry_pt <- return address for the ISR - ** argc <- argument count for main() - ** /-> argv <- argv pointer for main() - ** | ... <- argv array w/trailing NULL - ** | ... <- argv character strings - ** \--- ptr <- last word in stack - ** - ** Stack alignment rules for the SysV ABI i386 supplement dictate that - ** the 'argc' parameter must be at an address that is a multiple of 16; - ** see below for more information. - */ - - // Pointer to the last word in stack. We get this from the - // VM hierarchy. Get the PDE entry for the user address space. - pde_t stack_pde = pcb->pdir[USER_PDE]; - - // The PDE entry points to the PT, which is an array of PTE. The last - // two entries are for the stack; pull out the last one. - pte_t stack_pte = ((pte_t *)(stack_pde & MOD4K_MASK))[USER_STK_PTE2]; - - // OK, now we have the PTE. The frame address of the last page is - // in this PTE. Find the address immediately after that. - uint32_t *ptr = (uint32_t *) - ((uint32_t)(stack_pte & MOD4K_MASK) + SZ_PAGE); - - // Pointer to where the arg strings should be filled in. - char *strings = (char *) ( (uint32_t) ptr - argbytes ); - - // back the pointer up to the nearest word boundary; because we're - // moving toward location 0, the nearest word boundary is just the - // next smaller address whose low-order two bits are zeroes - strings = (char *) ((uint32_t) strings & MOD4_MASK); - - // Copy over the argv strings. - memcpy( (void *)strings, argstrings, argbytes ); - - /* - ** Next, we need to copy over the argv pointers. Start by - ** determining where 'argc' should go. - ** - ** Stack alignment is controlled by the SysV ABI i386 supplement, - ** version 1.2 (June 23, 2016), which states in section 2.2.2: - ** - ** "The end of the input argument area shall be aligned on a 16 - ** (32 or 64, if __m256 or __m512 is passed on stack) byte boundary. - ** In other words, the value (%esp + 4) is always a multiple of 16 - ** (32 or 64) when control is transferred to the function entry - ** point. The stack pointer, %esp, always points to the end of the - ** latest allocated stack frame." - ** - ** Isn't technical documentation fun? Ultimately, this means that - ** the first parameter to main() should be on the stack at an address - ** that is a multiple of 16. - ** - ** The space needed for argc, argv, and the argv array itself is - ** argc + 3 words (argc+1 for the argv entries, plus one word each - ** for argc and argv). We back up that much from 'strings'. - */ - - int nwords = argc + 3; - uint32_t *acptr = ((uint32_t *) strings) - nwords; - - /* - ** Next, back up until we're at a multiple-of-16 address. Because we - ** are moving to a lower address, its upper 28 bits are identical to - ** the address we currently have, so we can do this with a bitwise - ** AND to just turn off the lower four bits. - */ - - acptr = (uint32_t *) ( ((uint32_t)acptr) & MOD16_MASK ); - - // copy in 'argc' - *acptr = argc; - - // next, 'argv', which follows 'argc'; 'argv' points to the - // word that follows it in the stack - uint32_t *avptr = acptr + 2; - *(acptr+1) = (uint32_t) avptr; - - /* - ** Next, we copy in all argc+1 pointers. - */ - - // Adjust and copy the string pointers. - for( int i = 0; i <= argc; ++i ) { - if( argv[i] != NULL ) { - // an actual pointer - adjust it and copy it in - *avptr = (uint32_t) strings; - // skip to the next entry in the array - strings += strlen(argv[i]) + 1; - } else { - // end of the line! - *avptr = NULL; - } - ++avptr; - } - - /* - ** Now, we need to set up the initial context for the executing - ** process. - ** - ** When this process is dispatched, the context restore code will - ** pop all the saved context information off the stack, including - ** the saved EIP, CS, and EFLAGS. We set those fields up so that - ** the interrupt "returns" to the entry point of the process. - */ - - // Locate the context save area on the stack. - context_t *ctx = ((context_t *) avptr) - 1; - - /* - ** We cleared the entire stack earlier, so all the context - ** fields currently contain zeroes. We now need to fill in - ** all the important fields. - */ - - ctx->eflags = DEFAULT_EFLAGS; // IE enabled, PPL 0 - ctx->eip = entry; // initial EIP - ctx->cs = GDT_CODE; // segment registers - ctx->ss = GDT_STACK; - ctx->ds = ctx->es = ctx->fs = ctx->gs = GDT_DATA; - - /* - ** Return the new context pointer to the caller. It will be our - ** caller's responsibility to schedule this process. - */ - - return( ctx ); -} - -/* -** PUBLIC FUNCTIONS -*/ - -/** -** Name: user_init -** -** Initializes the user support module. -*/ -void user_init( void ) { - -#if TRACING_INIT - cio_puts( " User" ); -#endif - - // This is gross, but we need to get this information somehow. - // Access the "user blob" data in the second bootstrap sector - uint16_t *blobdata = (uint16_t *) USER_BLOB_DATA; - user_offset = *blobdata++; - user_segment = *blobdata++; - user_sectors = *blobdata++; - -#if TRACING_USER - cio_printf( "\nUser blob: %u sectors @ %04x:%04x", user_sectors, - user_segment, user_offset ); -#endif - - // calculate the location of the user blob - if( user_sectors > 0 ) { - - // calculate the address of the header - user_header = (header_t *) - ( KERN_BASE + - ( (((uint_t)user_segment) << 4) + ((uint_t)user_offset) ) - ); - - // the program table immediate follows the blob header - prog_table = (prog_t *) (user_header + 1); - -#if TRACING_USER - cio_printf( ", hdr %08x, %u progs, tbl %08x\n", (uint32_t) user_header, - user_header->num, (uint32_t) prog_table ); -#endif - - } else { - // too bad, so sad! - user_header = NULL; - prog_table = NULL; -#if TRACING_USER - cio_putchar( '\n' ); -#endif - } -} - -/** -** Name: user_locate -** -** Locates a user program in the user code archive. -** -** @param what The ID of the user program to find -** -** @return pointer to the program table entry in the code archive, or NULL -*/ -prog_t *user_locate( uint_t what ) { - - // no programs if there is no blob! - if( user_header == NULL ) { - return NULL; - } - - // make sure this is a reasonable program to request - if( what >= user_header->num ) { - // no such program! - return NULL; - } - - // find the entry in the program table - prog_t *prog = &prog_table[what]; - - // if there are no bytes, it's useless - if( prog->size < 1 ) { - return NULL; - } - - // return the program table pointer - return prog; -} - -/** -** Name: user_duplicate -** -** Duplicates the memory setup for an existing process. -** -** @param new The PCB for the new copy of the program -** @param old The PCB for the existing the program -** -** @return the status of the duplicate attempt -*/ -int user_duplicate( pcb_t *new, pcb_t *old ) { - - // We need to do a recursive duplication of the process address - // space of the current process. First, we create a new user - // page directory. Next, we'll duplicate the USER_PDE page - // table. Finally, we'll go through that table and duplicate - // all the frames. - - // create the initial VM hierarchy - pde_t *pdir = vm_mkuvm(); - if( pdir == NULL ) { - return E_NO_MEMORY; - } - new->pdir = pdir; - - // Next, add a USER_PDE page table that's a duplicate of the - // current process' page table - if( !vm_uvmdup(old->pdir,new->pdir) ) { - // check for memory leak? - return E_NO_MEMORY; - } - - // We don't do copy-on-write, so we must duplicate all the - // individual page frames. Iterate through all the user-level - // PDE entries, and replace the existing frames with duplicates. - // - // NOTE: we only deal with pdir[0] here, as we are limiting - // the user address space to the first 4MB. If the size of - // the address space goes up, this code will need to be - // modified to loop over the larger space. - - // pointer to the PMT for the user - pte_t *pt = (pte_t *) (pdir[USER_PDE]); - assert( pt != NULL ); - - for( int i = 0; i < N_PTE; ++i ) { - // get the current entry from the PMT - pte_t entry = *pt; - - // if this entry is present, - if( IS_PRESENT(entry) ) { - - // duplicate the frame pointed to by this PTE - void *tmp = vm_pagedup( (void *) PTE_ADDR(entry) ); - - // replace the old frame number with the new one - *pt = (pte_t) (((uint32_t)tmp) | PERMS(entry) ); - - } else { - - *pt = 0; - - } - ++pt; - } - - return SUCCESS; -} - -/** -** Name: user_load -** -** Loads a user program from the user code archive into memory. -** Allocates all needed frames and sets up the VM tables. -** -** @param ptab A pointer to the program table entry to be loaded -** @param pcb The PCB for the program being loaded -** @param args The argument vector for the program -** -** @return the status of the load attempt -*/ -int user_load( prog_t *ptab, pcb_t *pcb, const char **args ) { - - // NULL pointers are bad! - assert1( ptab != NULL ); - assert1( pcb != NULL ); - assert1( args != NULL ); - - // locate the ELF binary - elfhdr_t *hdr = (elfhdr_t *) ((uint32_t)user_header + ptab->offset); - -#if TRACING_ELF - cio_printf( "Load: ptab %08x: '%s', off %08x, size %08x, flags %08x\n", - (uint32_t) ptab, ptab->name, ptab->offset, ptab->size, - ptab->flags ); - cio_printf( " args %08x:", (uint32_t) args ); - for( int i = 0; args[i] != NULL; ++i ) { - cio_printf( " [%d] %s", i, args[i] ); - } - cio_printf( "\n pcb %08x (pid %u)\n", (uint32_t) pcb, pcb->pid ); - dump_fhdr( hdr ); -#endif - - // verify the ELF header - if( hdr->e_ident.f.magic != ELF_MAGIC ) { - return E_BAD_PARAM; - } - - // allocate a page directory - pcb->pdir = vm_mkuvm(); - if( pcb->pdir == NULL ) { - return E_NO_MEMORY; - } - - // read all the program headers - int stat = read_phdrs( hdr, pcb ); - if( stat != SUCCESS ) { - // TODO figure out a better way to deal with this - PANIC( 0, "user_load: phdr read failed" ); - } - - // next, set up the runtime stack - just like setting up loadable - // sections, except nothing to copy - stat = vm_add( pcb->pdir, true, false, (void *) USER_STACK, - SZ_USTACK, NULL, 0 ); - if( stat != SUCCESS ) { - // TODO yadda yadda... - PANIC( 0, "user_load: vm_add failed" ); - } - - // set up the command-line arguments - pcb->context = stack_setup( pcb, hdr->e_entry, args ); - - return SUCCESS; -} - -/** -** Name: user_cleanup -** -** "Unloads" a user program. Deallocates all memory frames and -** cleans up the VM structures. -** -** @param pcb The PCB of the program to be unloaded -*/ -void user_cleanup( pcb_t *pcb ) { - - if( pcb == NULL ) { - // should this be an error? - return; - } - - vm_free( pcb->pdir ); - pcb->pdir = NULL; -} diff --git a/kernel/old/vm.c b/kernel/old/vm.c deleted file mode 100644 index 749bed3..0000000 --- a/kernel/old/vm.c +++ /dev/null @@ -1,625 +0,0 @@ -/** -** @file vm.c -** -** @author CSCI-452 class of 20245 -** -** @brief Kernel VM support -*/ - -#define KERNEL_SRC - -#include <common.h> - -#include <vm.h> -#include <vmtables.h> - -#include <kmem.h> -#include <procs.h> -#include <x86/arch.h> -#include <x86/ops.h> - -/* -** PUBLIC GLOBAL VARIABLES -*/ - -// created page directory for the kernel -pde_t *kpdir; - -/* -** PRIVATE FUNCTIONS -*/ - -/** -** Name: vm_isr -** -** Description: Page fault handler -** -** @param vector Interrupt vector number -** @param code Error code pushed onto the stack -*/ -static void vm_isr( int vector, int code ) { - - // get whatever information we can from the fault - pfec_t fault; - fault.u = (uint32_t) code; - uint32_t addr = r_cr2(); - - // report what we found - sprint( b256, - "** page fault @ 0x%08x %cP %c %cM %cRSV %c %cPK %cSS %cHLAT %cSGZ", - addr, - fault.s.p ? ' ' : '!', - fault.s.w ? 'W' : 'R', - fault.s.us ? 'U' : 'S', - fault.s.rsvd ? ' ' : '!', - fault.s.id ? 'I' : 'D', - fault.s.pk ? ' ' : '!', - fault.s.ss ? ' ' : '!', - fault.s.hlat ? ' ' : '!', - fault.s.sgz ? ' ' : '!' - ); - - // and give up - PANIC( 0, b256 ); -} - -/** -** Name: uva2kva -** -** Convert a user VA into a kernel address. Works for all addresses - -** if the address is a page address, the PERMS(va) value will be 0; -** otherwise, it is the offset into the page. -** -** @param pdir Pointer to the page directory to examine -** @param va Virtual address to check -*/ -ATTR_UNUSED -static void *uva2kva( pde_t *pdir, void *va ) { - - // find the PMT entry for this address - pte_t *pte = vm_getpte( pdir, va, false ); - if( pte == NULL ) { - return NULL; - } - - // get the entry - pte_t entry = *pte; - - // is this a valid address for the user? - if( IS_PRESENT(entry) ) { - return NULL; - } - - // is this a system-only page? - if( IS_SYSTEM(entry) ) { - return NULL; - } - - // get the physical address - uint32_t frame = PTE_ADDR(*pte) | PERMS(va); - - return (void *) P2V(frame); -} - - -/* -** PUBLIC FUNCTIONS -*/ - -/** -** Name: vm_init -** -** Description: Initialize the VM module -*/ -void vm_init( void ) { - -#if TRACING_INIT - cio_puts( " VM" ); -#endif - - // set up the kernel's 4K-page directory - kpdir = vm_mkkvm(); - assert( kpdir != NULL ); - - // switch to it - vm_set_kvm(); - - // install the page fault handler - install_isr( VEC_PAGE_FAULT, vm_isr ); -} - -/** -** Name: vm_pagedup -** -** Duplicate a page of memory -** -** @param old Pointer to the first byte of a page -** -** @return a pointer to the new, duplicate page, or NULL -*/ -void *vm_pagedup( void *old ) { - void *new = (void *) km_page_alloc(); - if( new != NULL ) { - blkmov( new, old, SZ_PAGE ); - } - return new; -} - -/** -** Name: vm_pdedup -** -** Duplicate a page directory entry -** -** @param dst Pointer to where the duplicate should go -** @param curr Pointer to the entry to be duplicated -** -** @return true on success, else false -*/ -bool_t vm_pdedup( pde_t *dst, pde_t *curr ) { - - assert1( curr != NULL ); - assert1( dst != NULL ); - -#if TRACING_VM - cio_printf( "vm_pdedup dst %08x curr %08x\n", - (uint32_t) dst, (uint32_t) curr ); -#endif - pde_t entry = *curr; - - // simplest case - if( !IS_PRESENT(entry) ) { - *dst = 0; - return true; - } - - // OK, we have an entry; allocate a page table for it - pte_t *newtbl = (pte_t *) km_page_alloc(); - if( newtbl == NULL ) { - return false; - } - - // we could clear the new table, but we'll be assigning to - // each entry anyway, so we'll save the execution time - - // address of the page table for this directory entry - pte_t *old = (pte_t *) PDE_ADDR(entry); - - // pointer to the first PTE in the new table - pte_t *new = newtbl; - - for( int i = 0 ; i < N_PTE; ++i ) { - if( !IS_PRESENT(*old) ) { - *new = 0; - } else { - *new = *old; - } - ++old; - ++new; - } - - // replace the page table address - // upper 22 bits from 'newtbl', lower 12 from '*curr' - *dst = (pde_t) ( PTE_ADDR(newtbl) | PERMS(entry) ); - - return true; -} - -/** -** Name: vm_getpte -** -** Return the address of the PTE corresponding to the virtual address -** 'va' within the address space controlled by 'pgdir'. If there is no -** page table for that VA and 'alloc' is true, create the necessary -** page table entries. -** -** @param pdir Pointer to the page directory to be searched -** @param va The virtual address we're looking for -** @param alloc Should we allocate a page table if there isn't one? -** -** @return A pointer to the page table entry for this VA, or NULL if -** there isn't one and we're not allocating -*/ -pte_t *vm_getpte( pde_t *pdir, const void *va, bool_t alloc ) { - pte_t *ptab; - - // sanity check - assert1( pdir != NULL ); - - // get the PDIR entry for this virtual address - pde_t *pde = &pdir[ PDIX(va) ]; - - // is it already set up? - if( IS_PRESENT(*pde) ) { - - // yes! - ptab = (pte_t*)P2V(PTE_ADDR(*pde)); - - } else { - - // no - should we create it? - if( !alloc ) { - // nope, so just return - return NULL; - } - - // yes - try to allocate a page table - ptab = (pte_t *) km_page_alloc(); - if( ptab == NULL ) { - WARNING( "can't allocate page table" ); - return NULL; - } - - // who knows what was left in this page.... - memclr( ptab, SZ_PAGE ); - - // add this to the page directory - // - // we set this up to allow general access; this could be - // controlled by setting access control in the page table - // entries, if necessary. - // - // NOTE: the allocator is serving us virtual page addresses, - // so we must convert them to physical addresses - *pde = ((uint32_t) V2P(ptab)) | PDE_P | PDE_RW; - } - - // finally, return a pointer to the entry in the - // page table for this VA - return &ptab[ PTIX(va) ]; -} - -// Set up kernel part of a page table. -pde_t *vm_mkkvm( void ) -{ - mapping_t *k; - - // allocate the page directory - pde_t *pdir = km_page_alloc(); - if( pdir == NULL ) { - return NULL; - } - - // clear it out to disable all the entries - memclr( pdir, SZ_PAGE ); - - if( P2V(PHYS_TOP) > DEV_BASE ) { - cio_printf( "PHYS_TOP (%08x -> %08x) > DEV_BASE(%08x)\n", - PHYS_TOP, P2V(PHYS_TOP), DEV_BASE ); - PANIC( 0, "PHYS_TOP too large" ); - } - - // map in all the page ranges - k = kmap; - for( int i = 0; i < n_kmap; ++i, ++k ) { - int stat = vm_map( pdir, ((void *)k->va_start), - k->pa_end - k->pa_start, - k->pa_start, k->perm ); - if( stat != SUCCESS ) { - vm_free( pdir ); - return 0; - } - } - - return pdir; -} - -/* -** Creates an initial user VM table hierarchy by copying the -** system entries into a new page directory. -** -** @return a pointer to the new page directory, or NULL -*/ -pde_t *vm_mkuvm( void ) { - - // allocate the directory - pde_t *new = (pde_t *) km_page_alloc(); - if( new == NULL ) { - return NULL; - } - - // iterate through the kernel page directory - pde_t *curr = kpdir; - pde_t *dst = new; - for( int i = 0; i < N_PDE; ++i ) { - - if( *curr != 0 ) { - // found an active one - duplicate it - if( !vm_pdedup(dst,curr) ) { - return NULL; - } - } - - ++curr; - ++dst; - } - - return new; - -} - -/** -** Name: vm_set_kvm -** -** Switch the page table register to the kernel's page directory. -*/ -void vm_set_kvm( void ) { - w_cr3( V2P(kpdir) ); // switch to the kernel page table -} - -/** -** Name: vm_set_uvm -** -** Switch the page table register to the page directory for a user process. -** -** @param p PCB of the process we're switching to -*/ -void vm_set_uvm( pcb_t *p ) { - assert( p != NULL ); - assert( p->pdir != NULL ); - - w_cr3( V2P(p->pdir) ); // switch to process's address space -} - -/** -** Name: vm_add -** -** Add pages to the page hierarchy for a process, copying data into -** them if necessary. -** -** @param pdir Pointer to the page directory to modify -** @param wr "Writable" flag for the PTE -** @param sys "System" flag for the PTE -** @param va Starting VA of the range -** @param size Amount of physical memory to allocate (bytes) -** @param data Pointer to data to copy, or NULL -** @param bytes Number of bytes to copy -** -** @return status of the allocation attempt -*/ -int vm_add( pde_t *pdir, bool_t wr, bool_t sys, - void *va, uint32_t size, char *data, uint32_t bytes ) { - - // how many pages do we need? - uint_t npages = ((size & MOD4K_BITS) ? PGUP(size) : size) >> MOD4K_SHIFT; - - // permission set for the PTEs - uint_t entrybase = PTE_P; - if( wr ) { - entrybase |= PTE_RW; - } - if( sys ) { - entrybase |= PTE_US; - } - -#if TRACING_VM - cio_printf( "vm_add: pdir %08x, %s, va %08x (%u, %u pgs)\n", - (uint32_t) pdir, wr ? "W" : "!W", (uint32_t) va, size ); - cio_printf( " from %08x, %u bytes, perms %08x\n", - (uint32_t) data, bytes, entrybase ); -#endif - - // iterate through the pages - - for( int i = 0; i < npages; ++i ) { - - // figure out where this page will go in the hierarchy - pte_t *pte = vm_getpte( pdir, va, true ); - if( pte == NULL ) { - // TODO if i > 0, this isn't the first frame - is - // there anything to do about other frames? - // POSSIBLE MEMORY LEAK? - return E_NO_MEMORY; - } - - // allocate the frame - void *page = km_page_alloc(); - if( page == NULL ) { - // TODO same question here - return E_NO_MEMORY; - } - - // clear it all out - memclr( page, SZ_PAGE ); - - // create the PTE for this frame - uint32_t entry = (uint32_t) (PTE_ADDR(page) | entrybase); - *pte = entry; - - // copy data if we need to - if( data != NULL && bytes > 0 ) { - // how much to copy - uint_t num = bytes > SZ_PAGE ? SZ_PAGE : bytes; - // do it! - memcpy( (void *)page, (void *)data, num ); - // adjust all the pointers - data += num; // where to continue - bytes -= num; // what's left to copy - } - - // bump the virtual address - va += SZ_PAGE; - } - - return SUCCESS; - -} - -/** -** Name: vm_free -** -** Deallocate a page table hierarchy and all physical memory frames -** in the user portion. -** -** Works only for 4KB pages. -** -** @param pdir Pointer to the page directory -*/ -void vm_free( pde_t *pdir ) { - - // do we have anything to do? - if( pdir == NULL ) { - return; - } - - // iterate through the page directory entries, freeing the - // PMTS and the frames they point to - pde_t *curr = pdir; - for( int i = 0; i < N_PDE; ++i ) { - - // the entry itself - pde_t entry = *curr; - - // does this entry point to anything useful? - if( IS_PRESENT(entry) ) { - - // yes - large pages make us unhappy - assert( !IS_LARGE(entry) ); - - // get the PMT pointer - pte_t *pmt = (pte_t *) PTE_ADDR(entry); - - // walk the PMT - for( int j = 0; j < N_PTE; ++j ) { - // does this entry point to a frame? - if( IS_PRESENT(*pmt) ) { - // yes - free the frame - km_page_free( (void *) PTE_ADDR(*pmt) ); - // mark it so we don't get surprised - *pmt = 0; - } - // move on - ++pmt; - } - // now, free the PMT itself - km_page_free( (void *) PDE_ADDR(entry) ); - *curr = 0; - } - - // move to the next entry - ++curr; - } - - // finally, free the PDIR itself - km_page_free( (void *) pdir ); -} - -/* -** Name: vm_map -** -** Create PTEs for virtual addresses starting at 'va' that refer to -** physical addresses in the range [pa, pa+size-1]. We aren't guaranteed -** that va is page-aligned. -** -** @param pdir Page directory for this address space -** @param va The starting virtual address -** @param size Length of the range to be mapped -** @param pa The starting physical address -** @param perm Permission bits for the PTEs -** -** @return the status of the mapping attempt -*/ -int vm_map( pde_t *pdir, void *va, uint_t size, uint_t pa, int perm ) { - - // round the VA down to its page boundary - char *addr = (char*)PGDOWN((uint_t)va); - - // round the end of the range down to its page boundary - char *last = (char*)PGDOWN(((uint_t)va) + size - 1); - - while( addr < last ) { - - // get a pointer to the PTE for the current VA - pte_t *pte = vm_getpte( pdir, addr, true ); - if( pte == NULL ) { - // couldn't find it - return E_NO_PTE; - } - - // if this entry has already been mapped, we're in trouble - if( IS_PRESENT(*pte) ) { - cio_printf( "vm_map(%08x,%08x,%u,%08x,%03x)\n", - (uint32_t) pdir, (uint32_t) va, size, pa, perm ); - cio_printf( " addr %08x last %08x pte %08x *pte %08x\n", - (uint32_t) addr, (uint32_t) last, - (uint32_t) pte, *pte ); - - PANIC( 0, "mapping an already-mapped address" ); - } - - // ok, set the PTE as requested - *pte = pa | perm | PTE_P; - - // nope - move to the next page - addr += SZ_PAGE; - pa += SZ_PAGE; - - } - return SUCCESS; -} - -/** -** Name: vm_uvmdup -** -** Create a duplicate of the user portio of an existing page table -** hierarchy. We assume that the "new" page directory exists and -** the system portions of it should not be touched. -** -** Note: we do not duplicate the frames in the hierarchy - we just -** create a duplicate of the hierarchy itself. This means that we -** now have two sets of page tables that refer to the same physical -** frames in memory. -** -** @param old Existing page directory -** @param new New page directory -** -** @return status of the duplication attempt -*/ -int vm_uvmdup( pde_t *old, pde_t *new ) { - - if( old == NULL || new == NULL ) { - return E_BAD_PARAM; - } - - // we only want to deal with the "user" half of the address space - for( int i = 0; i < (N_PDE >> 1); ++i ) { - - // the entry to copy - pde_t entry = *old; - - // is this entry in use? - if( IS_PRESENT(entry) ) { - - // yes. if it points to a 4MB page, we just copy it; - // otherwise, we must duplicate the next level PMT - - if( !IS_LARGE(entry) ) { - - // it's a 4KB page, so we need to duplicate the PMT - pte_t *newpt = (pte_t *) vm_pagedup( (void *)PTE_ADDR(entry) ); - if( newpt == NULL ) { - return E_NO_MEMORY; - } - - uint32_t perms = PERMS(entry); - - // create the new PDE entry by replacing the frame # - entry = ((uint32_t) newpt) | perms; - } - - } else { - - // not present, so create an empty entry - entry = 0; - - } - - // send it on its way - *new = entry; - - // move on down the line - ++old; - ++new; - } - - return SUCCESS; -} diff --git a/kernel/old/vmtables.c b/kernel/old/vmtables.c deleted file mode 100644 index a50315d..0000000 --- a/kernel/old/vmtables.c +++ /dev/null @@ -1,338 +0,0 @@ -/** -** @file vmtables.c -** -** @author CSCI-452 class of 20245 -** -** @brief Kernel VM tables -** -** Compilation options: -** -** MAKE_IDENTITY_MAP Creates a page table that identity-maps the first -** 4MB of main memory. -*/ - -#define KERNEL_SRC - -#include <common.h> - -#include <kmem.h> -#include <procs.h> -#include <vm.h> -#include <x86/arch.h> - -// defined for us by the linker -extern char _data[]; - -/* -** Initial page directory, for when the kernel is starting up -** -** we use large (4MB) pages here to allow us to use a one-level -** paging hierarchy; the kernel will create a new page table -** hierarchy once memory is initialized -** -** We only map the first 2GB of memory, plus a 4MB portion of -** the upper half, which we map to cover the first 4MB of -** memory. -*/ - -// identity-map 4MB virtual address #n to physical 4MB address #n -// used for addresses 0 to 2GB -#define L(n) [n] = (pde_t) ( (TO_4MFRAME((n))) | (PDE_P|PDE_RW|PDE_PS) ) - -// ditto, but adds 512 (0x200) to the index -// used for addresses 2GB to 4GB -#define M(n) [n|0x200] = (pde_t) ( (TO_4MFRAME((n))) | (PDE_P|PDE_RW|PDE_PS) ) - -ATTR_ALIGNED(SZ_PAGE) -const pde_t firstpdir[N_PDE] = { - - // Map VA range [0, 2GB] to PA range [0, 2GB] -L(0x000), L(0x001), L(0x002), L(0x003), L(0x004), L(0x005), L(0x006), L(0x007), -L(0x008), L(0x009), L(0x00a), L(0x00b), L(0x00c), L(0x00d), L(0x00e), L(0x00f), -L(0x010), L(0x011), L(0x012), L(0x013), L(0x014), L(0x015), L(0x016), L(0x017), -L(0x018), L(0x019), L(0x01a), L(0x01b), L(0x01c), L(0x01d), L(0x01e), L(0x01f), -L(0x020), L(0x021), L(0x022), L(0x023), L(0x024), L(0x025), L(0x026), L(0x027), -L(0x028), L(0x029), L(0x02a), L(0x02b), L(0x02c), L(0x02d), L(0x02e), L(0x02f), -L(0x030), L(0x031), L(0x032), L(0x033), L(0x034), L(0x035), L(0x036), L(0x037), -L(0x038), L(0x039), L(0x03a), L(0x03b), L(0x03c), L(0x03d), L(0x03e), L(0x03f), -L(0x040), L(0x041), L(0x042), L(0x043), L(0x044), L(0x045), L(0x046), L(0x047), -L(0x048), L(0x049), L(0x04a), L(0x04b), L(0x04c), L(0x04d), L(0x04e), L(0x04f), -L(0x050), L(0x051), L(0x052), L(0x053), L(0x054), L(0x055), L(0x056), L(0x057), -L(0x058), L(0x059), L(0x05a), L(0x05b), L(0x05c), L(0x05d), L(0x05e), L(0x05f), -L(0x060), L(0x061), L(0x062), L(0x063), L(0x064), L(0x065), L(0x066), L(0x067), -L(0x068), L(0x069), L(0x06a), L(0x06b), L(0x06c), L(0x06d), L(0x06e), L(0x06f), -L(0x070), L(0x071), L(0x072), L(0x073), L(0x074), L(0x075), L(0x076), L(0x077), -L(0x078), L(0x079), L(0x07a), L(0x07b), L(0x07c), L(0x07d), L(0x07e), L(0x07f), -L(0x080), L(0x081), L(0x082), L(0x083), L(0x084), L(0x085), L(0x086), L(0x087), -L(0x088), L(0x089), L(0x08a), L(0x08b), L(0x08c), L(0x08d), L(0x08e), L(0x08f), -L(0x090), L(0x091), L(0x092), L(0x093), L(0x094), L(0x095), L(0x096), L(0x097), -L(0x098), L(0x099), L(0x09a), L(0x09b), L(0x09c), L(0x09d), L(0x09e), L(0x09f), -L(0x0a0), L(0x0a1), L(0x0a2), L(0x0a3), L(0x0a4), L(0x0a5), L(0x0a6), L(0x0a7), -L(0x0a8), L(0x0a9), L(0x0aa), L(0x0ab), L(0x0ac), L(0x0ad), L(0x0ae), L(0x0af), -L(0x0b0), L(0x0b1), L(0x0b2), L(0x0b3), L(0x0b4), L(0x0b5), L(0x0b6), L(0x0b7), -L(0x0b8), L(0x0b9), L(0x0ba), L(0x0bb), L(0x0bc), L(0x0bd), L(0x0be), L(0x0bf), -L(0x0c0), L(0x0c1), L(0x0c2), L(0x0c3), L(0x0c4), L(0x0c5), L(0x0c6), L(0x0c7), -L(0x0c8), L(0x0c9), L(0x0ca), L(0x0cb), L(0x0cc), L(0x0cd), L(0x0ce), L(0x0cf), -L(0x0d0), L(0x0d1), L(0x0d2), L(0x0d3), L(0x0d4), L(0x0d5), L(0x0d6), L(0x0d7), -L(0x0d8), L(0x0d9), L(0x0da), L(0x0db), L(0x0dc), L(0x0dd), L(0x0de), L(0x0df), -L(0x0e0), L(0x0e1), L(0x0e2), L(0x0e3), L(0x0e4), L(0x0e5), L(0x0e6), L(0x0e7), -L(0x0e8), L(0x0e9), L(0x0ea), L(0x0eb), L(0x0ec), L(0x0ed), L(0x0ee), L(0x0ef), -L(0x0f0), L(0x0f1), L(0x0f2), L(0x0f3), L(0x0f4), L(0x0f5), L(0x0f6), L(0x0f7), -L(0x0f8), L(0x0f9), L(0x0fa), L(0x0fb), L(0x0fc), L(0x0fd), L(0x0fe), L(0x0ff), -L(0x100), L(0x101), L(0x102), L(0x103), L(0x104), L(0x105), L(0x106), L(0x107), -L(0x108), L(0x109), L(0x10a), L(0x10b), L(0x10c), L(0x10d), L(0x10e), L(0x10f), -L(0x110), L(0x111), L(0x112), L(0x113), L(0x114), L(0x115), L(0x116), L(0x117), -L(0x118), L(0x119), L(0x11a), L(0x11b), L(0x11c), L(0x11d), L(0x11e), L(0x11f), -L(0x120), L(0x121), L(0x122), L(0x123), L(0x124), L(0x125), L(0x126), L(0x127), -L(0x128), L(0x129), L(0x12a), L(0x12b), L(0x12c), L(0x12d), L(0x12e), L(0x12f), -L(0x130), L(0x131), L(0x132), L(0x133), L(0x134), L(0x135), L(0x136), L(0x137), -L(0x138), L(0x139), L(0x13a), L(0x13b), L(0x13c), L(0x13d), L(0x13e), L(0x13f), -L(0x140), L(0x141), L(0x142), L(0x143), L(0x144), L(0x145), L(0x146), L(0x147), -L(0x148), L(0x149), L(0x14a), L(0x14b), L(0x14c), L(0x14d), L(0x14e), L(0x14f), -L(0x150), L(0x151), L(0x152), L(0x153), L(0x154), L(0x155), L(0x156), L(0x157), -L(0x158), L(0x159), L(0x15a), L(0x15b), L(0x15c), L(0x15d), L(0x15e), L(0x15f), -L(0x160), L(0x161), L(0x162), L(0x163), L(0x164), L(0x165), L(0x166), L(0x167), -L(0x168), L(0x169), L(0x16a), L(0x16b), L(0x16c), L(0x16d), L(0x16e), L(0x16f), -L(0x170), L(0x171), L(0x172), L(0x173), L(0x174), L(0x175), L(0x176), L(0x177), -L(0x178), L(0x179), L(0x17a), L(0x17b), L(0x17c), L(0x17d), L(0x17e), L(0x17f), -L(0x180), L(0x181), L(0x182), L(0x183), L(0x184), L(0x185), L(0x186), L(0x187), -L(0x188), L(0x189), L(0x18a), L(0x18b), L(0x18c), L(0x18d), L(0x18e), L(0x18f), -L(0x190), L(0x191), L(0x192), L(0x193), L(0x194), L(0x195), L(0x196), L(0x197), -L(0x198), L(0x199), L(0x19a), L(0x19b), L(0x19c), L(0x19d), L(0x19e), L(0x19f), -L(0x1a0), L(0x1a1), L(0x1a2), L(0x1a3), L(0x1a4), L(0x1a5), L(0x1a6), L(0x1a7), -L(0x1a8), L(0x1a9), L(0x1aa), L(0x1ab), L(0x1ac), L(0x1ad), L(0x1ae), L(0x1af), -L(0x1b0), L(0x1b1), L(0x1b2), L(0x1b3), L(0x1b4), L(0x1b5), L(0x1b6), L(0x1b7), -L(0x1b8), L(0x1b9), L(0x1ba), L(0x1bb), L(0x1bc), L(0x1bd), L(0x1be), L(0x1bf), -L(0x1c0), L(0x1c1), L(0x1c2), L(0x1c3), L(0x1c4), L(0x1c5), L(0x1c6), L(0x1c7), -L(0x1c8), L(0x1c9), L(0x1ca), L(0x1cb), L(0x1cc), L(0x1cd), L(0x1ce), L(0x1cf), -L(0x1d0), L(0x1d1), L(0x1d2), L(0x1d3), L(0x1d4), L(0x1d5), L(0x1d6), L(0x1d7), -L(0x1d8), L(0x1d9), L(0x1da), L(0x1db), L(0x1dc), L(0x1dd), L(0x1de), L(0x1df), -L(0x1e0), L(0x1e1), L(0x1e2), L(0x1e3), L(0x1e4), L(0x1e5), L(0x1e6), L(0x1e7), -L(0x1e8), L(0x1e9), L(0x1ea), L(0x1eb), L(0x1ec), L(0x1ed), L(0x1ee), L(0x1ef), -L(0x1f0), L(0x1f1), L(0x1f2), L(0x1f3), L(0x1f4), L(0x1f5), L(0x1f6), L(0x1f7), -L(0x1f8), L(0x1f9), L(0x1fa), L(0x1fb), L(0x1fc), L(0x1fd), L(0x1fe), L(0x1ff), - - // Map VA range [2GB, 4GB] to PA range [0, 2MB] -M(0x000), M(0x001), M(0x002), M(0x003), M(0x004), M(0x005), M(0x006), M(0x007), -M(0x008), M(0x009), M(0x00a), M(0x00b), M(0x00c), M(0x00d), M(0x00e), M(0x00f), -M(0x010), M(0x011), M(0x012), M(0x013), M(0x014), M(0x015), M(0x016), M(0x017), -M(0x018), M(0x019), M(0x01a), M(0x01b), M(0x01c), M(0x01d), M(0x01e), M(0x01f), -M(0x020), M(0x021), M(0x022), M(0x023), M(0x024), M(0x025), M(0x026), M(0x027), -M(0x028), M(0x029), M(0x02a), M(0x02b), M(0x02c), M(0x02d), M(0x02e), M(0x02f), -M(0x030), M(0x031), M(0x032), M(0x033), M(0x034), M(0x035), M(0x036), M(0x037), -M(0x038), M(0x039), M(0x03a), M(0x03b), M(0x03c), M(0x03d), M(0x03e), M(0x03f), -M(0x040), M(0x041), M(0x042), M(0x043), M(0x044), M(0x045), M(0x046), M(0x047), -M(0x048), M(0x049), M(0x04a), M(0x04b), M(0x04c), M(0x04d), M(0x04e), M(0x04f), -M(0x050), M(0x051), M(0x052), M(0x053), M(0x054), M(0x055), M(0x056), M(0x057), -M(0x058), M(0x059), M(0x05a), M(0x05b), M(0x05c), M(0x05d), M(0x05e), M(0x05f), -M(0x060), M(0x061), M(0x062), M(0x063), M(0x064), M(0x065), M(0x066), M(0x067), -M(0x068), M(0x069), M(0x06a), M(0x06b), M(0x06c), M(0x06d), M(0x06e), M(0x06f), -M(0x070), M(0x071), M(0x072), M(0x073), M(0x074), M(0x075), M(0x076), M(0x077), -M(0x078), M(0x079), M(0x07a), M(0x07b), M(0x07c), M(0x07d), M(0x07e), M(0x07f), -M(0x080), M(0x081), M(0x082), M(0x083), M(0x084), M(0x085), M(0x086), M(0x087), -M(0x088), M(0x089), M(0x08a), M(0x08b), M(0x08c), M(0x08d), M(0x08e), M(0x08f), -M(0x090), M(0x091), M(0x092), M(0x093), M(0x094), M(0x095), M(0x096), M(0x097), -M(0x098), M(0x099), M(0x09a), M(0x09b), M(0x09c), M(0x09d), M(0x09e), M(0x09f), -M(0x0a0), M(0x0a1), M(0x0a2), M(0x0a3), M(0x0a4), M(0x0a5), M(0x0a6), M(0x0a7), -M(0x0a8), M(0x0a9), M(0x0aa), M(0x0ab), M(0x0ac), M(0x0ad), M(0x0ae), M(0x0af), -M(0x0b0), M(0x0b1), M(0x0b2), M(0x0b3), M(0x0b4), M(0x0b5), M(0x0b6), M(0x0b7), -M(0x0b8), M(0x0b9), M(0x0ba), M(0x0bb), M(0x0bc), M(0x0bd), M(0x0be), M(0x0bf), -M(0x0c0), M(0x0c1), M(0x0c2), M(0x0c3), M(0x0c4), M(0x0c5), M(0x0c6), M(0x0c7), -M(0x0c8), M(0x0c9), M(0x0ca), M(0x0cb), M(0x0cc), M(0x0cd), M(0x0ce), M(0x0cf), -M(0x0d0), M(0x0d1), M(0x0d2), M(0x0d3), M(0x0d4), M(0x0d5), M(0x0d6), M(0x0d7), -M(0x0d8), M(0x0d9), M(0x0da), M(0x0db), M(0x0dc), M(0x0dd), M(0x0de), M(0x0df), -M(0x0e0), M(0x0e1), M(0x0e2), M(0x0e3), M(0x0e4), M(0x0e5), M(0x0e6), M(0x0e7), -M(0x0e8), M(0x0e9), M(0x0ea), M(0x0eb), M(0x0ec), M(0x0ed), M(0x0ee), M(0x0ef), -M(0x0f0), M(0x0f1), M(0x0f2), M(0x0f3), M(0x0f4), M(0x0f5), M(0x0f6), M(0x0f7), -M(0x0f8), M(0x0f9), M(0x0fa), M(0x0fb), M(0x0fc), M(0x0fd), M(0x0fe), M(0x0ff), -M(0x100), M(0x101), M(0x102), M(0x103), M(0x104), M(0x105), M(0x106), M(0x107), -M(0x108), M(0x109), M(0x10a), M(0x10b), M(0x10c), M(0x10d), M(0x10e), M(0x10f), -M(0x110), M(0x111), M(0x112), M(0x113), M(0x114), M(0x115), M(0x116), M(0x117), -M(0x118), M(0x119), M(0x11a), M(0x11b), M(0x11c), M(0x11d), M(0x11e), M(0x11f), -M(0x120), M(0x121), M(0x122), M(0x123), M(0x124), M(0x125), M(0x126), M(0x127), -M(0x128), M(0x129), M(0x12a), M(0x12b), M(0x12c), M(0x12d), M(0x12e), M(0x12f), -M(0x130), M(0x131), M(0x132), M(0x133), M(0x134), M(0x135), M(0x136), M(0x137), -M(0x138), M(0x139), M(0x13a), M(0x13b), M(0x13c), M(0x13d), M(0x13e), M(0x13f), -M(0x140), M(0x141), M(0x142), M(0x143), M(0x144), M(0x145), M(0x146), M(0x147), -M(0x148), M(0x149), M(0x14a), M(0x14b), M(0x14c), M(0x14d), M(0x14e), M(0x14f), -M(0x150), M(0x151), M(0x152), M(0x153), M(0x154), M(0x155), M(0x156), M(0x157), -M(0x158), M(0x159), M(0x15a), M(0x15b), M(0x15c), M(0x15d), M(0x15e), M(0x15f), -M(0x160), M(0x161), M(0x162), M(0x163), M(0x164), M(0x165), M(0x166), M(0x167), -M(0x168), M(0x169), M(0x16a), M(0x16b), M(0x16c), M(0x16d), M(0x16e), M(0x16f), -M(0x170), M(0x171), M(0x172), M(0x173), M(0x174), M(0x175), M(0x176), M(0x177), -M(0x178), M(0x179), M(0x17a), M(0x17b), M(0x17c), M(0x17d), M(0x17e), M(0x17f), -M(0x180), M(0x181), M(0x182), M(0x183), M(0x184), M(0x185), M(0x186), M(0x187), -M(0x188), M(0x189), M(0x18a), M(0x18b), M(0x18c), M(0x18d), M(0x18e), M(0x18f), -M(0x190), M(0x191), M(0x192), M(0x193), M(0x194), M(0x195), M(0x196), M(0x197), -M(0x198), M(0x199), M(0x19a), M(0x19b), M(0x19c), M(0x19d), M(0x19e), M(0x19f), -M(0x1a0), M(0x1a1), M(0x1a2), M(0x1a3), M(0x1a4), M(0x1a5), M(0x1a6), M(0x1a7), -M(0x1a8), M(0x1a9), M(0x1aa), M(0x1ab), M(0x1ac), M(0x1ad), M(0x1ae), M(0x1af), -M(0x1b0), M(0x1b1), M(0x1b2), M(0x1b3), M(0x1b4), M(0x1b5), M(0x1b6), M(0x1b7), -M(0x1b8), M(0x1b9), M(0x1ba), M(0x1bb), M(0x1bc), M(0x1bd), M(0x1be), M(0x1bf), -M(0x1c0), M(0x1c1), M(0x1c2), M(0x1c3), M(0x1c4), M(0x1c5), M(0x1c6), M(0x1c7), -M(0x1c8), M(0x1c9), M(0x1ca), M(0x1cb), M(0x1cc), M(0x1cd), M(0x1ce), M(0x1cf), -M(0x1d0), M(0x1d1), M(0x1d2), M(0x1d3), M(0x1d4), M(0x1d5), M(0x1d6), M(0x1d7), -M(0x1d8), M(0x1d9), M(0x1da), M(0x1db), M(0x1dc), M(0x1dd), M(0x1de), M(0x1df), -M(0x1e0), M(0x1e1), M(0x1e2), M(0x1e3), M(0x1e4), M(0x1e5), M(0x1e6), M(0x1e7), -M(0x1e8), M(0x1e9), M(0x1ea), M(0x1eb), M(0x1ec), M(0x1ed), M(0x1ee), M(0x1ef), -M(0x1f0), M(0x1f1), M(0x1f2), M(0x1f3), M(0x1f4), M(0x1f5), M(0x1f6), M(0x1f7), -M(0x1f8), M(0x1f9), M(0x1fa), M(0x1fb), M(0x1fc), M(0x1fd), M(0x1fe), M(0x1ff) -}; - -#ifdef MAKE_IDENTITY_MAP -/* -** "Identity" page map table. -** -** This just maps the first 4MB of physical memory. It is initialized -** in vm_init(). -** -** This could be converted into a 4GB map of 4MB pages by turning on -** the PDE_PS bit in each entry. -*/ - -// identity-map 4KB page #n -#define S(n) [n] = (pte_t) ( (TO_4KFRAME((n))) | (PTE_P|PTE_RW) ) - -const pte_t id_map[N_PTE] = { -S(0x000), S(0x001), S(0x002), S(0x003), S(0x004), S(0x005), S(0x006), S(0x007), -S(0x008), S(0x009), S(0x00a), S(0x00b), S(0x00c), S(0x00d), S(0x00e), S(0x00f), -S(0x010), S(0x011), S(0x012), S(0x013), S(0x014), S(0x015), S(0x016), S(0x017), -S(0x018), S(0x019), S(0x01a), S(0x01b), S(0x01c), S(0x01d), S(0x01e), S(0x01f), -S(0x020), S(0x021), S(0x022), S(0x023), S(0x024), S(0x025), S(0x026), S(0x027), -S(0x028), S(0x029), S(0x02a), S(0x02b), S(0x02c), S(0x02d), S(0x02e), S(0x02f), -S(0x030), S(0x031), S(0x032), S(0x033), S(0x034), S(0x035), S(0x036), S(0x037), -S(0x038), S(0x039), S(0x03a), S(0x03b), S(0x03c), S(0x03d), S(0x03e), S(0x03f), -S(0x040), S(0x041), S(0x042), S(0x043), S(0x044), S(0x045), S(0x046), S(0x047), -S(0x048), S(0x049), S(0x04a), S(0x04b), S(0x04c), S(0x04d), S(0x04e), S(0x04f), -S(0x050), S(0x051), S(0x052), S(0x053), S(0x054), S(0x055), S(0x056), S(0x057), -S(0x058), S(0x059), S(0x05a), S(0x05b), S(0x05c), S(0x05d), S(0x05e), S(0x05f), -S(0x060), S(0x061), S(0x062), S(0x063), S(0x064), S(0x065), S(0x066), S(0x067), -S(0x068), S(0x069), S(0x06a), S(0x06b), S(0x06c), S(0x06d), S(0x06e), S(0x06f), -S(0x070), S(0x071), S(0x072), S(0x073), S(0x074), S(0x075), S(0x076), S(0x077), -S(0x078), S(0x079), S(0x07a), S(0x07b), S(0x07c), S(0x07d), S(0x07e), S(0x07f), -S(0x080), S(0x081), S(0x082), S(0x083), S(0x084), S(0x085), S(0x086), S(0x087), -S(0x088), S(0x089), S(0x08a), S(0x08b), S(0x08c), S(0x08d), S(0x08e), S(0x08f), -S(0x090), S(0x091), S(0x092), S(0x093), S(0x094), S(0x095), S(0x096), S(0x097), -S(0x098), S(0x099), S(0x09a), S(0x09b), S(0x09c), S(0x09d), S(0x09e), S(0x09f), -S(0x0a0), S(0x0a1), S(0x0a2), S(0x0a3), S(0x0a4), S(0x0a5), S(0x0a6), S(0x0a7), -S(0x0a8), S(0x0a9), S(0x0aa), S(0x0ab), S(0x0ac), S(0x0ad), S(0x0ae), S(0x0af), -S(0x0b0), S(0x0b1), S(0x0b2), S(0x0b3), S(0x0b4), S(0x0b5), S(0x0b6), S(0x0b7), -S(0x0b8), S(0x0b9), S(0x0ba), S(0x0bb), S(0x0bc), S(0x0bd), S(0x0be), S(0x0bf), -S(0x0c0), S(0x0c1), S(0x0c2), S(0x0c3), S(0x0c4), S(0x0c5), S(0x0c6), S(0x0c7), -S(0x0c8), S(0x0c9), S(0x0ca), S(0x0cb), S(0x0cc), S(0x0cd), S(0x0ce), S(0x0cf), -S(0x0d0), S(0x0d1), S(0x0d2), S(0x0d3), S(0x0d4), S(0x0d5), S(0x0d6), S(0x0d7), -S(0x0d8), S(0x0d9), S(0x0da), S(0x0db), S(0x0dc), S(0x0dd), S(0x0de), S(0x0df), -S(0x0e0), S(0x0e1), S(0x0e2), S(0x0e3), S(0x0e4), S(0x0e5), S(0x0e6), S(0x0e7), -S(0x0e8), S(0x0e9), S(0x0ea), S(0x0eb), S(0x0ec), S(0x0ed), S(0x0ee), S(0x0ef), -S(0x0f0), S(0x0f1), S(0x0f2), S(0x0f3), S(0x0f4), S(0x0f5), S(0x0f6), S(0x0f7), -S(0x0f8), S(0x0f9), S(0x0fa), S(0x0fb), S(0x0fc), S(0x0fd), S(0x0fe), S(0x0ff), -S(0x100), S(0x101), S(0x102), S(0x103), S(0x104), S(0x105), S(0x106), S(0x107), -S(0x108), S(0x109), S(0x10a), S(0x10b), S(0x10c), S(0x10d), S(0x10e), S(0x10f), -S(0x110), S(0x111), S(0x112), S(0x113), S(0x114), S(0x115), S(0x116), S(0x117), -S(0x118), S(0x119), S(0x11a), S(0x11b), S(0x11c), S(0x11d), S(0x11e), S(0x11f), -S(0x120), S(0x121), S(0x122), S(0x123), S(0x124), S(0x125), S(0x126), S(0x127), -S(0x128), S(0x129), S(0x12a), S(0x12b), S(0x12c), S(0x12d), S(0x12e), S(0x12f), -S(0x130), S(0x131), S(0x132), S(0x133), S(0x134), S(0x135), S(0x136), S(0x137), -S(0x138), S(0x139), S(0x13a), S(0x13b), S(0x13c), S(0x13d), S(0x13e), S(0x13f), -S(0x140), S(0x141), S(0x142), S(0x143), S(0x144), S(0x145), S(0x146), S(0x147), -S(0x148), S(0x149), S(0x14a), S(0x14b), S(0x14c), S(0x14d), S(0x14e), S(0x14f), -S(0x150), S(0x151), S(0x152), S(0x153), S(0x154), S(0x155), S(0x156), S(0x157), -S(0x158), S(0x159), S(0x15a), S(0x15b), S(0x15c), S(0x15d), S(0x15e), S(0x15f), -S(0x160), S(0x161), S(0x162), S(0x163), S(0x164), S(0x165), S(0x166), S(0x167), -S(0x168), S(0x169), S(0x16a), S(0x16b), S(0x16c), S(0x16d), S(0x16e), S(0x16f), -S(0x170), S(0x171), S(0x172), S(0x173), S(0x174), S(0x175), S(0x176), S(0x177), -S(0x178), S(0x179), S(0x17a), S(0x17b), S(0x17c), S(0x17d), S(0x17e), S(0x17f), -S(0x180), S(0x181), S(0x182), S(0x183), S(0x184), S(0x185), S(0x186), S(0x187), -S(0x188), S(0x189), S(0x18a), S(0x18b), S(0x18c), S(0x18d), S(0x18e), S(0x18f), -S(0x190), S(0x191), S(0x192), S(0x193), S(0x194), S(0x195), S(0x196), S(0x197), -S(0x198), S(0x199), S(0x19a), S(0x19b), S(0x19c), S(0x19d), S(0x19e), S(0x19f), -S(0x1a0), S(0x1a1), S(0x1a2), S(0x1a3), S(0x1a4), S(0x1a5), S(0x1a6), S(0x1a7), -S(0x1a8), S(0x1a9), S(0x1aa), S(0x1ab), S(0x1ac), S(0x1ad), S(0x1ae), S(0x1af), -S(0x1b0), S(0x1b1), S(0x1b2), S(0x1b3), S(0x1b4), S(0x1b5), S(0x1b6), S(0x1b7), -S(0x1b8), S(0x1b9), S(0x1ba), S(0x1bb), S(0x1bc), S(0x1bd), S(0x1be), S(0x1bf), -S(0x1c0), S(0x1c1), S(0x1c2), S(0x1c3), S(0x1c4), S(0x1c5), S(0x1c6), S(0x1c7), -S(0x1c8), S(0x1c9), S(0x1ca), S(0x1cb), S(0x1cc), S(0x1cd), S(0x1ce), S(0x1cf), -S(0x1d0), S(0x1d1), S(0x1d2), S(0x1d3), S(0x1d4), S(0x1d5), S(0x1d6), S(0x1d7), -S(0x1d8), S(0x1d9), S(0x1da), S(0x1db), S(0x1dc), S(0x1dd), S(0x1de), S(0x1df), -S(0x1e0), S(0x1e1), S(0x1e2), S(0x1e3), S(0x1e4), S(0x1e5), S(0x1e6), S(0x1e7), -S(0x1e8), S(0x1e9), S(0x1ea), S(0x1eb), S(0x1ec), S(0x1ed), S(0x1ee), S(0x1ef), -S(0x1f0), S(0x1f1), S(0x1f2), S(0x1f3), S(0x1f4), S(0x1f5), S(0x1f6), S(0x1f7), -S(0x1f8), S(0x1f9), S(0x1fa), S(0x1fb), S(0x1fc), S(0x1fd), S(0x1fe), S(0x1ff), -S(0x200), S(0x201), S(0x202), S(0x203), S(0x204), S(0x205), S(0x206), S(0x207), -S(0x208), S(0x209), S(0x20a), S(0x20b), S(0x20c), S(0x20d), S(0x20e), S(0x20f), -S(0x210), S(0x211), S(0x212), S(0x213), S(0x214), S(0x215), S(0x216), S(0x217), -S(0x218), S(0x219), S(0x21a), S(0x21b), S(0x21c), S(0x21d), S(0x21e), S(0x21f), -S(0x220), S(0x221), S(0x222), S(0x223), S(0x224), S(0x225), S(0x226), S(0x227), -S(0x228), S(0x229), S(0x22a), S(0x22b), S(0x22c), S(0x22d), S(0x22e), S(0x22f), -S(0x230), S(0x231), S(0x232), S(0x233), S(0x234), S(0x235), S(0x236), S(0x237), -S(0x238), S(0x239), S(0x23a), S(0x23b), S(0x23c), S(0x23d), S(0x23e), S(0x23f), -S(0x240), S(0x241), S(0x242), S(0x243), S(0x244), S(0x245), S(0x246), S(0x247), -S(0x248), S(0x249), S(0x24a), S(0x24b), S(0x24c), S(0x24d), S(0x24e), S(0x24f), -S(0x250), S(0x251), S(0x252), S(0x253), S(0x254), S(0x255), S(0x256), S(0x257), -S(0x258), S(0x259), S(0x25a), S(0x25b), S(0x25c), S(0x25d), S(0x25e), S(0x25f), -S(0x260), S(0x261), S(0x262), S(0x263), S(0x264), S(0x265), S(0x266), S(0x267), -S(0x268), S(0x269), S(0x26a), S(0x26b), S(0x26c), S(0x26d), S(0x26e), S(0x26f), -S(0x270), S(0x271), S(0x272), S(0x273), S(0x274), S(0x275), S(0x276), S(0x277), -S(0x278), S(0x279), S(0x27a), S(0x27b), S(0x27c), S(0x27d), S(0x27e), S(0x27f), -S(0x280), S(0x281), S(0x282), S(0x283), S(0x284), S(0x285), S(0x286), S(0x287), -S(0x288), S(0x289), S(0x28a), S(0x28b), S(0x28c), S(0x28d), S(0x28e), S(0x28f), -S(0x290), S(0x291), S(0x292), S(0x293), S(0x294), S(0x295), S(0x296), S(0x297), -S(0x298), S(0x299), S(0x29a), S(0x29b), S(0x29c), S(0x29d), S(0x29e), S(0x29f), -S(0x2a0), S(0x2a1), S(0x2a2), S(0x2a3), S(0x2a4), S(0x2a5), S(0x2a6), S(0x2a7), -S(0x2a8), S(0x2a9), S(0x2aa), S(0x2ab), S(0x2ac), S(0x2ad), S(0x2ae), S(0x2af), -S(0x2b0), S(0x2b1), S(0x2b2), S(0x2b3), S(0x2b4), S(0x2b5), S(0x2b6), S(0x2b7), -S(0x2b8), S(0x2b9), S(0x2ba), S(0x2bb), S(0x2bc), S(0x2bd), S(0x2be), S(0x2bf), -S(0x2c0), S(0x2c1), S(0x2c2), S(0x2c3), S(0x2c4), S(0x2c5), S(0x2c6), S(0x2c7), -S(0x2c8), S(0x2c9), S(0x2ca), S(0x2cb), S(0x2cc), S(0x2cd), S(0x2ce), S(0x2cf), -S(0x2d0), S(0x2d1), S(0x2d2), S(0x2d3), S(0x2d4), S(0x2d5), S(0x2d6), S(0x2d7), -S(0x2d8), S(0x2d9), S(0x2da), S(0x2db), S(0x2dc), S(0x2dd), S(0x2de), S(0x2df), -S(0x2e0), S(0x2e1), S(0x2e2), S(0x2e3), S(0x2e4), S(0x2e5), S(0x2e6), S(0x2e7), -S(0x2e8), S(0x2e9), S(0x2ea), S(0x2eb), S(0x2ec), S(0x2ed), S(0x2ee), S(0x2ef), -S(0x2f0), S(0x2f1), S(0x2f2), S(0x2f3), S(0x2f4), S(0x2f5), S(0x2f6), S(0x2f7), -S(0x2f8), S(0x2f9), S(0x2fa), S(0x2fb), S(0x2fc), S(0x2fd), S(0x2fe), S(0x2ff), -S(0x300), S(0x301), S(0x302), S(0x303), S(0x304), S(0x305), S(0x306), S(0x307), -S(0x308), S(0x309), S(0x30a), S(0x30b), S(0x30c), S(0x30d), S(0x30e), S(0x30f), -S(0x310), S(0x311), S(0x312), S(0x313), S(0x314), S(0x315), S(0x316), S(0x317), -S(0x318), S(0x319), S(0x31a), S(0x31b), S(0x31c), S(0x31d), S(0x31e), S(0x31f), -S(0x320), S(0x321), S(0x322), S(0x323), S(0x324), S(0x325), S(0x326), S(0x327), -S(0x328), S(0x329), S(0x32a), S(0x32b), S(0x32c), S(0x32d), S(0x32e), S(0x32f), -S(0x330), S(0x331), S(0x332), S(0x333), S(0x334), S(0x335), S(0x336), S(0x337), -S(0x338), S(0x339), S(0x33a), S(0x33b), S(0x33c), S(0x33d), S(0x33e), S(0x33f), -S(0x340), S(0x341), S(0x342), S(0x343), S(0x344), S(0x345), S(0x346), S(0x347), -S(0x348), S(0x349), S(0x34a), S(0x34b), S(0x34c), S(0x34d), S(0x34e), S(0x34f), -S(0x350), S(0x351), S(0x352), S(0x353), S(0x354), S(0x355), S(0x356), S(0x357), -S(0x358), S(0x359), S(0x35a), S(0x35b), S(0x35c), S(0x35d), S(0x35e), S(0x35f), -S(0x360), S(0x361), S(0x362), S(0x363), S(0x364), S(0x365), S(0x366), S(0x367), -S(0x368), S(0x369), S(0x36a), S(0x36b), S(0x36c), S(0x36d), S(0x36e), S(0x36f), -S(0x370), S(0x371), S(0x372), S(0x373), S(0x374), S(0x375), S(0x376), S(0x377), -S(0x378), S(0x379), S(0x37a), S(0x37b), S(0x37c), S(0x37d), S(0x37e), S(0x37f), -S(0x380), S(0x381), S(0x382), S(0x383), S(0x384), S(0x385), S(0x386), S(0x387), -S(0x388), S(0x389), S(0x38a), S(0x38b), S(0x38c), S(0x38d), S(0x38e), S(0x38f), -S(0x390), S(0x391), S(0x392), S(0x393), S(0x394), S(0x395), S(0x396), S(0x397), -S(0x398), S(0x399), S(0x39a), S(0x39b), S(0x39c), S(0x39d), S(0x39e), S(0x39f), -S(0x3a0), S(0x3a1), S(0x3a2), S(0x3a3), S(0x3a4), S(0x3a5), S(0x3a6), S(0x3a7), -S(0x3a8), S(0x3a9), S(0x3aa), S(0x3ab), S(0x3ac), S(0x3ad), S(0x3ae), S(0x3af), -S(0x3b0), S(0x3b1), S(0x3b2), S(0x3b3), S(0x3b4), S(0x3b5), S(0x3b6), S(0x3b7), -S(0x3b8), S(0x3b9), S(0x3ba), S(0x3bb), S(0x3bc), S(0x3bd), S(0x3be), S(0x3bf), -S(0x3c0), S(0x3c1), S(0x3c2), S(0x3c3), S(0x3c4), S(0x3c5), S(0x3c6), S(0x3c7), -S(0x3c8), S(0x3c9), S(0x3ca), S(0x3cb), S(0x3cc), S(0x3cd), S(0x3ce), S(0x3cf), -S(0x3d0), S(0x3d1), S(0x3d2), S(0x3d3), S(0x3d4), S(0x3d5), S(0x3d6), S(0x3d7), -S(0x3d8), S(0x3d9), S(0x3da), S(0x3db), S(0x3dc), S(0x3dd), S(0x3de), S(0x3df), -S(0x3e0), S(0x3e1), S(0x3e2), S(0x3e3), S(0x3e4), S(0x3e5), S(0x3e6), S(0x3e7), -S(0x3e8), S(0x3e9), S(0x3ea), S(0x3eb), S(0x3ec), S(0x3ed), S(0x3ee), S(0x3ef), -S(0x3f0), S(0x3f1), S(0x3f2), S(0x3f3), S(0x3f4), S(0x3f5), S(0x3f6), S(0x3f7), -S(0x3f8), S(0x3f9), S(0x3fa), S(0x3fb), S(0x3fc), S(0x3fd), S(0x3fe), S(0x3ff) -}; -#endif /* MAKE_IDENTITY_MAP */ - -/* -** Kernel address mappings, present in every page table -*/ -const mapping_t kmap[] = { - // va pa_start pa_end perms - { KERN_BASE, 0, EXT_BASE, PDE_RW }, - { KERN_VLINK, KERN_PLINK, V2P(_data), 0 }, - { (uint32_t) _data, V2P(_data), KERN_BASE, PDE_RW }, - { DEV_BASE, DEV_BASE, 0, PDE_RW } -}; -const uint_t n_kmap = sizeof(kmap) / sizeof(kmap[0]); |