system/bootdevice.c

   1 /*
   2  * QEMU Boot Device Implement
   3  *
   4  * Copyright (c) 2014 HUAWEI TECHNOLOGIES CO., LTD.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24
  25 #include "qemu/osdep.h"
  26 #include "qapi/error.h"
  27 #include "sysemu/sysemu.h"
  28 #include "qapi/visitor.h"
  29 #include "qemu/error-report.h"
  30 #include "sysemu/reset.h"
  31 #include "hw/qdev-core.h"
  32 #include "hw/boards.h"
  33
  34 typedef struct FWBootEntry FWBootEntry;
  35
  36 struct FWBootEntry {
  37     QTAILQ_ENTRY(FWBootEntry) link;
  38     int32_t bootindex;
  39     DeviceState *dev;
  40     char *suffix;
  41 };
  42
  43 static QTAILQ_HEAD(, FWBootEntry) fw_boot_order =
  44     QTAILQ_HEAD_INITIALIZER(fw_boot_order);
  45 static QEMUBootSetHandler *boot_set_handler;
  46 static void *boot_set_opaque;
  47
  48 void qemu_register_boot_set(QEMUBootSetHandler *func, void *opaque)
  49 {
  50     boot_set_handler = func;
  51     boot_set_opaque = opaque;
  52 }
  53
  54 void qemu_boot_set(const char *boot_order, Error **errp)
  55 {
  56     Error *local_err = NULL;
  57
  58     if (!boot_set_handler) {
  59         error_setg(errp, "no function defined to set boot device list for"
  60                          " this architecture");
  61         return;
  62     }
  63
  64     validate_bootdevices(boot_order, &local_err);
  65     if (local_err) {
  66         error_propagate(errp, local_err);
  67         return;
  68     }
  69
  70     boot_set_handler(boot_set_opaque, boot_order, errp);
  71 }
  72
  73 void validate_bootdevices(const char *devices, Error **errp)
  74 {
  75     /* We just do some generic consistency checks */
  76     const char *p;
  77     int bitmap = 0;
  78
  79     for (p = devices; *p != '\0'; p++) {
  80         /* Allowed boot devices are:
  81          * a-b: floppy disk drives
  82          * c-f: IDE disk drives
  83          * g-m: machine implementation dependent drives
  84          * n-p: network devices
  85          * It's up to each machine implementation to check if the given boot
  86          * devices match the actual hardware implementation and firmware
  87          * features.
  88          */
  89         if (*p < 'a' || *p > 'p') {
  90             error_setg(errp, "Invalid boot device '%c'", *p);
  91             return;
  92         }
  93         if (bitmap & (1 << (*p - 'a'))) {
  94             error_setg(errp, "Boot device '%c' was given twice", *p);
  95             return;
  96         }
  97         bitmap |= 1 << (*p - 'a');
  98     }
  99 }
 100
 101 void restore_boot_order(void *opaque)
 102 {
 103     char *normal_boot_order = opaque;
 104     static int first = 1;
 105
 106     /* Restore boot order and remove ourselves after the first boot */
 107     if (first) {
 108         first = 0;
 109         return;
 110     }
 111
 112     if (boot_set_handler) {
 113         qemu_boot_set(normal_boot_order, &error_abort);
 114     }
 115
 116     qemu_unregister_reset(restore_boot_order, normal_boot_order);
 117     g_free(normal_boot_order);
 118 }
 119
 120 void check_boot_index(int32_t bootindex, Error **errp)
 121 {
 122     FWBootEntry *i;
 123
 124     if (bootindex >= 0) {
 125         QTAILQ_FOREACH(i, &fw_boot_order, link) {
 126             if (i->bootindex == bootindex) {
 127                 error_setg(errp, "The bootindex %d has already been used",
 128                            bootindex);
 129                 return;
 130             }
 131         }
 132     }
 133 }
 134
 135 void del_boot_device_path(DeviceState *dev, const char *suffix)
 136 {
 137     FWBootEntry *i;
 138
 139     if (dev == NULL) {
 140         return;
 141     }
 142
 143     QTAILQ_FOREACH(i, &fw_boot_order, link) {
 144         if ((!suffix || !g_strcmp0(i->suffix, suffix)) &&
 145              i->dev == dev) {
 146             QTAILQ_REMOVE(&fw_boot_order, i, link);
 147             g_free(i->suffix);
 148             g_free(i);
 149
 150             break;
 151         }
 152     }
 153 }
 154
 155 void add_boot_device_path(int32_t bootindex, DeviceState *dev,
 156                           const char *suffix)
 157 {
 158     FWBootEntry *node, *i;
 159
 160     if (bootindex < 0) {
 161         del_boot_device_path(dev, suffix);
 162         return;
 163     }
 164
 165     assert(dev != NULL || suffix != NULL);
 166
 167     del_boot_device_path(dev, suffix);
 168
 169     node = g_new0(FWBootEntry, 1);
 170     node->bootindex = bootindex;
 171     node->suffix = g_strdup(suffix);
 172     node->dev = dev;
 173
 174     QTAILQ_FOREACH(i, &fw_boot_order, link) {
 175         if (i->bootindex == bootindex) {
 176             error_report("Two devices with same boot index %d", bootindex);
 177             exit(1);
 178         } else if (i->bootindex < bootindex) {
 179             continue;
 180         }
 181         QTAILQ_INSERT_BEFORE(i, node, link);
 182         return;
 183     }
 184     QTAILQ_INSERT_TAIL(&fw_boot_order, node, link);
 185 }
 186
 187 DeviceState *get_boot_device(uint32_t position)
 188 {
 189     uint32_t counter = 0;
 190     FWBootEntry *i = NULL;
 191     DeviceState *res = NULL;
 192
 193     if (!QTAILQ_EMPTY(&fw_boot_order)) {
 194         QTAILQ_FOREACH(i, &fw_boot_order, link) {
 195             if (counter == position) {
 196                 res = i->dev;
 197                 break;
 198             }
 199             counter++;
 200         }
 201     }
 202     return res;
 203 }
 204
 205 static char *get_boot_device_path(DeviceState *dev, bool ignore_suffixes,
 206                                   const char *suffix)
 207 {
 208     char *devpath = NULL, *s = NULL, *d, *bootpath;
 209
 210     if (dev) {
 211         devpath = qdev_get_fw_dev_path(dev);
 212         assert(devpath);
 213     }
 214
 215     if (!ignore_suffixes) {
 216         if (dev) {
 217             d = qdev_get_own_fw_dev_path_from_handler(dev->parent_bus, dev);
 218             if (d) {
 219                 assert(!suffix);
 220                 s = d;
 221             } else {
 222                 s = g_strdup(suffix);
 223             }
 224         } else {
 225             s = g_strdup(suffix);
 226         }
 227     }
 228
 229     bootpath = g_strdup_printf("%s%s",
 230                                devpath ? devpath : "",
 231                                s ? s : "");
 232     g_free(devpath);
 233     g_free(s);
 234
 235     return bootpath;
 236 }
 237
 238 /*
 239  * This function returns null terminated string that consist of new line
 240  * separated device paths.
 241  *
 242  * memory pointed by "size" is assigned total length of the array in bytes
 243  *
 244  */
 245 char *get_boot_devices_list(size_t *size)
 246 {
 247     FWBootEntry *i;
 248     size_t total = 0;
 249     char *list = NULL;
 250     MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine());
 251     bool ignore_suffixes = mc->ignore_boot_device_suffixes;
 252
 253     QTAILQ_FOREACH(i, &fw_boot_order, link) {
 254         char *bootpath;
 255         size_t len;
 256
 257         bootpath = get_boot_device_path(i->dev, ignore_suffixes, i->suffix);
 258
 259         if (total) {
 260             list[total-1] = '\n';
 261         }
 262         len = strlen(bootpath) + 1;
 263         list = g_realloc(list, total + len);
 264         memcpy(&list[total], bootpath, len);
 265         total += len;
 266         g_free(bootpath);
 267     }
 268
 269     *size = total;
 270
 271     if (current_machine->boot_config.has_strict &&
 272         current_machine->boot_config.strict && *size > 0) {
 273         list[total-1] = '\n';
 274         list = g_realloc(list, total + 5);
 275         memcpy(&list[total], "HALT", 5);
 276         *size = total + 5;
 277     }
 278     return list;
 279 }
 280
 281 typedef struct {
 282     int32_t *bootindex;
 283     const char *suffix;
 284     DeviceState *dev;
 285 } BootIndexProperty;
 286
 287 static void device_get_bootindex(Object *obj, Visitor *v, const char *name,
 288                                  void *opaque, Error **errp)
 289 {
 290     BootIndexProperty *prop = opaque;
 291     visit_type_int32(v, name, prop->bootindex, errp);
 292 }
 293
 294 static void device_set_bootindex(Object *obj, Visitor *v, const char *name,
 295                                  void *opaque, Error **errp)
 296 {
 297     BootIndexProperty *prop = opaque;
 298     int32_t boot_index;
 299     Error *local_err = NULL;
 300
 301     if (!visit_type_int32(v, name, &boot_index, errp)) {
 302         return;
 303     }
 304     /* check whether bootindex is present in fw_boot_order list  */
 305     check_boot_index(boot_index, &local_err);
 306     if (local_err) {
 307         error_propagate(errp, local_err);
 308         return;
 309     }
 310     /* change bootindex to a new one */
 311     *prop->bootindex = boot_index;
 312
 313     add_boot_device_path(*prop->bootindex, prop->dev, prop->suffix);
 314 }
 315
 316 static void property_release_bootindex(Object *obj, const char *name,
 317                                        void *opaque)
 318
 319 {
 320     BootIndexProperty *prop = opaque;
 321
 322     del_boot_device_path(prop->dev, prop->suffix);
 323     g_free(prop);
 324 }
 325
 326 void device_add_bootindex_property(Object *obj, int32_t *bootindex,
 327                                    const char *name, const char *suffix,
 328                                    DeviceState *dev)
 329 {
 330     BootIndexProperty *prop = g_malloc0(sizeof(*prop));
 331
 332     prop->bootindex = bootindex;
 333     prop->suffix = suffix;
 334     prop->dev = dev;
 335
 336     object_property_add(obj, name, "int32",
 337                         device_get_bootindex,
 338                         device_set_bootindex,
 339                         property_release_bootindex,
 340                         prop);
 341
 342     /* initialize devices' bootindex property to -1 */
 343     object_property_set_int(obj, name, -1, NULL);
 344 }
 345
 346 typedef struct FWLCHSEntry FWLCHSEntry;
 347
 348 struct FWLCHSEntry {
 349     QTAILQ_ENTRY(FWLCHSEntry) link;
 350     DeviceState *dev;
 351     char *suffix;
 352     uint32_t lcyls;
 353     uint32_t lheads;
 354     uint32_t lsecs;
 355 };
 356
 357 static QTAILQ_HEAD(, FWLCHSEntry) fw_lchs =
 358     QTAILQ_HEAD_INITIALIZER(fw_lchs);
 359
 360 void add_boot_device_lchs(DeviceState *dev, const char *suffix,
 361                           uint32_t lcyls, uint32_t lheads, uint32_t lsecs)
 362 {
 363     FWLCHSEntry *node;
 364
 365     if (!lcyls && !lheads && !lsecs) {
 366         return;
 367     }
 368
 369     assert(dev != NULL || suffix != NULL);
 370
 371     node = g_new0(FWLCHSEntry, 1);
 372     node->suffix = g_strdup(suffix);
 373     node->dev = dev;
 374     node->lcyls = lcyls;
 375     node->lheads = lheads;
 376     node->lsecs = lsecs;
 377
 378     QTAILQ_INSERT_TAIL(&fw_lchs, node, link);
 379 }
 380
 381 void del_boot_device_lchs(DeviceState *dev, const char *suffix)
 382 {
 383     FWLCHSEntry *i;
 384
 385     if (dev == NULL) {
 386         return;
 387     }
 388
 389     QTAILQ_FOREACH(i, &fw_lchs, link) {
 390         if ((!suffix || !g_strcmp0(i->suffix, suffix)) &&
 391              i->dev == dev) {
 392             QTAILQ_REMOVE(&fw_lchs, i, link);
 393             g_free(i->suffix);
 394             g_free(i);
 395
 396             break;
 397         }
 398     }
 399 }
 400
 401 char *get_boot_devices_lchs_list(size_t *size)
 402 {
 403     FWLCHSEntry *i;
 404     size_t total = 0;
 405     char *list = NULL;
 406
 407     QTAILQ_FOREACH(i, &fw_lchs, link) {
 408         char *bootpath;
 409         char *chs_string;
 410         size_t len;
 411
 412         bootpath = get_boot_device_path(i->dev, false, i->suffix);
 413         chs_string = g_strdup_printf("%s %" PRIu32 " %" PRIu32 " %" PRIu32,
 414                                      bootpath, i->lcyls, i->lheads, i->lsecs);
 415
 416         if (total) {
 417             list[total - 1] = '\n';
 418         }
 419         len = strlen(chs_string) + 1;
 420         list = g_realloc(list, total + len);
 421         memcpy(&list[total], chs_string, len);
 422         total += len;
 423         g_free(chs_string);
 424         g_free(bootpath);
 425     }
 426
 427     *size = total;
 428
 429     return list;
 430 }