src/system/boot/loader/loader.cpp

   1 /*
   2  * Copyright 2003-2009, Axel Dörfler, axeld@pinc-software.de.
   3  * Distributed under the terms of the MIT License.
   4  */
   5
   6
   7 #include "loader.h"
   8 #include "elf.h"
   9 #include "RootFileSystem.h"
  10
  11 #include <directories.h>
  12 #include <OS.h>
  13 #include <util/list.h>
  14 #include <boot/stage2.h>
  15 #include <boot/vfs.h>
  16 #include <boot/platform.h>
  17 #include <boot/stdio.h>
  18 #include <boot/partitions.h>
  19
  20 #include <unistd.h>
  21 #include <string.h>
  22
  23
  24 #ifndef BOOT_ARCH
  25 #       error BOOT_ARCH has to be defined to differentiate the kernel per platform
  26 #endif
  27
  28 #define SYSTEM_DIRECTORY_PREFIX "system/"
  29 #define KERNEL_IMAGE    "kernel_" BOOT_ARCH
  30 #define KERNEL_PATH             SYSTEM_DIRECTORY_PREFIX KERNEL_IMAGE
  31
  32 #ifdef ALTERNATE_BOOT_ARCH
  33 # define ALTERNATE_KERNEL_IMAGE "kernel_" ALTERNATE_BOOT_ARCH
  34 # define ALTERNATE_KERNEL_PATH  "system/" ALTERNATE_KERNEL_IMAGE
  35 #endif
  36
  37
  38 static const char* const kSystemDirectoryPrefix = SYSTEM_DIRECTORY_PREFIX;
  39
  40 static const char *sKernelPaths[][2] = {
  41         { KERNEL_PATH, KERNEL_IMAGE },
  42 #ifdef ALTERNATE_BOOT_ARCH
  43         { ALTERNATE_KERNEL_PATH, ALTERNATE_KERNEL_IMAGE },
  44 #endif
  45         { NULL, NULL },
  46 };
  47
  48 static const char *sAddonPaths[] = {
  49         kVolumeLocalSystemKernelAddonsDirectory,
  50         kVolumeLocalCommonNonpackagedKernelAddonsDirectory,
  51         kVolumeLocalCommonKernelAddonsDirectory,
  52         kVolumeLocalUserNonpackagedKernelAddonsDirectory,
  53         kVolumeLocalUserKernelAddonsDirectory,
  54         NULL
  55 };
  56
  57
  58 static int
  59 open_maybe_packaged(BootVolume& volume, const char* path, int openMode)
  60 {
  61         if (strncmp(path, kSystemDirectoryPrefix, strlen(kSystemDirectoryPrefix))
  62                         == 0) {
  63                 path += strlen(kSystemDirectoryPrefix);
  64                 return open_from(volume.SystemDirectory(), path, openMode);
  65         }
  66
  67         return open_from(volume.RootDirectory(), path, openMode);
  68 }
  69
  70
  71 static int
  72 find_kernel(BootVolume& volume, const char** name = NULL)
  73 {
  74         for (int32 i = 0; sKernelPaths[i][0] != NULL; i++) {
  75                 int fd = open_maybe_packaged(volume, sKernelPaths[i][0], O_RDONLY);
  76                 if (fd >= 0) {
  77                         if (name)
  78                                 *name = sKernelPaths[i][1];
  79
  80                         return fd;
  81                 }
  82         }
  83
  84         return B_ENTRY_NOT_FOUND;
  85 }
  86
  87
  88 bool
  89 is_bootable(Directory *volume)
  90 {
  91         if (volume->IsEmpty())
  92                 return false;
  93
  94         BootVolume bootVolume;
  95         if (bootVolume.SetTo(volume) != B_OK)
  96                 return false;
  97
  98         // check for the existance of a kernel (for our platform)
  99         int fd = find_kernel(bootVolume);
 100         if (fd < 0)
 101                 return false;
 102
 103         close(fd);
 104
 105         return true;
 106 }
 107
 108
 109 status_t
 110 load_kernel(stage2_args* args, BootVolume& volume)
 111 {
 112         const char *name;
 113         int fd = find_kernel(volume, &name);
 114         if (fd < B_OK)
 115                 return fd;
 116
 117         dprintf("load kernel %s...\n", name);
 118
 119         elf_init();
 120         preloaded_image *image;
 121         status_t status = elf_load_image(fd, &image);
 122
 123         close(fd);
 124
 125         if (status < B_OK) {
 126                 dprintf("loading kernel failed: %" B_PRIx32 "!\n", status);
 127                 return status;
 128         }
 129
 130         gKernelArgs.kernel_image = image;
 131
 132         status = elf_relocate_image(gKernelArgs.kernel_image);
 133         if (status < B_OK) {
 134                 dprintf("relocating kernel failed: %" B_PRIx32 "!\n", status);
 135                 return status;
 136         }
 137
 138         gKernelArgs.kernel_image->name = kernel_args_strdup(name);
 139
 140         return B_OK;
 141 }
 142
 143
 144 static status_t
 145 load_modules_from(BootVolume& volume, const char* path)
 146 {
 147         // we don't have readdir() & co. (yet?)...
 148
 149         int fd = open_maybe_packaged(volume, path, O_RDONLY);
 150         if (fd < B_OK)
 151                 return fd;
 152
 153         Directory *modules = (Directory *)get_node_from(fd);
 154         if (modules == NULL)
 155                 return B_ENTRY_NOT_FOUND;
 156
 157         void *cookie;
 158         if (modules->Open(&cookie, O_RDONLY) == B_OK) {
 159                 char name[B_FILE_NAME_LENGTH];
 160                 while (modules->GetNextEntry(cookie, name, sizeof(name)) == B_OK) {
 161                         if (!strcmp(name, ".") || !strcmp(name, ".."))
 162                                 continue;
 163
 164                         status_t status = elf_load_image(modules, name);
 165                         if (status != B_OK)
 166                                 dprintf("Could not load \"%s\" error %" B_PRIx32 "\n", name, status);
 167                 }
 168
 169                 modules->Close(cookie);
 170         }
 171
 172         return B_OK;
 173 }
 174
 175
 176 /** Loads a module by module name. This basically works in the same
 177  *      way as the kernel module loader; it will cut off the last part
 178  *      of the module name until it could find a module and loads it.
 179  *      It tests both, kernel and user module directories.
 180  */
 181
 182 static status_t
 183 load_module(BootVolume& volume, const char* name)
 184 {
 185         char moduleName[B_FILE_NAME_LENGTH];
 186         if (strlcpy(moduleName, name, sizeof(moduleName)) > sizeof(moduleName))
 187                 return B_NAME_TOO_LONG;
 188
 189         for (int32 i = 0; sAddonPaths[i]; i++) {
 190                 // get base path
 191                 int baseFD = open_maybe_packaged(volume, sAddonPaths[i], O_RDONLY);
 192                 if (baseFD < B_OK)
 193                         continue;
 194
 195                 Directory *base = (Directory *)get_node_from(baseFD);
 196                 if (base == NULL) {
 197                         close(baseFD);
 198                         continue;
 199                 }
 200
 201                 while (true) {
 202                         int fd = open_from(base, moduleName, O_RDONLY);
 203                         if (fd >= B_OK) {
 204                                 struct stat stat;
 205                                 if (fstat(fd, &stat) != 0 || !S_ISREG(stat.st_mode))
 206                                         return B_BAD_VALUE;
 207
 208                                 status_t status = elf_load_image(base, moduleName);
 209
 210                                 close(fd);
 211                                 close(baseFD);
 212                                 return status;
 213                         }
 214
 215                         // cut off last name element (or stop trying if there are no more)
 216
 217                         char *last = strrchr(moduleName, '/');
 218                         if (last != NULL)
 219                                 last[0] = '\0';
 220                         else
 221                                 break;
 222                 }
 223
 224                 close(baseFD);
 225         }
 226
 227         return B_OK;
 228 }
 229
 230
 231 status_t
 232 load_modules(stage2_args* args, BootVolume& volume)
 233 {
 234         int32 failed = 0;
 235
 236         // ToDo: this should be mostly replaced by a hardware oriented detection mechanism
 237
 238         int32 i = 0;
 239         for (; sAddonPaths[i]; i++) {
 240                 char path[B_FILE_NAME_LENGTH];
 241                 snprintf(path, sizeof(path), "%s/boot", sAddonPaths[i]);
 242
 243                 if (load_modules_from(volume, path) != B_OK)
 244                         failed++;
 245         }
 246
 247         if (failed == i) {
 248                 // couldn't load any boot modules
 249                 // fall back to load all modules (currently needed by the boot floppy)
 250                 const char *paths[] = { "bus_managers", "busses/ide", "busses/scsi",
 251                         "generic", "partitioning_systems", "drivers/bin", NULL};
 252
 253                 for (int32 i = 0; paths[i]; i++) {
 254                         char path[B_FILE_NAME_LENGTH];
 255                         snprintf(path, sizeof(path), "%s/%s", sAddonPaths[0], paths[i]);
 256                         load_modules_from(volume, path);
 257                 }
 258         }
 259
 260         // and now load all partitioning and file system modules
 261         // needed to identify the boot volume
 262
 263         if (!gBootVolume.GetBool(BOOT_VOLUME_BOOTED_FROM_IMAGE, false)) {
 264                 // iterate over the mounted volumes and load their file system
 265                 Partition *partition;
 266                 if (gRoot->GetPartitionFor(volume.RootDirectory(), &partition)
 267                                 == B_OK) {
 268                         while (partition != NULL) {
 269                                 load_module(volume, partition->ModuleName());
 270                                 partition = partition->Parent();
 271                         }
 272                 }
 273         } else {
 274                 // The boot image should only contain the file system
 275                 // needed to boot the system, so we just load it.
 276                 // ToDo: this is separate from the fall back from above
 277                 //      as this piece will survive a more intelligent module
 278                 //      loading approach...
 279                 char path[B_FILE_NAME_LENGTH];
 280                 snprintf(path, sizeof(path), "%s/%s", sAddonPaths[0], "file_systems");
 281                 load_modules_from(volume, path);
 282         }
 283
 284         return B_OK;
 285 }
 286