src/system/boot/loader/load_driver_settings.cpp

   1 /*
   2  * Copyright 2008, Rene Gollent, rene@gollent.com. All rights reserved.
   3  * Copyright 2005-2009, Axel Dörfler, axeld@pinc-software.de.
   4  * Distributed under the terms of the MIT License.
   5  */
   6
   7
   8 #include "load_driver_settings.h"
   9
  10 #include <errno.h>
  11 #include <string.h>
  12 #include <unistd.h>
  13
  14 #include <OS.h>
  15 #include <drivers/driver_settings.h>
  16
  17 #include <safemode_defs.h>
  18
  19 #include <boot/driver_settings.h>
  20 #include <boot/kernel_args.h>
  21 #include <boot/stage2.h>
  22 #include <boot/platform.h>
  23
  24
  25 static status_t
  26 load_driver_settings_file(Directory* directory, const char* name)
  27 {
  28         int fd = open_from(directory, name, O_RDONLY);
  29         if (fd < 0)
  30                 return fd;
  31
  32         struct stat stat;
  33         if (fstat(fd, &stat) < 0)
  34                 return errno;
  35
  36         char* buffer = (char*)kernel_args_malloc(stat.st_size + 1);
  37         if (buffer == NULL)
  38                 return B_NO_MEMORY;
  39
  40         if (read(fd, buffer, stat.st_size) != stat.st_size) {
  41                 kernel_args_free(buffer);
  42                 return B_IO_ERROR;
  43         }
  44
  45         driver_settings_file* file = (driver_settings_file*)kernel_args_malloc(
  46                 sizeof(driver_settings_file));
  47         if (file == NULL) {
  48                 kernel_args_free(buffer);
  49                 return B_NO_MEMORY;
  50         }
  51
  52         buffer[stat.st_size] = '\0';
  53                 // null terminate the buffer
  54
  55         strlcpy(file->name, name, sizeof(file->name));
  56         file->buffer = buffer;
  57         file->size = stat.st_size;
  58
  59         // add it to the list
  60         file->next = gKernelArgs.driver_settings;
  61         gKernelArgs.driver_settings = file;
  62
  63         return B_OK;
  64 }
  65
  66
  67 static void
  68 apply_boot_settings(void* kernelSettings, void* safemodeSettings)
  69 {
  70 #if B_HAIKU_PHYSICAL_BITS > 32
  71         if ((kernelSettings != NULL
  72                         && get_driver_boolean_parameter(kernelSettings,
  73                                 B_SAFEMODE_4_GB_MEMORY_LIMIT, false, false))
  74                 || (safemodeSettings != NULL
  75                         && get_driver_boolean_parameter(safemodeSettings,
  76                                 B_SAFEMODE_4_GB_MEMORY_LIMIT, false, false))) {
  77                 ignore_physical_memory_ranges_beyond_4gb();
  78         }
  79 #endif
  80 }
  81
  82
  83 //      #pragma mark -
  84
  85
  86 status_t
  87 load_driver_settings(stage2_args* /*args*/, Directory* volume)
  88 {
  89         int fd = open_from(volume, "home/config/settings/kernel/drivers", O_RDONLY);
  90         if (fd < B_OK)
  91                 return fd;
  92
  93         Directory* settings = (Directory*)get_node_from(fd);
  94         if (settings == NULL)
  95                 return B_ENTRY_NOT_FOUND;
  96
  97         void* cookie;
  98         if (settings->Open(&cookie, O_RDONLY) == B_OK) {
  99                 char name[B_FILE_NAME_LENGTH];
 100                 while (settings->GetNextEntry(cookie, name, sizeof(name)) == B_OK) {
 101                         if (!strcmp(name, ".") || !strcmp(name, ".."))
 102                                 continue;
 103
 104                         status_t status = load_driver_settings_file(settings, name);
 105                         if (status != B_OK)
 106                                 dprintf("Could not load \"%s\" error %" B_PRIx32 "\n", name, status);
 107                 }
 108
 109                 settings->Close(cookie);
 110         }
 111
 112         return B_OK;
 113 }
 114
 115
 116 status_t
 117 add_stage2_driver_settings(stage2_args* args)
 118 {
 119         // TODO: split more intelligently
 120         for (const char** arg = args->arguments;
 121                         arg != NULL && args->arguments_count-- && arg[0] != NULL; arg++) {
 122                 dprintf("adding args: '%s'\n", arg[0]);
 123                 add_safe_mode_settings((char*)arg[0]);
 124         }
 125         return B_OK;
 126 }
 127
 128
 129 status_t
 130 add_safe_mode_settings(const char* settings)
 131 {
 132         if (settings == NULL || settings[0] == '\0')
 133                 return B_OK;
 134
 135         size_t length = strlen(settings);
 136         char* buffer = (char*)kernel_args_malloc(length + 1);
 137         if (buffer == NULL)
 138                 return B_NO_MEMORY;
 139
 140         driver_settings_file* file = (driver_settings_file*)kernel_args_malloc(
 141                 sizeof(driver_settings_file));
 142         if (file == NULL) {
 143                 kernel_args_free(buffer);
 144                 return B_NO_MEMORY;
 145         }
 146
 147         strlcpy(file->name, B_SAFEMODE_DRIVER_SETTINGS, sizeof(file->name));
 148         memcpy(buffer, settings, length + 1);
 149         file->buffer = buffer;
 150         file->size = length;
 151
 152         // add it to the list
 153         file->next = gKernelArgs.driver_settings;
 154         gKernelArgs.driver_settings = file;
 155
 156         return B_OK;
 157 }
 158
 159
 160 void
 161 apply_boot_settings()
 162 {
 163         void* kernelSettings = load_driver_settings("kernel");
 164         void* safemodeSettings = load_driver_settings(B_SAFEMODE_DRIVER_SETTINGS);
 165
 166         apply_boot_settings(kernelSettings, safemodeSettings);
 167
 168         if (safemodeSettings != NULL)
 169                 unload_driver_settings(safemodeSettings);
 170         if (kernelSettings)
 171                 unload_driver_settings(kernelSettings);
 172 }