Aren
/
toaruos
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

modules: Reimplement loadable kernel modules

This commit is contained in:
K. Lange 2021-07-17 18:55:54 +09:00
parent b5d33500a6
commit 236c8bacb3
15 changed files with 460 additions and 302 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Makefile
View File

@ -91,7 +91,7 @@ system: image.iso
$(BASE)/mod/%.ko: modules/%.c | dirs
${CC} -c ${KERNEL_CFLAGS} -mcmodel=large -o $@ $<
ramdisk.igz: $(wildcard $(BASE)/* $(BASE)/*/* $(BASE)/*/*/* $(BASE)/*/*/*/* $(BASE)/*/*/*/*/*) $(APPS_X) $(LIBS_X) $(KRK_MODS_X) $(BASE)/bin/kuroko $(BASE)/lib/ld.so $(APPS_KRK_X) $(KRK_MODS) $(APPS_SH_X)
ramdisk.igz: $(wildcard $(BASE)/* $(BASE)/*/* $(BASE)/*/*/* $(BASE)/*/*/*/* $(BASE)/*/*/*/*/*) $(APPS_X) $(LIBS_X) $(KRK_MODS_X) $(BASE)/bin/kuroko $(BASE)/lib/ld.so $(APPS_KRK_X) $(KRK_MODS) $(APPS_SH_X) $(MODULES)
python3 util/createramdisk.py
KRK_SRC = $(sort $(wildcard kuroko/src/*.c))

34
apps/lspci.c
View File

@ -174,7 +174,9 @@ static void show_usage(char * argv[]) {
int main(int argc, char * argv[]) {
int numeric = 0;
int opt;
while ((opt = getopt(argc, argv, "n?")) != -1) {
char * query = NULL;
while ((opt = getopt(argc, argv, "nq:?")) != -1) {
switch (opt) {
case '?':
show_usage(argv);
@ -182,6 +184,9 @@ int main(int argc, char * argv[]) {
case 'n':
numeric = 1;
break;
case 'q':
query = optarg;
break;
}
}
@ -235,7 +240,31 @@ int main(int argc, char * argv[]) {
}
*last_paren = '\0';
if (numeric) {
if (query) {
unsigned short vendor_id = strtoul(device_vendor, NULL, 16);
unsigned short device_id = strtoul(device_code, NULL, 16);
char * start = query;
while (start) {
char * colon = strchr(start, ':');
if (!colon) return 2; /* Invalid query string */
*colon = '\0';
char * comma = strchr(colon+1, ',');
if (comma) *comma = '\0';
unsigned long query_man = strtoul(start,NULL,16);
unsigned long query_dev = strtoul(colon+1,NULL,16);
if (query_man == vendor_id && query_dev == device_id) return 0;
*colon = ':';
if (comma) {
*comma = ',';
start = comma + 1;
} else {
start = NULL;
}
}
} else if (numeric) {
fprintf(stdout, "%s %s: %s:%s\n", device_bus, device_class, device_vendor, device_code);
} else {
unsigned short class_id = strtoul(device_class, NULL, 16);
@ -256,5 +285,6 @@ int main(int argc, char * argv[]) {
}
}
if (query) return 1;
return 0;
}

11
base/etc/startup.d/04_modprobe.sh Executable file
View File

@ -0,0 +1,11 @@
#!/bin/sh
# Add module descriptions here...
if lspci -q 8086:2415 then insmod /mod/ac97.ko
if lspci -q 1234:1111 then insmod /mod/vmware.ko
if lspci -q 80EE:CAFE then insmod /mod/vbox.ko
if lspci -q 8086:0046 then insmod /mod/i965.ko
if lspci -q 8086:100e,8086:1004,8086:100f,8086:10ea,8086:10d3 then insmod /mod/e1000.ko

0
base/etc/startup.d/04_mountcd.sh → base/etc/startup.d/05_mountcd.sh
View File

1
base/usr/include/kernel/arch/x86_64/mmu.h
View File

@ -32,6 +32,7 @@ uintptr_t mmu_allocate_n_frames(int n);
union PML * mmu_get_kernel_directory(void);
void * mmu_map_from_physical(uintptr_t frameaddress);
void * mmu_map_mmio_region(uintptr_t physical_address, size_t size);
void * mmu_map_module(size_t size);
size_t mmu_count_user(union PML * from);
size_t mmu_count_shm(union PML * from);

7
base/usr/include/kernel/module.h Normal file
View File

@ -0,0 +1,7 @@
#pragma once
struct Module {
const char * name;
int (*init)(int argc, char * argv[]);
int (*fini)(void);
};

23
kernel/arch/x86_64/main.c
View File

@ -41,6 +41,7 @@ extern void portio_initialize(void);
extern void ps2hid_install(void);
extern void serial_initialize(void);
extern void fbterm_initialize(void);
extern void xhci_initialize(void);
#define EARLY_LOG_DEVICE 0x3F8
static size_t _early_log_write(size_t size, uint8_t * buffer) {
@ -290,30 +291,8 @@ int kmain(struct multiboot * mboot, uint32_t mboot_mag, void* esp) {
ps2hid_install();
serial_initialize();
portio_initialize();
extern void xhci_initialize(void);
xhci_initialize();
/* Special drivers should probably be modules... */
extern void ac97_install(void);
ac97_install();
if (!args_present("novmware")) {
extern void vmware_initialize(void);
vmware_initialize();
}
if (!args_present("novbox")) {
extern void vbox_initialize(void);
vbox_initialize();
}
extern void i965_initialize(void);
i965_initialize();
extern void e1000_initialize(void);
e1000_initialize();
/* Yield to the generic main, which starts /bin/init */
return generic_main();
}

32
kernel/arch/x86_64/mmu.c
View File

@ -31,6 +31,7 @@ static uint32_t nframes;
#define KERNEL_HEAP_START 0xFFFFff0000000000UL
#define MMIO_BASE_START 0xffffff1fc0000000UL
#define HIGH_MAP_REGION 0xffffff8000000000UL
#define MODULE_BASE_START 0xffffffff80000000UL
/* These are actually defined in the shm layer... */
#define USER_SHM_LOW 0x0000000200000000UL
@ -86,6 +87,7 @@ int mmu_frame_test(uintptr_t frame_addr) {
static spin_lock_t frame_alloc_lock = { 0 };
static spin_lock_t kheap_lock = { 0 };
static spin_lock_t mmio_space_lock = { 0 };
static spin_lock_t module_space_lock = { 0 };
/**
* @brief Find the first range of @p n contiguous frames.
@ -807,3 +809,33 @@ void * mmu_map_mmio_region(uintptr_t physical_address, size_t size) {
return out;
}
static uintptr_t module_base_address = MODULE_BASE_START;
/**
* @brief Obtain space to load a module in the -2GiB region.
*
* This should really start immediately after the kernel, but we don't
* yet load the kernel in the -2GiB region... it might also be worthwhile
* to implement some ASLR here, especially given that we're loading
* relocatable ELF object files and can stick them anywhere.
*/
void * mmu_map_module(size_t size) {
if (size & PAGE_LOW_MASK) {
size += (PAGE_LOW_MASK + 1) - (size & PAGE_LOW_MASK);
}
spin_lock(module_space_lock);
void * out = (void*)module_base_address;
for (size_t i = 0; i < size; i += PAGE_SIZE) {
union PML * p = mmu_get_page(module_base_address + i, MMU_GET_MAKE);
mmu_frame_allocate(p, MMU_FLAG_KERNEL | MMU_FLAG_WRITABLE);
mmu_invalidate(module_base_address + i);
}
module_base_address += size;
spin_unlock(module_space_lock);
return out;
}

144
kernel/misc/elf64.c
View File

@ -17,6 +17,7 @@
#include <kernel/process.h>
#include <kernel/mmu.h>
#include <kernel/misc.h>
#include <kernel/ksym.h>
static Elf64_Shdr * elf_getSection(Elf64_Header * this, Elf64_Word index) {
return (Elf64_Shdr*)((uintptr_t)this + this->e_shoff + index * this->e_shentsize);
@ -49,6 +50,11 @@ static const char * sectionHeaderTypeToStr(Elf64_Word type) {
}
}
struct Module {
const char * name;
int (*init)(int argc, char * argv[]);
int (*fini)(void);
};
int elf_module(const char * path) {
Elf64_Header header;
@ -80,69 +86,105 @@ int elf_module(const char * path) {
return -EINVAL;
}
printf("Loading module...\n");
/* Just slap the whole thing into memory, why not... */
char * module_load_address = mmu_map_module(file->length);
read_fs(file, 0, file->length, (void*)module_load_address);
/**
* Load the section string table, we'll want this for debugging, mostly.
* Locate the section string table, which we'll use for debugging and to check
* for special section names (eg. dependencies, PCI mappings...)
*/
Elf64_Shdr shstr_hdr;
read_fs(file, header.e_shoff + header.e_shentsize * header.e_shstrndx, sizeof(Elf64_Shdr), (uint8_t*)&shstr_hdr);
char * stringTable = malloc(shstr_hdr.sh_size);
read_fs(file, shstr_hdr.sh_offset, shstr_hdr.sh_size, (uint8_t*)stringTable);
#if 0
Elf64_Shdr * shstr_hdr = (Elf64_Shdr*)(module_load_address + header.e_shoff + header.e_shentsize * header.e_shstrndx);
char * stringTable = (char*)(module_load_address + shstr_hdr->sh_offset);
#endif
/**
* Modules are relocatable objects, so we have to link them by sections,
* not by PHDRs - they don't have those. We'll generally see a lot more
* relocations but usually of a smaller set.
* Set up section header entries to have correct loaded addresses, and map
* any NOBITS sections to new memory. We'll page-align anything, which
* should be good enough for any object files we make...
*/
printf("\nSection Headers:\n");
printf(" [Nr] Name Type Address Offset\n");
printf(" Size EntSize Flags Link Info Align\n");
for (unsigned int i = 0; i < header.e_shnum; ++i) {
Elf64_Shdr sectionHeader;
read_fs(file, header.e_shoff + header.e_shentsize * i, sizeof(Elf64_Shdr), (uint8_t*)&sectionHeader);
if (sectionHeader.sh_type == SHT_PROGBITS) {
printf("progbits: %s\n", stringTable + sectionHeader.sh_name);
} else if (sectionHeader.sh_type == SHT_NOBITS) {
printf("nobits: %s\n", stringTable + sectionHeader.sh_name);
}
#if 0
printf(" [%2d] %-17.17s %-16.16s %016lx %08lx\n",
i, stringTable + sectionHeader.sh_name, sectionHeaderTypeToStr(sectionHeader.sh_type),
sectionHeader.sh_addr, sectionHeader.sh_offset);
printf(" %016lx %016lx %4ld %6d %5d %5ld\n",
sectionHeader.sh_size, sectionHeader.sh_entsize, sectionHeader.sh_flags,
sectionHeader.sh_link, sectionHeader.sh_info, sectionHeader.sh_addralign);
#endif
}
/**
* In order to load a module, we need to link it as an object
* into the running kernel using the symbol table we integrated
* into our binary.
*/
//char * shrstrtab = (char*)elfHeader + elf_getSection(elfHeader, elfHeader->e_shstrndx)->sh_offset;
/**
* First, we're going to check sections and update their addresses.
*/
#if 0
for (unsigned int i = 0; i < elfHeader->e_shnum; ++i) {
Elf64_Shdr * shdr = elf_getSection(elfHeader, i);
if (shdr->sh_type == SHT_NOBITS) {
if (shdr->sh_size) {
printf("Warning: Module needs %lu bytes for BSS, we don't have an allocator.\n",
shdr->sh_size);
}
/* otherwise, skip bss */
Elf64_Shdr * sectionHeader = (Elf64_Shdr*)(module_load_address + header.e_shoff + header.e_shentsize * i);
if (sectionHeader->sh_type == SHT_NOBITS) {
sectionHeader->sh_addr = (uintptr_t)mmu_map_module(sectionHeader->sh_size);
memset((void*)sectionHeader->sh_addr, 0, sectionHeader->sh_size);
} else {
shdr->sh_addr = (uintptr_t)atAddress + shdr->sh_offset;
sectionHeader->sh_addr = (uintptr_t)(module_load_address + sectionHeader->sh_offset);
}
}
struct Module * moduleData = NULL;
/**
* Let's start loading symbols...
*/
for (unsigned int i = 0; i < header.e_shnum; ++i) {
Elf64_Shdr * sectionHeader = (Elf64_Shdr*)(module_load_address + header.e_shoff + header.e_shentsize * i);
if (sectionHeader->sh_type != SHT_SYMTAB) continue;
Elf64_Shdr * strtab_hdr = (Elf64_Shdr*)(module_load_address + header.e_shoff + header.e_shentsize * sectionHeader->sh_link);
char * symNames = (char*)strtab_hdr->sh_addr;
Elf64_Sym * symTable = (Elf64_Sym*)sectionHeader->sh_addr;
/* Uh, we should be able to figure out how many symbols we have by doing something less dumb than
* just checking the size of the section, right? */
for (unsigned int sym = 0; sym < sectionHeader->sh_size / sizeof(Elf64_Sym); ++sym) {
/* TODO: We need to share symbols... */
#if 0
int binding = (symTable[sym].st_info >> 4);
int type = (symTable[sym].st_info & 0xF);
#endif
return 0;
if (symTable[sym].st_shndx > 0 && symTable[sym].st_shndx < SHN_LOPROC) {
Elf64_Shdr * sh_hdr = (Elf64_Shdr*)(module_load_address + header.e_shoff + header.e_shentsize * symTable[sym].st_shndx);
symTable[sym].st_value = symTable[sym].st_value + sh_hdr->sh_addr;
} else if (symTable[sym].st_shndx == SHN_UNDEF) {
symTable[sym].st_value = (uintptr_t)ksym_lookup(symNames + symTable[sym].st_name);
}
if (symTable[sym].st_name && !strcmp(symNames + symTable[sym].st_name, "metadata")) {
moduleData = (void*)symTable[sym].st_value;
}
}
}
if (!moduleData) {
printf("No module data, bailing.\n");
return -EINVAL;
}
for (unsigned int i = 0; i < header.e_shnum; ++i) {
Elf64_Shdr * sectionHeader = (Elf64_Shdr*)(module_load_address + header.e_shoff + header.e_shentsize * i);
if (sectionHeader->sh_type != SHT_RELA) continue;
Elf64_Rela * table = (Elf64_Rela*)sectionHeader->sh_addr;
/* Get the section these relocations apply to */
Elf64_Shdr * targetSection = (Elf64_Shdr*)(module_load_address + header.e_shoff + header.e_shentsize * sectionHeader->sh_info);
/* Get the symbol table */
Elf64_Shdr * symbolSection = (Elf64_Shdr*)(module_load_address + header.e_shoff + header.e_shentsize * sectionHeader->sh_link);
Elf64_Sym * symbolTable = (Elf64_Sym *)symbolSection->sh_addr;
for (unsigned int rela = 0; rela < sectionHeader->sh_size / sizeof(Elf64_Rela); ++rela) {
uintptr_t target = table[rela].r_offset + targetSection->sh_addr;
switch (ELF64_R_TYPE(table[rela].r_info)) {
case R_X86_64_64:
*(uint64_t*)target = symbolTable[ELF64_R_SYM(table[rela].r_info)].st_value + table[rela].r_addend;
break;
case R_X86_64_32:
*(uint32_t*)target = symbolTable[ELF64_R_SYM(table[rela].r_info)].st_value + table[rela].r_addend;
break;
case R_X86_64_PC32:
*(uint32_t*)target = symbolTable[ELF64_R_SYM(table[rela].r_info)].st_value + table[rela].r_addend - target;
break;
default:
printf("Unsupported relocation: %ld\n", ELF64_R_TYPE(table[rela].r_info));
return -EINVAL;
}
}
}
return moduleData->init(0,NULL);
}
int elf_exec(const char * path, fs_node_t * file, int argc, const char *const argv[], const char *const env[], int interp) {

16
kernel/audio/ac97.c → modules/ac97.c
View File

@ -19,6 +19,7 @@
* Copyright (C) 2015-2021 K. Lange
*/
#include <errno.h>
#include <kernel/types.h>
#include <kernel/string.h>
#include <kernel/printf.h>
@ -26,6 +27,7 @@
#include <kernel/process.h>
#include <kernel/mmu.h>
#include <kernel/list.h>
#include <kernel/module.h>
#include <kernel/mod/snd.h>
#include <kernel/arch/x86_64/ports.h>
@ -241,11 +243,11 @@ static int ac97_mixer_write(uint32_t knob_id, uint32_t val) {
return 0;
}
void ac97_install(void) {
static int ac97_install(int argc, char * argv[]) {
//debug_print(NOTICE, "Initializing AC97");
pci_scan(&find_ac97, -1, &_device);
if (!_device.pci_device) {
return;
return -ENODEV;
}
_device.nabmbar = pci_read_field(_device.pci_device, AC97_NABMBAR, 2) & ((uint32_t) -1) << 1;
_device.nambar = pci_read_field(_device.pci_device, PCI_BAR0, 4) & ((uint32_t) -1) << 1;
@ -300,10 +302,9 @@ void ac97_install(void) {
//debug_print(NOTICE, "AC97 initialized successfully");
return;
return 0;
}
#if 0
static int fini(void) {
snd_unregister(&_snd);
@ -313,5 +314,10 @@ static int fini(void) {
}
return 0;
}
#endif
struct Module metadata = {
.name = "ac97",
.init = ac97_install,
.fini = fini,
};

40
kernel/net/e1000.c → modules/e1000.c
View File

@ -21,6 +21,7 @@
#include <kernel/mod/net.h>
#include <kernel/net/netif.h>
#include <kernel/net/eth.h>
#include <kernel/module.h>
#include <errno.h>
#include <kernel/arch/x86_64/irq.h>
@ -370,8 +371,15 @@ static int wait_e1000(fs_node_t *node, void * process) {
return 0;
}
static void e1000_init(void * data) {
static void e1000_process(void * data) {
struct e1000_nic * nic = data;
while (1) {
struct ethernet_packet * packet = dequeue_packet(nic);
net_eth_handle(packet, nic->eth.device_node);
}
}
static void e1000_init(struct e1000_nic * nic) {
uint32_t e1000_device_pci = nic->pci_device;
nic->rx_phys = mmu_allocate_a_frame() << 12;
@ -511,11 +519,9 @@ static void e1000_init(void * data) {
net_add_interface(nic->eth.if_name, nic->eth.device_node);
/* Now wait for packets */
while (1) {
struct ethernet_packet * packet = dequeue_packet(nic);
net_eth_handle(packet, nic->eth.device_node);
}
char worker_name[34];
snprintf(worker_name, 33, "[%s]", nic->eth.if_name);
spawn_worker_thread(e1000_process, worker_name, nic);
}
static void find_e1000(uint32_t device, uint16_t vendorid, uint16_t deviceid, void * found) {
@ -531,21 +537,31 @@ static void find_e1000(uint32_t device, uint16_t vendorid, uint16_t deviceid, vo
(int)pci_extract_bus(device),
(int)pci_extract_slot(device));
char worker_name[34];
snprintf(worker_name, 33, "[%s]", nic->eth.if_name);
spawn_worker_thread(e1000_init, worker_name, nic);
e1000_init(nic);
*(int*)found = 1;
}
}
void e1000_initialize(void) {
static int e1000_install(int argc, char * argv[]) {
uint32_t found = 0;
pci_scan(&find_e1000, -1, &found);
if (!found) {
/* TODO: Clean up? Remove ourselves? */
return;
return -ENODEV;
}
return 0;
}
static int fini(void) {
/* TODO: Uninstall device */
return 0;
}
struct Module metadata = {
.name = "e1000",
.init = e1000_install,
.fini = fini,
};

18
kernel/video/i965.c → modules/i965.c
View File

@ -7,6 +7,7 @@
* for the panel on one particular model of Lenovo ThinkPad and then sets
* a handful of registers to get the framebuffer into the right resolution.
*/
#include <errno.h>
#include <kernel/printf.h>
#include <kernel/types.h>
#include <kernel/video.h>
@ -14,6 +15,7 @@
#include <kernel/mmu.h>
#include <kernel/vfs.h>
#include <kernel/args.h>
#include <kernel/module.h>
#define REG_PIPEASRC 0x6001C
#define REG_PIPEACONF 0x70008
@ -82,7 +84,19 @@ static void find_intel(uint32_t device, uint16_t v, uint16_t d, void * extra) {
}
}
void i965_initialize(void) {
if (args_present("noi965")) return;
static int i965_install(int argc, char * argv[]) {
if (args_present("noi965")) return -ENODEV;
pci_scan(find_intel, -1, NULL);
return 0;
}
static int fini(void) {
return 0;
}
struct Module metadata = {
.name = "i965",
.init = i965_install,
.fini = fini,
};

9
modules/test.c
View File

@ -1,7 +1,8 @@
#include <kernel/printf.h>
#include <kernel/module.h>
static int init(int argc, char * argv[]) {
printf("Hello, world.\n");
printf("Hello, modules.\n");
return 0;
}
@ -9,11 +10,7 @@ static int fini(void) {
return 0;
}
struct Module {
const char * name;
int (*init)(int argc, char * argv[]);
int (*fini)(void);
} module_info_test = {
struct Module metadata = {
.name = "test",
.init = init,
.fini = fini,

20
kernel/arch/x86_64/vbox.c → modules/vbox.c
View File

@ -14,7 +14,7 @@
* of the NCSA / University of Illinois License - see LICENSE.md
* Copyright (C) 2016-2021 K. Lange
*/
#include <errno.h>
#include <kernel/types.h>
#include <kernel/vfs.h>
#include <kernel/printf.h>
@ -24,6 +24,7 @@
#include <kernel/pipe.h>
#include <kernel/mouse.h>
#include <kernel/args.h>
#include <kernel/module.h>
#include <kernel/arch/x86_64/regs.h>
#include <kernel/arch/x86_64/ports.h>
@ -276,10 +277,11 @@ static void * kvmalloc_p(size_t size, uint32_t * outphys) {
return mmu_map_from_physical(index);
}
void vbox_initialize(void) {
static int vbox_install(int argc, char * argv[]) {
if (args_present("novbox")) return -ENODEV;
pci_scan(vbox_scan_pci, -1, &vbox_device);
if (!vbox_device) return -ENODEV;
if (vbox_device) {
if (!args_present("novboxdebug")) {
vbox_set_log();
}
@ -452,7 +454,17 @@ void vbox_initialize(void) {
}
vbox_vmmdev[3] = 0xFFFFFFFF; /* Enable all for now */
}
return 0;
}
static int fini(void) {
return 0;
}
struct Module metadata = {
.name = "vbox",
.init = vbox_install,
.fini = fini,
};

17
kernel/arch/x86_64/vmware.c → modules/vmware.c
View File

@ -34,6 +34,7 @@
#include <kernel/mouse.h>
#include <kernel/time.h>
#include <kernel/args.h>
#include <kernel/module.h>
#include <kernel/arch/x86_64/ports.h>
#define VMWARE_MAGIC 0x564D5868 /* hXMV */
@ -484,8 +485,8 @@ static int ioctl_mouse(fs_node_t * node, unsigned long request, void * argp) {
}
}
void vmware_initialize(void) {
if (detect_device()) {
static int vmware_initialize(int argc, char * argv[]) {
if (!detect_device()) return -ENODEV;
mouse_pipe = make_pipe(sizeof(mouse_device_packet_t) * PACKETS_IN_PIPE);
mouse_pipe->flags = FS_CHARDEVICE;
@ -510,6 +511,16 @@ void vmware_initialize(void) {
}
#endif
}
return 0;
}
static int fini(void) {
return 0;
}
struct Module metadata = {
.name = "vmware",
.init = vmware_initialize,
.fini = fini,
};