status_t register_boot_file_system(BootVolume& bootVolume) { Directory* rootDirectory = bootVolume.RootDirectory(); gRoot->AddLink("boot", rootDirectory); Partition *partition; status_t status = gRoot->GetPartitionFor(rootDirectory, &partition); if (status != B_OK) { dprintf("register_boot_file_system(): could not locate boot volume in " "root!\n"); return status; } gBootVolume.SetInt64(BOOT_VOLUME_PARTITION_OFFSET, partition->offset); if (bootVolume.IsPackaged()) { gBootVolume.SetBool(BOOT_VOLUME_PACKAGED, true); PackageVolumeState* state = bootVolume.GetPackageVolumeState(); if (state->Name() != NULL) gBootVolume.AddString(BOOT_VOLUME_PACKAGES_STATE, state->Name()); } Node *device = get_node_from(partition->FD()); if (device == NULL) { dprintf("register_boot_file_system(): could not get boot device!\n"); return B_ERROR; } return platform_register_boot_device(device); }
status_t load_modules(stage2_args* args, BootVolume& volume) { int32 failed = 0; // ToDo: this should be mostly replaced by a hardware oriented detection mechanism int32 i = 0; for (; sAddonPaths[i]; i++) { char path[B_FILE_NAME_LENGTH]; snprintf(path, sizeof(path), "%s/boot", sAddonPaths[i]); if (load_modules_from(volume, path) != B_OK) failed++; } if (failed == i) { // couldn't load any boot modules // fall back to load all modules (currently needed by the boot floppy) const char *paths[] = { "bus_managers", "busses/ide", "busses/scsi", "generic", "partitioning_systems", "drivers/bin", NULL}; for (int32 i = 0; paths[i]; i++) { char path[B_FILE_NAME_LENGTH]; snprintf(path, sizeof(path), "%s/%s", sAddonPaths[0], paths[i]); load_modules_from(volume, path); } } // and now load all partitioning and file system modules // needed to identify the boot volume if (!gBootVolume.GetBool(BOOT_VOLUME_BOOTED_FROM_IMAGE, false)) { // iterate over the mounted volumes and load their file system Partition *partition; if (gRoot->GetPartitionFor(volume.RootDirectory(), &partition) == B_OK) { while (partition != NULL) { load_module(volume, partition->ModuleName()); partition = partition->Parent(); } } } else { // The boot image should only contain the file system // needed to boot the system, so we just load it. // ToDo: this is separate from the fall back from above // as this piece will survive a more intelligent module // loading approach... char path[B_FILE_NAME_LENGTH]; snprintf(path, sizeof(path), "%s/%s", sAddonPaths[0], "file_systems"); load_modules_from(volume, path); } return B_OK; }
static int open_maybe_packaged(BootVolume& volume, const char* path, int openMode) { if (strncmp(path, kSystemDirectoryPrefix, strlen(kSystemDirectoryPrefix)) == 0) { path += strlen(kSystemDirectoryPrefix); return open_from(volume.SystemDirectory(), path, openMode); } return open_from(volume.RootDirectory(), path, openMode); }
extern "C" int main(stage2_args *args) { TRACE(("boot(): enter\n")); if (heap_init(args) < B_OK) panic("Could not initialize heap!\n"); TRACE(("boot(): heap initialized...\n")); // set debug syslog default #if KDEBUG_ENABLE_DEBUG_SYSLOG gKernelArgs.keep_debug_output_buffer = true; #endif add_stage2_driver_settings(args); platform_init_video(); // the main platform dependent initialisation // has already taken place at this point. if (vfs_init(args) < B_OK) panic("Could not initialize VFS!\n"); dprintf("Welcome to the Haiku boot loader!\n"); bool mountedAllVolumes = false; BootVolume bootVolume; PathBlacklist pathBlacklist; if (get_boot_file_system(args, bootVolume) != B_OK || (platform_boot_options() & BOOT_OPTION_MENU) != 0) { if (!bootVolume.IsValid()) puts("\tno boot path found, scan for all partitions...\n"); if (mount_file_systems(args) < B_OK) { // That's unfortunate, but we still give the user the possibility // to insert a CD-ROM or just rescan the available devices puts("Could not locate any supported boot devices!\n"); } // ToDo: check if there is only one bootable volume! mountedAllVolumes = true; if (user_menu(bootVolume, pathBlacklist) < B_OK) { // user requested to quit the loader goto out; } } if (bootVolume.IsValid()) { // we got a volume to boot from! status_t status; while ((status = load_kernel(args, bootVolume)) < B_OK) { // loading the kernel failed, so let the user choose another // volume to boot from until it works bootVolume.Unset(); if (!mountedAllVolumes) { // mount all other file systems, if not already happened if (mount_file_systems(args) < B_OK) panic("Could not locate any supported boot devices!\n"); mountedAllVolumes = true; } if (user_menu(bootVolume, pathBlacklist) != B_OK || !bootVolume.IsValid()) { // user requested to quit the loader goto out; } } // if everything is okay, continue booting; the kernel // is already loaded at this point and we definitely // know our boot volume, too if (status == B_OK) { if (bootVolume.IsPackaged()) { packagefs_apply_path_blacklist(bootVolume.SystemDirectory(), pathBlacklist); } register_boot_file_system(bootVolume); if ((platform_boot_options() & BOOT_OPTION_DEBUG_OUTPUT) == 0) platform_switch_to_logo(); load_modules(args, bootVolume); load_driver_settings(args, bootVolume.RootDirectory()); // apply boot settings apply_boot_settings(); // set up kernel args version info gKernelArgs.kernel_args_size = sizeof(kernel_args); gKernelArgs.version = CURRENT_KERNEL_ARGS_VERSION; // clone the boot_volume KMessage into kernel accessible memory // note, that we need to 4 byte align the buffer and thus allocate // 3 more bytes void* buffer = kernel_args_malloc(gBootVolume.ContentSize() + 3); if (!buffer) { panic("Could not allocate memory for the boot volume kernel " "arguments"); } buffer = (void*)(((addr_t)buffer + 3) & ~(addr_t)0x3); memcpy(buffer, gBootVolume.Buffer(), gBootVolume.ContentSize()); gKernelArgs.boot_volume = buffer; gKernelArgs.boot_volume_size = gBootVolume.ContentSize(); // ToDo: cleanup, heap_release() etc. heap_print_statistics(); platform_start_kernel(); } } out: heap_release(args); return 0; }