matos/core/main.c

278 lines
8.5 KiB
C
Raw Normal View History

2019-04-11 22:34:20 +02:00
#include "alloc.h"
2021-08-09 09:26:10 +02:00
#include "allocArea.h"
2021-10-03 23:19:00 +02:00
#include "ata.h"
2022-07-25 17:10:28 +02:00
#include "elf.h"
2018-07-20 15:41:58 +02:00
#include "exception.h"
#include "gdt.h"
#include "idt.h"
#include "interrupt.h"
#include "io.h"
#include "irq.h"
2021-11-05 23:02:23 +01:00
#include "kernel.h"
2021-10-07 21:23:32 +02:00
#include "keyboard.h"
2018-08-09 22:19:34 +02:00
#include "klibc.h"
2018-08-06 18:41:45 +02:00
#include "mem.h"
2021-10-30 00:28:31 +02:00
#include "mmuContext.h"
#include "multiboot.h"
2018-11-11 23:04:23 +01:00
#include "paging.h"
2018-07-20 15:41:58 +02:00
#include "pit.h"
2021-10-30 15:43:40 +02:00
#include "process.h"
2018-11-08 21:11:45 +01:00
#include "serial.h"
2020-04-23 00:49:09 +02:00
#include "stack.h"
#include "stdarg.h"
2021-11-03 23:54:36 +01:00
#include "swintr.h"
2021-11-05 23:02:23 +01:00
#include "thread.h"
2018-11-08 22:08:27 +01:00
#ifdef RUN_TEST
#include "test.h"
#endif
2020-04-27 23:08:36 +02:00
#include "time.h"
2018-11-11 23:04:23 +01:00
#include "types.h"
2018-07-20 15:41:58 +02:00
#include "vga.h"
2023-03-24 23:43:09 +01:00
#include "zero.h"
2018-07-20 15:41:58 +02:00
2018-08-09 22:19:34 +02:00
#define CHECK_FLAG(flags, bit) ((flags) & (1 << (bit)))
2018-07-20 15:41:58 +02:00
void idleThread(void *arg)
{
2020-04-23 00:49:09 +02:00
(void)arg;
2020-05-03 14:45:26 +02:00
while (1) {
2024-02-11 15:34:33 +01:00
VGAPrintf(GREEN, BLACK, 0, VGA_HEIGHT - 1, "%d allocated %d, mapped %d", (jiffies / HZ), getNbAllocatedPage(), getNbMappedPage());
2021-10-30 14:18:21 +02:00
threadYield();
2020-05-03 14:45:26 +02:00
}
}
2021-11-05 23:02:23 +01:00
#define FILE_HEADER_SIZE 16
2022-08-07 16:20:01 +02:00
#define FILE_MAX_SIZE 64 // In nb of sectors
2021-11-05 23:02:23 +01:00
void loadUserSpace()
{
struct ata_partition *part = ATAGetPartition(1);
2021-11-05 23:02:23 +01:00
if (part == NULL) {
printf("No user partition found\n");
return;
}
2022-08-07 16:20:01 +02:00
char *buf = malloc(FILE_MAX_SIZE * DISK_SECTOR_SIZE);
2021-11-05 23:02:23 +01:00
if (buf == NULL) {
printf("ENOMEM\n");
return;
}
if (ATAReadPartitionSector(part, 0, 1, buf)) {
printf("Fail to read from disk\n");
return;
}
int sectorToRead;
{
char size[FILE_HEADER_SIZE + 1];
memcpy(size, buf, FILE_HEADER_SIZE);
size[FILE_HEADER_SIZE] = '\0';
int sizeInt = atoi(size);
sectorToRead = DIV_ROUND_UP(sizeInt, DISK_SECTOR_SIZE) - 1;
}
if (sectorToRead > FILE_MAX_SIZE - 1 || sectorToRead <= 0) {
printf("Invalid file size: %d (sector)\n", sectorToRead);
return;
}
if (ATAReadPartitionSector(part, 1, sectorToRead,
buf + DISK_SECTOR_SIZE)) {
2021-11-05 23:02:23 +01:00
printf("Fail to read from disk\n");
return;
}
2024-02-08 00:07:12 +01:00
{
struct process *proc = processCreate("init");
struct uAddrSpace *as = processGetAddrSpace(proc);
threadChangeCurrentContext(processGetMMUContext(proc));
uaddr_t prog = loadElfProg(buf + FILE_HEADER_SIZE, proc);
if (prog == (uaddr_t)NULL) {
free(buf);
return;
}
// Alloc user stack
size_t stackSize = PAGE_SIZE * 2;
uaddr_t stack = PAGING_TOP_USER_ADDRESS - stackSize + 1;
zeroMmap(as, &stack, stackSize, PAGING_MEM_USER | PAGING_MEM_WRITE | PAGING_MEM_READ,
0);
threadCreateUser("init", proc, prog, 0, 0, stack + stackSize - 4);
processUnref(proc);
threadChangeCurrentContext(NULL);
2021-11-05 23:02:23 +01:00
}
free(buf);
}
2018-08-09 22:19:34 +02:00
// Multiboot information available here :
// https://www.gnu.org/software/grub/manual/multiboot/multiboot.html#kernel_002ec
// https://www.gnu.org/software/grub/manual/multiboot/html_node/Boot-information-format.html#Boot%20information%20format
void kmain(unsigned long magic, unsigned long addr)
2018-07-20 15:41:58 +02:00
{
2021-01-23 00:42:09 +01:00
unsigned long upperMemKB = 0;
2021-11-05 23:02:23 +01:00
int memMapAvailable = 0;
2021-01-23 00:42:09 +01:00
paddr_t lastUsedByMem;
2021-04-10 00:24:02 +02:00
paddr_t firstUsedByMem;
2021-01-22 22:59:45 +01:00
2018-11-08 22:08:27 +01:00
VGASetup(BLACK, GREEN);
2021-10-25 21:29:02 +02:00
printf("[Setup] Interruptions\n");
2018-07-20 15:41:58 +02:00
gdtSetup();
idtSetup();
irqSetup();
2020-04-27 23:08:36 +02:00
pitSetup(HZ);
2018-07-20 15:41:58 +02:00
2021-10-18 20:39:08 +02:00
// https://www.gnu.org/software/grub/manual/multiboot/multiboot.html#Boot-information-format
2019-04-15 23:19:14 +02:00
if (magic == MULTIBOOT_BOOTLOADER_MAGIC) { // Get loaded by Grub with mutliboot version 1
multiboot_info_t *mbi = (multiboot_info_t *)addr;
/* Are mem_* valid? */
2018-08-09 22:19:34 +02:00
if (CHECK_FLAG(mbi->flags, 0)) {
2021-10-25 21:29:02 +02:00
printf("mem_lower = %dKiB, mem_upper %dKiB\n", mbi->mem_lower, mbi->mem_upper);
2021-01-23 00:42:09 +01:00
upperMemKB = mbi->mem_upper;
}
/* Is boot_device valid? */
2018-08-09 22:19:34 +02:00
if (CHECK_FLAG(mbi->flags, 1)) {
2021-11-05 23:02:23 +01:00
int disk = mbi->boot_device >> 24 & 0xff;
2021-10-18 20:39:08 +02:00
int part1 = mbi->boot_device >> 16 & 0xff;
int part2 = mbi->boot_device >> 8 & 0xff;
int part3 = mbi->boot_device & 0xff;
2021-11-05 23:02:23 +01:00
printf("boot_device = 0x%x (0x0 for floppy 0x80 for disk) part %d %d %d\n", disk,
part1, part2, part3);
}
if (CHECK_FLAG(mbi->flags, 3)) {
2021-10-18 20:39:08 +02:00
if (mbi->mods_count > 0) {
multiboot_module_t *mod;
uint32_t i;
printf("mods_count = %d, mods_addr = 0x%x\n", (int)mbi->mods_count,
(int)mbi->mods_addr);
for (i = 0, mod = (multiboot_module_t *)mbi->mods_addr; i < mbi->mods_count;
i++, mod++)
printf(" mod_start = 0x%x, mod_end = 0x%x, cmdline = %s\n",
(unsigned)mod->mod_start, (unsigned)mod->mod_end,
(char *)mod->cmdline);
}
}
if (CHECK_FLAG(mbi->flags, 5)) {
stackSymbolSetup(mbi);
}
if (CHECK_FLAG(mbi->flags, 6)) {
2021-01-23 00:42:09 +01:00
memMapAvailable = 1;
}
2021-10-18 20:39:08 +02:00
if (CHECK_FLAG(mbi->flags, 9)) {
printf("Loaded by %s. ", (char *)mbi->boot_loader_name);
2021-10-18 20:39:08 +02:00
}
/* Is the command line passed? */
if (CHECK_FLAG(mbi->flags, 2)) {
printf("cmdline = %s\n", (char *)mbi->cmdline);
}
if (CHECK_FLAG(mbi->flags, 12)) {
2021-11-05 23:02:23 +01:00
printf("Re configure Framebuffer from 0x%llx size (%dx%d) pitch %d bpp %d\n",
mbi->framebuffer_addr, mbi->framebuffer_width, mbi->framebuffer_height,
mbi->framebuffer_pitch, mbi->framebuffer_bpp);
VGAConfigure(mbi->framebuffer_addr, mbi->framebuffer_width,
mbi->framebuffer_height);
2021-10-18 20:39:08 +02:00
}
}
2021-01-23 00:42:09 +01:00
if (upperMemKB == 0) {
2018-08-06 22:28:45 +02:00
printf("Cannot get upper phy mem bound. Using default value 32MB\n");
2021-01-23 00:42:09 +01:00
upperMemKB = 32 * 1024;
2018-08-06 18:41:45 +02:00
}
2018-11-08 22:08:27 +01:00
2021-10-25 21:29:02 +02:00
printf("[Setup] Mem\n");
2021-04-10 00:24:02 +02:00
memSetup(upperMemKB, &firstUsedByMem, &lastUsedByMem);
2021-01-23 00:42:09 +01:00
if (memMapAvailable) {
multiboot_info_t *mbi = (multiboot_info_t *)addr;
struct multiboot_mmap_entry *mmap = (struct multiboot_mmap_entry *)mbi->mmap_addr;
uint size = mbi->mmap_length / sizeof(struct multiboot_mmap_entry);
2021-01-25 14:00:06 +01:00
2021-01-23 00:42:09 +01:00
pr_devel("mmap buffer at 0x%x with %d entries\n", mbi->mmap_addr, size);
2021-01-25 14:00:06 +01:00
2021-01-23 00:42:09 +01:00
for (uint i = 0; i < size; i++) {
2021-01-23 21:21:13 +01:00
printf(" base_addr 0x%llx, length = 0x%llx, type = 0x%x\n", mmap[i].addr,
mmap[i].len, (uint32_t)mmap[i].type);
// Consider low memory taken (https://wiki.osdev.org/Detecting_Memory_(x86). For
// example by VGA
// Turns out linux and windows do the same !
// https://lore.kernel.org/lkml/MWHPR21MB159330952629D36EEDE706B3D7379@MWHPR21MB1593.namprd21.prod.outlook.com/
if (mmap[i].addr < 0x100000) {
2021-10-17 15:37:20 +02:00
printf(" -> skipping\n");
2021-04-10 00:24:02 +02:00
continue;
}
2021-01-23 21:51:00 +01:00
memAddBank(max(mmap[i].addr, (multiboot_uint64_t)lastUsedByMem),
mmap[i].addr + mmap[i].len, mmap[i].type == MULTIBOOT_MEMORY_AVAILABLE);
2021-01-23 00:42:09 +01:00
}
} else {
printf("Cannot get memory Mapping information, using default value\n");
memAddBank(lastUsedByMem, upperMemKB * 1024, 1);
}
printf("%ld pages used by kernel(0x%lx->0x%lx))",
2021-11-05 23:02:23 +01:00
(lastUsedByMem - firstUsedByMem) / PAGE_SIZE, firstUsedByMem, lastUsedByMem);
printf(" (%lu pages for MM)\n", (lastUsedByMem - (paddr_t)&__ld_kernel_end) / PAGE_SIZE);
2021-01-25 14:00:06 +01:00
2018-11-12 18:06:46 +01:00
#ifdef RUN_TEST
testPhymem();
#endif
2021-10-25 21:29:02 +02:00
printf("[Setup] Pagination\n");
2021-04-10 00:24:02 +02:00
pagingSetup(firstUsedByMem, lastUsedByMem);
2021-10-25 21:29:02 +02:00
VGAMap();
2018-08-06 18:41:45 +02:00
2018-11-08 22:08:27 +01:00
2021-10-25 21:29:02 +02:00
printf("[Setup] HW interrupts\n");
2018-07-20 15:41:58 +02:00
// Enabling the HW interrupts
2020-04-29 23:07:01 +02:00
exceptionSetup();
2018-07-20 15:41:58 +02:00
asm volatile("sti\n");
2018-11-08 22:08:27 +01:00
2021-10-25 21:29:02 +02:00
printf("[Setup] Serial link (115200)\n");
2018-11-08 22:08:27 +01:00
serialSetup(115200);
2021-01-25 14:00:06 +01:00
2021-10-25 21:29:02 +02:00
printf("[Setup] allocation system\n");
2021-10-28 00:32:35 +02:00
areaInit(firstUsedByMem, lastUsedByMem, _stack_bottom, _stack_top);
2021-10-17 15:37:20 +02:00
2021-11-06 00:13:40 +01:00
printf("[Setup] IRQ handlers\n");
keyboardSetup();
irqSetRoutineWrapped(IRQ_KEYBOARD, keyboard_do_irq);
2021-10-30 00:28:31 +02:00
mmuContextSetup();
2021-10-17 15:37:20 +02:00
cpu_context_subsystem_setup();
2021-01-25 14:00:06 +01:00
2021-10-25 21:29:02 +02:00
printf("[Setup] thread system\n");
2021-10-30 14:18:21 +02:00
threadSetup(_stack_bottom, (_stack_top - _stack_bottom + 1));
threadCreate("idle ", idleThread, NULL);
2021-10-30 15:43:40 +02:00
processSetup();
2021-11-03 23:54:36 +01:00
syscallSetup();
2021-01-25 14:00:06 +01:00
2020-04-23 00:49:09 +02:00
irqSetRoutine(IRQ_TIMER, pit_handler);
2021-10-03 23:19:00 +02:00
ATAInit();
2018-11-08 22:08:27 +01:00
#ifdef RUN_TEST
run_test();
#endif
2021-01-23 21:51:00 +01:00
printf("\nSystem init done: ");
{
uint free, used;
memGetStat(&free, &used);
printf("%dKB free %dKB Used\n", free * (PAGE_SIZE / 1024), used * (PAGE_SIZE / 1024));
}
2018-11-08 21:11:45 +01:00
2021-11-05 23:02:23 +01:00
loadUserSpace();
2020-04-23 23:40:16 +02:00
// There is no real caller behind this point
// So finish this by ourself
2021-10-30 14:18:21 +02:00
threadExit();
2018-07-20 15:41:58 +02:00
}