mirror of
https://github.com/LadybirdBrowser/ladybird.git
synced 2025-04-25 05:55:13 +00:00
e362b56b4f
The kernel and its static data structures are no longer identity-mapped in the bottom 8MB of the address space, but instead move above 3GB. The first 8MB above 3GB are pseudo-identity-mapped to the bottom 8MB of the physical address space. But things don't have to stay this way! Thanks to Jesse who made an earlier attempt at this, it was really easy to get device drivers working once the page tables were in place! :^) Fixes #734.
408 lines
12 KiB
C++
408 lines
12 KiB
C++
#include "Devices/PATADiskDevice.h"
|
|
#include "KSyms.h"
|
|
#include "Process.h"
|
|
#include "RTC.h"
|
|
#include "Scheduler.h"
|
|
#include "kstdio.h"
|
|
#include <AK/Types.h>
|
|
#include <Kernel/ACPI/ACPIDynamicParser.h>
|
|
#include <Kernel/ACPI/ACPIStaticParser.h>
|
|
#include <Kernel/ACPI/DMIDecoder.h>
|
|
#include <Kernel/Arch/i386/APIC.h>
|
|
#include <Kernel/Arch/i386/CPU.h>
|
|
#include <Kernel/Arch/i386/PIC.h>
|
|
#include <Kernel/Arch/i386/PIT.h>
|
|
#include <Kernel/CMOS.h>
|
|
#include <Kernel/Devices/BXVGADevice.h>
|
|
#include <Kernel/Devices/DebugLogDevice.h>
|
|
#include <Kernel/Devices/DiskPartition.h>
|
|
#include <Kernel/Devices/FloppyDiskDevice.h>
|
|
#include <Kernel/Devices/FullDevice.h>
|
|
#include <Kernel/Devices/GPTPartitionTable.h>
|
|
#include <Kernel/Devices/KeyboardDevice.h>
|
|
#include <Kernel/Devices/MBRPartitionTable.h>
|
|
#include <Kernel/Devices/MBVGADevice.h>
|
|
#include <Kernel/Devices/NullDevice.h>
|
|
#include <Kernel/Devices/PATAChannel.h>
|
|
#include <Kernel/Devices/PS2MouseDevice.h>
|
|
#include <Kernel/Devices/RandomDevice.h>
|
|
#include <Kernel/Devices/SB16.h>
|
|
#include <Kernel/Devices/SerialDevice.h>
|
|
#include <Kernel/Devices/ZeroDevice.h>
|
|
#include <Kernel/FileSystem/Ext2FileSystem.h>
|
|
#include <Kernel/FileSystem/VirtualFileSystem.h>
|
|
#include <Kernel/Heap/SlabAllocator.h>
|
|
#include <Kernel/Heap/kmalloc.h>
|
|
#include <Kernel/KParams.h>
|
|
#include <Kernel/Multiboot.h>
|
|
#include <Kernel/Net/E1000NetworkAdapter.h>
|
|
#include <Kernel/Net/LoopbackAdapter.h>
|
|
#include <Kernel/Net/NetworkTask.h>
|
|
#include <Kernel/Net/RTL8139NetworkAdapter.h>
|
|
#include <Kernel/PCI/Access.h>
|
|
#include <Kernel/PCI/Initializer.h>
|
|
#include <Kernel/Random.h>
|
|
#include <Kernel/TTY/PTYMultiplexer.h>
|
|
#include <Kernel/TTY/VirtualConsole.h>
|
|
#include <Kernel/VM/MemoryManager.h>
|
|
|
|
VirtualConsole* tty0;
|
|
VirtualConsole* tty1;
|
|
KeyboardDevice* keyboard;
|
|
PS2MouseDevice* ps2mouse;
|
|
SB16* sb16;
|
|
DebugLogDevice* dev_debuglog;
|
|
NullDevice* dev_null;
|
|
SerialDevice* ttyS0;
|
|
SerialDevice* ttyS1;
|
|
SerialDevice* ttyS2;
|
|
SerialDevice* ttyS3;
|
|
VFS* vfs;
|
|
|
|
[[noreturn]] static void init_stage2()
|
|
{
|
|
Syscall::initialize();
|
|
|
|
auto dev_zero = make<ZeroDevice>();
|
|
auto dev_full = make<FullDevice>();
|
|
auto dev_random = make<RandomDevice>();
|
|
auto dev_ptmx = make<PTYMultiplexer>();
|
|
|
|
bool text_debug = KParams::the().has("text_debug");
|
|
bool force_pio = KParams::the().has("force_pio");
|
|
|
|
auto root = KParams::the().get("root");
|
|
if (root.is_empty()) {
|
|
root = "/dev/hda";
|
|
}
|
|
|
|
bool dmi_unreliable = KParams::the().has("dmi_unreliable");
|
|
if (dmi_unreliable) {
|
|
DMIDecoder::initialize_untrusted();
|
|
} else {
|
|
DMIDecoder::initialize();
|
|
}
|
|
|
|
if (!root.starts_with("/dev/hda")) {
|
|
kprintf("init_stage2: root filesystem must be on the first IDE hard drive (/dev/hda)\n");
|
|
hang();
|
|
}
|
|
|
|
auto pata0 = PATAChannel::create(PATAChannel::ChannelType::Primary, force_pio);
|
|
NonnullRefPtr<DiskDevice> root_dev = *pata0->master_device();
|
|
|
|
root = root.substring(strlen("/dev/hda"), root.length() - strlen("/dev/hda"));
|
|
|
|
if (root.length()) {
|
|
bool ok;
|
|
unsigned partition_number = root.to_uint(ok);
|
|
|
|
if (!ok) {
|
|
kprintf("init_stage2: couldn't parse partition number from root kernel parameter\n");
|
|
hang();
|
|
}
|
|
|
|
if (partition_number < 1 || partition_number > 4) {
|
|
kprintf("init_stage2: invalid partition number %d; expected 1 to 4\n", partition_number);
|
|
hang();
|
|
}
|
|
|
|
MBRPartitionTable mbr(root_dev);
|
|
|
|
if (!mbr.initialize()) {
|
|
kprintf("init_stage2: couldn't read MBR from disk\n");
|
|
hang();
|
|
}
|
|
|
|
if (mbr.is_protective_mbr()) {
|
|
dbgprintf("GPT Partitioned Storage Detected!\n");
|
|
GPTPartitionTable gpt(root_dev);
|
|
if (!gpt.initialize()) {
|
|
kprintf("init_stage2: couldn't read GPT from disk\n");
|
|
hang();
|
|
}
|
|
auto partition = gpt.partition(partition_number);
|
|
if (!partition) {
|
|
kprintf("init_stage2: couldn't get partition %d\n", partition_number);
|
|
hang();
|
|
}
|
|
root_dev = *partition;
|
|
} else {
|
|
dbgprintf("MBR Partitioned Storage Detected!\n");
|
|
auto partition = mbr.partition(partition_number);
|
|
if (!partition) {
|
|
kprintf("init_stage2: couldn't get partition %d\n", partition_number);
|
|
hang();
|
|
}
|
|
root_dev = *partition;
|
|
}
|
|
}
|
|
|
|
auto e2fs = Ext2FS::create(root_dev);
|
|
if (!e2fs->initialize()) {
|
|
kprintf("init_stage2: couldn't open root filesystem\n");
|
|
hang();
|
|
}
|
|
|
|
if (!vfs->mount_root(e2fs)) {
|
|
kprintf("VFS::mount_root failed\n");
|
|
hang();
|
|
}
|
|
|
|
current->process().set_root_directory(vfs->root_custody());
|
|
|
|
dbgprintf("Load ksyms\n");
|
|
load_ksyms();
|
|
dbgprintf("Loaded ksyms\n");
|
|
|
|
// Now, detect whether or not there are actually any floppy disks attached to the system
|
|
u8 detect = CMOS::read(0x10);
|
|
RefPtr<FloppyDiskDevice> fd0;
|
|
RefPtr<FloppyDiskDevice> fd1;
|
|
if ((detect >> 4) & 0x4) {
|
|
fd0 = FloppyDiskDevice::create(FloppyDiskDevice::DriveType::Master);
|
|
kprintf("fd0 is 1.44MB floppy drive\n");
|
|
} else {
|
|
kprintf("fd0 type unsupported! Type == 0x%x\n", detect >> 4);
|
|
}
|
|
|
|
if (detect & 0x0f) {
|
|
fd1 = FloppyDiskDevice::create(FloppyDiskDevice::DriveType::Slave);
|
|
kprintf("fd1 is 1.44MB floppy drive");
|
|
} else {
|
|
kprintf("fd1 type unsupported! Type == 0x%x\n", detect & 0x0f);
|
|
}
|
|
|
|
int error;
|
|
|
|
// SystemServer will start WindowServer, which will be doing graphics.
|
|
// From this point on we don't want to touch the VGA text terminal or
|
|
// accept keyboard input.
|
|
if (text_debug) {
|
|
tty0->set_graphical(false);
|
|
Thread* thread = nullptr;
|
|
Process::create_user_process(thread, "/bin/Shell", (uid_t)0, (gid_t)0, (pid_t)0, error, {}, {}, tty0);
|
|
if (error != 0) {
|
|
kprintf("init_stage2: error spawning Shell: %d\n", error);
|
|
hang();
|
|
}
|
|
thread->set_priority(THREAD_PRIORITY_HIGH);
|
|
} else {
|
|
tty0->set_graphical(true);
|
|
Thread* thread = nullptr;
|
|
Process::create_user_process(thread, "/bin/SystemServer", (uid_t)0, (gid_t)0, (pid_t)0, error, {}, {}, tty0);
|
|
if (error != 0) {
|
|
kprintf("init_stage2: error spawning SystemServer: %d\n", error);
|
|
hang();
|
|
}
|
|
thread->set_priority(THREAD_PRIORITY_HIGH);
|
|
}
|
|
{
|
|
Thread* thread = nullptr;
|
|
Process::create_kernel_process(thread, "NetworkTask", NetworkTask_main);
|
|
}
|
|
|
|
current->process().sys$exit(0);
|
|
ASSERT_NOT_REACHED();
|
|
}
|
|
|
|
extern "C" {
|
|
multiboot_info_t* multiboot_info_ptr;
|
|
}
|
|
|
|
typedef void (*ctor_func_t)();
|
|
|
|
// Defined in the linker script
|
|
extern ctor_func_t start_ctors;
|
|
extern ctor_func_t end_ctors;
|
|
|
|
// Define some Itanium C++ ABI methods to stop the linker from complaining
|
|
// If we actually call these something has gone horribly wrong
|
|
void* __dso_handle __attribute__((visibility("hidden")));
|
|
|
|
extern "C" int __cxa_atexit(void (*)(void*), void*, void*)
|
|
{
|
|
ASSERT_NOT_REACHED();
|
|
return 0;
|
|
}
|
|
|
|
extern u32 __stack_chk_guard;
|
|
u32 __stack_chk_guard;
|
|
|
|
extern "C" [[noreturn]] void init()
|
|
{
|
|
// this is only used one time, directly below here. we can't use this part
|
|
// of libc at this point in the boot process, or we'd just pull strstr in
|
|
// from <string.h>.
|
|
auto bad_prefix_check = [](const char* str, const char* search) -> bool {
|
|
while (*search)
|
|
if (*search++ != *str++)
|
|
return false;
|
|
|
|
return true;
|
|
};
|
|
|
|
// serial_debug will output all the kprintf and dbgprintf data to COM1 at
|
|
// 8-N-1 57600 baud. this is particularly useful for debugging the boot
|
|
// process on live hardware.
|
|
//
|
|
// note: it must be the first option in the boot cmdline.
|
|
u32 cmdline = low_physical_to_virtual(multiboot_info_ptr->cmdline);
|
|
if (cmdline && bad_prefix_check(reinterpret_cast<const char*>(cmdline), "serial_debug"))
|
|
set_serial_debug(true);
|
|
|
|
detect_cpu_features();
|
|
|
|
kmalloc_init();
|
|
slab_alloc_init();
|
|
|
|
// must come after kmalloc_init because we use AK_MAKE_ETERNAL in KParams
|
|
new KParams(String(reinterpret_cast<const char*>(cmdline)));
|
|
|
|
bool text_debug = KParams::the().has("text_debug");
|
|
bool complete_acpi_disable = KParams::the().has("noacpi");
|
|
bool dynamic_acpi_disable = KParams::the().has("noacpi_aml");
|
|
bool pci_mmio_disable = KParams::the().has("nopci_mmio");
|
|
|
|
complete_acpi_disable = true;
|
|
|
|
MemoryManager::initialize();
|
|
|
|
if (complete_acpi_disable) {
|
|
ACPIParser::initialize_limited();
|
|
} else {
|
|
if (!dynamic_acpi_disable) {
|
|
ACPIDynamicParser::initialize_without_rsdp();
|
|
} else {
|
|
ACPIStaticParser::initialize_without_rsdp();
|
|
}
|
|
}
|
|
|
|
vfs = new VFS;
|
|
dev_debuglog = new DebugLogDevice;
|
|
|
|
auto console = make<Console>();
|
|
|
|
kprintf("Starting SerenityOS...\n");
|
|
|
|
if (g_cpu_supports_sse) {
|
|
sse_init();
|
|
kprintf("x86: SSE support enabled\n");
|
|
}
|
|
|
|
if (g_cpu_supports_umip) {
|
|
asm volatile(
|
|
"mov %cr4, %eax\n"
|
|
"orl $0x800, %eax\n"
|
|
"mov %eax, %cr4\n");
|
|
kprintf("x86: UMIP support enabled\n");
|
|
}
|
|
|
|
if (g_cpu_supports_tsc) {
|
|
asm volatile(
|
|
"mov %cr4, %eax\n"
|
|
"orl $0x4, %eax\n"
|
|
"mov %eax, %cr4\n");
|
|
kprintf("x86: RDTSC support restricted\n");
|
|
}
|
|
|
|
if (g_cpu_supports_rdrand) {
|
|
kprintf("x86: Using RDRAND for good randomness\n");
|
|
} else {
|
|
kprintf("x86: No RDRAND support detected. Randomness will be shitty\n");
|
|
}
|
|
|
|
__stack_chk_guard = get_good_random<u32>();
|
|
|
|
RTC::initialize();
|
|
PIC::initialize();
|
|
gdt_init();
|
|
idt_init();
|
|
|
|
// call global constructors after gtd and itd init
|
|
for (ctor_func_t* ctor = &start_ctors; ctor < &end_ctors; ctor++)
|
|
(*ctor)();
|
|
|
|
keyboard = new KeyboardDevice;
|
|
ps2mouse = new PS2MouseDevice;
|
|
sb16 = new SB16;
|
|
dev_null = new NullDevice;
|
|
if (!get_serial_debug())
|
|
ttyS0 = new SerialDevice(SERIAL_COM1_ADDR, 64);
|
|
ttyS1 = new SerialDevice(SERIAL_COM2_ADDR, 65);
|
|
ttyS2 = new SerialDevice(SERIAL_COM3_ADDR, 66);
|
|
ttyS3 = new SerialDevice(SERIAL_COM4_ADDR, 67);
|
|
|
|
VirtualConsole::initialize();
|
|
tty0 = new VirtualConsole(0, VirtualConsole::AdoptCurrentVGABuffer);
|
|
tty1 = new VirtualConsole(1);
|
|
VirtualConsole::switch_to(0);
|
|
|
|
// Sample test to see if the ACPI parser is working...
|
|
kprintf("ACPI: HPET table @ P 0x%x\n", ACPIParser::the().find_table("HPET"));
|
|
|
|
PCI::Initializer::the().test_and_initialize(pci_mmio_disable);
|
|
PCI::Initializer::the().dismiss();
|
|
|
|
if (APIC::init())
|
|
APIC::enable(0);
|
|
|
|
PIT::initialize();
|
|
|
|
PCI::enumerate_all([](const PCI::Address& address, PCI::ID id) {
|
|
kprintf("PCI: device @ %w:%b:%b.%d [%w:%w]\n",
|
|
address.seg(),
|
|
address.bus(),
|
|
address.slot(),
|
|
address.function(),
|
|
id.vendor_id,
|
|
id.device_id);
|
|
});
|
|
|
|
if (text_debug) {
|
|
dbgprintf("Text mode enabled\n");
|
|
} else {
|
|
if (multiboot_info_ptr->framebuffer_type == 1 || multiboot_info_ptr->framebuffer_type == 2) {
|
|
new MBVGADevice(
|
|
PhysicalAddress((u32)(multiboot_info_ptr->framebuffer_addr)),
|
|
multiboot_info_ptr->framebuffer_pitch,
|
|
multiboot_info_ptr->framebuffer_width,
|
|
multiboot_info_ptr->framebuffer_height);
|
|
} else {
|
|
new BXVGADevice;
|
|
}
|
|
}
|
|
|
|
LoopbackAdapter::the();
|
|
auto e1000 = E1000NetworkAdapter::autodetect();
|
|
auto rtl8139 = RTL8139NetworkAdapter::autodetect();
|
|
|
|
Process::initialize();
|
|
Thread::initialize();
|
|
|
|
Thread* init_stage2_thread = nullptr;
|
|
Process::create_kernel_process(init_stage2_thread, "init_stage2", init_stage2);
|
|
|
|
Thread* syncd_thread = nullptr;
|
|
Process::create_kernel_process(syncd_thread, "syncd", [] {
|
|
for (;;) {
|
|
VFS::the().sync();
|
|
current->sleep(1 * TICKS_PER_SECOND);
|
|
}
|
|
});
|
|
|
|
Process::create_kernel_process(g_finalizer, "Finalizer", [] {
|
|
current->set_priority(THREAD_PRIORITY_LOW);
|
|
for (;;) {
|
|
current->wait_on(*g_finalizer_wait_queue);
|
|
Thread::finalize_dying_threads();
|
|
}
|
|
});
|
|
|
|
Scheduler::pick_next();
|
|
|
|
sti();
|
|
|
|
Scheduler::idle_loop();
|
|
ASSERT_NOT_REACHED();
|
|
}
|