7d39906acc
This code uses the cr0 task switched bit to disable the FPU upon task switch, which allows the kernel to delay copying the registers until another task starts using them. Or better yet, if no other thread actually uses the registers, then it won't need to do any copying at all!
401 lines
12 KiB
C++
401 lines
12 KiB
C++
/*******************************************************************************
|
|
|
|
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
|
|
|
|
This file is part of Sortix.
|
|
|
|
Sortix is free software: you can redistribute it and/or modify it under the
|
|
terms of the GNU General Public License as published by the Free Software
|
|
Foundation, either version 3 of the License, or (at your option) any later
|
|
version.
|
|
|
|
Sortix 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 General Public License for more
|
|
details.
|
|
|
|
You should have received a copy of the GNU General Public License along with
|
|
Sortix. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
kernel.cpp
|
|
The main kernel initialization routine. Configures hardware and starts an
|
|
initial process from the init ramdisk, allowing a full operating system.
|
|
|
|
*******************************************************************************/
|
|
|
|
#include <sortix/kernel/platform.h>
|
|
#include <sortix/kernel/log.h>
|
|
#include <sortix/kernel/panic.h>
|
|
#include <sortix/kernel/video.h>
|
|
#include <sortix/kernel/kthread.h>
|
|
#include <sortix/kernel/refcount.h>
|
|
#include <sortix/kernel/textbuffer.h>
|
|
#include <sortix/kernel/pci.h>
|
|
#include <sortix/kernel/worker.h>
|
|
#include <libmaxsi/error.h>
|
|
#include <libmaxsi/memory.h>
|
|
#include <libmaxsi/string.h>
|
|
#include <libmaxsi/format.h>
|
|
#include <sortix/mman.h>
|
|
#include "kernelinfo.h"
|
|
#include "x86-family/gdt.h"
|
|
#include "x86-family/float.h"
|
|
#include "time.h"
|
|
#include "keyboard.h"
|
|
#include "multiboot.h"
|
|
#include <sortix/kernel/memorymanagement.h>
|
|
#include "thread.h"
|
|
#include "process.h"
|
|
#include "scheduler.h"
|
|
#include "signal.h"
|
|
#include "syscall.h"
|
|
#include "ata.h"
|
|
#include "com.h"
|
|
#include "uart.h"
|
|
#include "vgatextbuffer.h"
|
|
#include "terminal.h"
|
|
#include "serialterminal.h"
|
|
#include "textterminal.h"
|
|
#include "elf.h"
|
|
#include "initrd.h"
|
|
#include "vga.h"
|
|
#include "bga.h"
|
|
#include "sound.h"
|
|
#include "io.h"
|
|
#include "pipe.h"
|
|
#include "filesystem.h"
|
|
#include "mount.h"
|
|
#include "directory.h"
|
|
#include "interrupt.h"
|
|
#include "fs/devfs.h"
|
|
|
|
using namespace Maxsi;
|
|
|
|
// Keep the stack size aligned with $CPU/base.s
|
|
const size_t STACK_SIZE = 64*1024;
|
|
extern "C" { size_t stack[STACK_SIZE / sizeof(size_t)] = {0}; }
|
|
|
|
namespace Sortix {
|
|
|
|
void DoMaxsiLogo()
|
|
{
|
|
Log::Print("\e[37;41m\e[2J"); // Make the background color red.
|
|
Log::Print(" _ \n");
|
|
Log::Print(" / \\ \n");
|
|
Log::Print(" /\\ /\\ / \\ \n");
|
|
Log::Print(" / \\ / \\ | | \n");
|
|
Log::Print(" / \\/ \\ | | \n");
|
|
Log::Print(" | O O \\_______________________ / | \n");
|
|
Log::Print(" | | \n");
|
|
Log::Print(" | \\_______/ / \n");
|
|
Log::Print(" \\ / \n");
|
|
Log::Print(" ------ --------------- ---/ \n");
|
|
Log::Print(" / \\ / \\ \n");
|
|
Log::Print(" / \\ / \\ \n");
|
|
Log::Print(" / \\ / \\ \n");
|
|
Log::Print(" /_____________\\ /____________\\ \n");
|
|
Log::Print(" \n");
|
|
}
|
|
|
|
void DoWelcome()
|
|
{
|
|
DoMaxsiLogo();
|
|
Log::Print(" BOOTING OPERATING SYSTEM... ");
|
|
}
|
|
|
|
// Forward declarations.
|
|
static void BootThread(void* user);
|
|
static void InitThread(void* user);
|
|
static void SystemIdleThread(void* user);
|
|
|
|
static size_t PrintToTextTerminal(void* user, const char* str, size_t len)
|
|
{
|
|
return ((TextTerminal*) user)->Print(str, len);
|
|
}
|
|
|
|
static size_t TextTermWidth(void* user)
|
|
{
|
|
return ((TextTerminal*) user)->Width();
|
|
}
|
|
|
|
static size_t TextTermHeight(void* user)
|
|
{
|
|
return ((TextTerminal*) user)->Height();
|
|
}
|
|
|
|
extern "C" void KernelInit(unsigned long magic, multiboot_info_t* bootinfo)
|
|
{
|
|
// Initialize system calls.
|
|
Syscall::Init();
|
|
|
|
// Detect and initialize any serial COM ports in the system.
|
|
COM::EarlyInit();
|
|
|
|
// Setup a text buffer handle for use by the text terminal.
|
|
uint16_t* const VGAFB = (uint16_t*) 0xB8000;
|
|
const size_t VGA_WIDTH = 80;
|
|
const size_t VGA_HEIGHT = 25;
|
|
static uint16_t vga_attr_buffer[VGA_WIDTH*VGA_HEIGHT];
|
|
VGATextBuffer textbuf(VGAFB, vga_attr_buffer, VGA_WIDTH, VGA_HEIGHT);
|
|
TextBufferHandle textbufhandle(NULL, false, &textbuf, false);
|
|
|
|
// Setup a text terminal instance.
|
|
TextTerminal textterm(&textbufhandle);
|
|
|
|
// Register the text terminal as the kernel log and initialize it.
|
|
Log::Init(PrintToTextTerminal, TextTermWidth, TextTermHeight, &textterm);
|
|
|
|
// Display the boot welcome screen.
|
|
DoWelcome();
|
|
|
|
if ( !bootinfo )
|
|
{
|
|
Panic("The bootinfo structure was NULL. Are your bootloader "
|
|
"multiboot compliant?");
|
|
}
|
|
|
|
addr_t initrd = NULL;
|
|
size_t initrdsize = 0;
|
|
|
|
uint32_t* modules = (uint32_t*) (addr_t) bootinfo->mods_addr;
|
|
for ( uint32_t i = 0; i < bootinfo->mods_count; i++ )
|
|
{
|
|
initrdsize = modules[2*i+1] - modules[2*i+0];
|
|
initrd = (addr_t) modules[2*i+0];
|
|
break;
|
|
}
|
|
|
|
if ( !initrd ) { PanicF("No init ramdisk provided"); }
|
|
|
|
Memory::RegisterInitRDSize(initrdsize);
|
|
|
|
// Initialize paging and virtual memory.
|
|
Memory::Init(bootinfo);
|
|
|
|
// Initialize the GDT and TSS structures.
|
|
GDT::Init();
|
|
|
|
// Initialize the interrupt handler table and enable interrupts.
|
|
Interrupt::Init();
|
|
|
|
// Initialize the kernel heap.
|
|
Maxsi::Memory::Init();
|
|
|
|
// Initialize the interrupt worker.
|
|
Interrupt::InitWorker();
|
|
|
|
// Initialize the list of kernel devices.
|
|
DeviceFS::Init();
|
|
|
|
// Initialize the COM ports.
|
|
COM::Init();
|
|
|
|
// Initialize the keyboard.
|
|
Keyboard::Init();
|
|
|
|
// Initialize the terminal.
|
|
Terminal::Init();
|
|
|
|
// Initialize the VGA driver.
|
|
VGA::Init();
|
|
|
|
// Initialize the sound driver.
|
|
Sound::Init();
|
|
|
|
// Initialize the process system.
|
|
Process::Init();
|
|
|
|
// Initialize the thread system.
|
|
Thread::Init();
|
|
|
|
// Initialize the IO system.
|
|
IO::Init();
|
|
|
|
// Initialize the pipe system.
|
|
Pipe::Init();
|
|
|
|
// Initialize the filesystem system.
|
|
FileSystem::Init();
|
|
|
|
// Initialize the directory system.
|
|
Directory::Init();
|
|
|
|
// Initialize the mount system.
|
|
Mount::Init();
|
|
|
|
// Initialize the scheduler.
|
|
Scheduler::Init();
|
|
|
|
// Initialize Unix Signals.
|
|
Signal::Init();
|
|
|
|
// Initialize the worker thread data structures.
|
|
Worker::Init();
|
|
|
|
// Initialize the kernel information query syscall.
|
|
Info::Init();
|
|
|
|
// Set up the initial ram disk.
|
|
InitRD::Init(initrd, initrdsize);
|
|
|
|
// Initialize the Video Driver framework.
|
|
Video::Init(&textbufhandle);
|
|
|
|
// Search for PCI devices and load their drivers.
|
|
PCI::Init();
|
|
|
|
// Initialize ATA devices.
|
|
ATA::Init();
|
|
|
|
// Initialize the BGA driver.
|
|
BGA::Init();
|
|
|
|
// Now that the base system has been loaded, it's time to go threaded. First
|
|
// we create an object that represents this thread.
|
|
Process* system = new Process;
|
|
if ( !system ) { Panic("Could not allocate the system process"); }
|
|
addr_t systemaddrspace = Memory::GetAddressSpace();
|
|
system->addrspace = systemaddrspace;
|
|
|
|
// We construct this thread manually for bootstrap reasons. We wish to
|
|
// create a kernel thread that is the current thread and isn't put into the
|
|
// scheduler's set of runnable threads, but rather run whenever there is
|
|
// _nothing_ else to run on this CPU.
|
|
Thread* idlethread = new Thread;
|
|
idlethread->process = system;
|
|
idlethread->kernelstackpos = (addr_t) stack;
|
|
idlethread->kernelstacksize = STACK_SIZE;
|
|
idlethread->kernelstackmalloced = false;
|
|
idlethread->fpuinitialized = true;
|
|
system->firstthread = idlethread;
|
|
Scheduler::SetIdleThread(idlethread);
|
|
|
|
// Let's create a regular kernel thread that can decide what happens next.
|
|
// Note that we don't do the work here: should it block, then there is
|
|
// nothing to run. Therefore we must become the system idle thread.
|
|
RunKernelThread(BootThread, NULL);
|
|
|
|
// Set up such that floating point registers are lazily switched.
|
|
Float::Init();
|
|
|
|
// The time driver will run the scheduler on the next timer interrupt.
|
|
Time::Init();
|
|
|
|
// Become the system idle thread.
|
|
SystemIdleThread(NULL);
|
|
}
|
|
|
|
static void SystemIdleThread(void* /*user*/)
|
|
{
|
|
// Alright, we are now the system idle thread. If there is nothing to do,
|
|
// then we are run. Note that we must never do any real work here.
|
|
while(true);
|
|
}
|
|
|
|
static void BootThread(void* /*user*/)
|
|
{
|
|
// Hello, threaded world! You can now regard the kernel as a multi-threaded
|
|
// process with super-root access to the system. Before we boot the full
|
|
// system we need to start some worker threads.
|
|
|
|
// Let's create the interrupt worker thread that executes additional work
|
|
// requested by interrupt handlers, where such work isn't safe.
|
|
Thread* interruptworker = RunKernelThread(Interrupt::WorkerThread, NULL);
|
|
if ( !interruptworker )
|
|
Panic("Could not create interrupt worker");
|
|
|
|
// Create a general purpose worker thread.
|
|
Thread* workerthread = RunKernelThread(Worker::Thread, NULL);
|
|
if ( !workerthread )
|
|
Panic("Unable to create general purpose worker thread");
|
|
|
|
// Finally, let's transfer control to a new kernel process that will
|
|
// eventually run user-space code known as the operating system.
|
|
addr_t initaddrspace = Memory::Fork();
|
|
if ( !initaddrspace ) { Panic("Could not create init's address space"); }
|
|
|
|
Process* init = new Process;
|
|
if ( !init ) { Panic("Could not allocate init process"); }
|
|
|
|
CurrentProcess()->AddChildProcess(init);
|
|
|
|
init->addrspace = initaddrspace;
|
|
Scheduler::SetInitProcess(init);
|
|
|
|
Thread* initthread = RunKernelThread(init, InitThread, NULL);
|
|
if ( !initthread ) { Panic("Coul not create init thread"); }
|
|
|
|
// Wait until init init is done and then shut down the computer.
|
|
int status;
|
|
pid_t pid = CurrentProcess()->Wait(init->pid, &status, 0);
|
|
if ( pid != init->pid )
|
|
PanicF("Waiting for init to exit returned %i (errno=%i)", pid, errno);
|
|
|
|
switch ( status )
|
|
{
|
|
case 0: CPU::ShutDown();
|
|
case 1: CPU::Reboot();
|
|
default:
|
|
PanicF("Init returned with unexpected return code %i", status);
|
|
}
|
|
}
|
|
|
|
static void InitThread(void* /*user*/)
|
|
{
|
|
// We are the init process's first thread. Let's load the init program from
|
|
// the init ramdisk and transfer execution to it. We will then become a
|
|
// regular user-space program with root permissions.
|
|
|
|
Thread* thread = CurrentThread();
|
|
Process* process = CurrentProcess();
|
|
|
|
uint32_t inode = InitRD::Traverse(InitRD::Root(), "init");
|
|
if ( !inode ) { Panic("InitRD did not contain an 'init' program."); }
|
|
|
|
size_t programsize;
|
|
uint8_t* program = InitRD::Open(inode, &programsize);
|
|
if ( !program ) { Panic("InitRD did not contain an 'init' program."); }
|
|
|
|
const size_t DEFAULT_STACK_SIZE = 64UL * 1024UL;
|
|
|
|
size_t stacksize = 0;
|
|
if ( !stacksize ) { stacksize = DEFAULT_STACK_SIZE; }
|
|
|
|
addr_t stackpos = process->AllocVirtualAddr(stacksize);
|
|
if ( !stackpos ) { Panic("Could not allocate init stack space"); }
|
|
|
|
int prot = PROT_FORK | PROT_READ | PROT_WRITE | PROT_KREAD | PROT_KWRITE;
|
|
if ( !Memory::MapRange(stackpos, stacksize, prot) )
|
|
{
|
|
Panic("Could not allocate init stack memory");
|
|
}
|
|
|
|
thread->stackpos = stackpos;
|
|
thread->stacksize = stacksize;
|
|
|
|
int argc = 1;
|
|
const char* argv[] = { "init", NULL };
|
|
#if defined(PLATFORM_X86)
|
|
const char* cputype = "cputype=i486-pc-sortix";
|
|
#elif defined(PLATFORM_X64)
|
|
const char* cputype = "cputype=x86_64-pc-sortix";
|
|
#else
|
|
#warning No cputype environmental variable provided here.
|
|
const char* cputype = "cputype=unknown-pc-sortix";
|
|
#endif
|
|
int envc = 1;
|
|
const char* envp[] = { cputype, NULL };
|
|
CPU::InterruptRegisters regs;
|
|
|
|
if ( process->Execute("init", program, programsize, argc, argv, envc, envp,
|
|
®s) )
|
|
{
|
|
Panic("Unable to execute init program");
|
|
}
|
|
|
|
// Now become the init process and the operation system shall run.
|
|
CPU::LoadRegisters(®s);
|
|
}
|
|
|
|
} // namespace Sortix
|