arch_init.c

   1 /*
   2  * QEMU System Emulator
   3  *
   4  * Copyright (c) 2003-2008 Fabrice Bellard
   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 #include <stdint.h>
  25 #include <stdarg.h>
  26 #ifndef _WIN32
  27 #include <sys/types.h>
  28 #include <sys/mman.h>
  29 #endif
  30 #include "config.h"
  31 #include "monitor.h"
  32 #include "sysemu.h"
  33 #include "arch_init.h"
  34 #include "audio/audio.h"
  35 #include "hw/pc.h"
  36 #include "hw/pci.h"
  37 #include "hw/audiodev.h"
  38 #include "kvm.h"
  39 #include "migration.h"
  40 #include "net.h"
  41 #include "gdbstub.h"
  42 #include "hw/smbios.h"
  43
  44 #ifdef TARGET_SPARC
  45 int graphic_width = 1024;
  46 int graphic_height = 768;
  47 int graphic_depth = 8;
  48 #else
  49 int graphic_width = 800;
  50 int graphic_height = 600;
  51 int graphic_depth = 15;
  52 #endif
  53
  54 const char arch_config_name[] = CONFIG_QEMU_CONFDIR "/target-" TARGET_ARCH ".conf";
  55
  56 #if defined(TARGET_ALPHA)
  57 #define QEMU_ARCH QEMU_ARCH_ALPHA
  58 #elif defined(TARGET_ARM)
  59 #define QEMU_ARCH QEMU_ARCH_ARM
  60 #elif defined(TARGET_CRIS)
  61 #define QEMU_ARCH QEMU_ARCH_CRIS
  62 #elif defined(TARGET_I386)
  63 #define QEMU_ARCH QEMU_ARCH_I386
  64 #elif defined(TARGET_M68K)
  65 #define QEMU_ARCH QEMU_ARCH_M68K
  66 #elif defined(TARGET_MICROBLAZE)
  67 #define QEMU_ARCH QEMU_ARCH_MICROBLAZE
  68 #elif defined(TARGET_MIPS)
  69 #define QEMU_ARCH QEMU_ARCH_MIPS
  70 #elif defined(TARGET_PPC)
  71 #define QEMU_ARCH QEMU_ARCH_PPC
  72 #elif defined(TARGET_S390X)
  73 #define QEMU_ARCH QEMU_ARCH_S390X
  74 #elif defined(TARGET_SH4)
  75 #define QEMU_ARCH QEMU_ARCH_SH4
  76 #elif defined(TARGET_SPARC)
  77 #define QEMU_ARCH QEMU_ARCH_SPARC
  78 #endif
  79
  80 const uint32_t arch_type = QEMU_ARCH;
  81
  82 /***********************************************************/
  83 /* ram save/restore */
  84
  85 #define RAM_SAVE_FLAG_FULL      0x01 /* Obsolete, not used anymore */
  86 #define RAM_SAVE_FLAG_COMPRESS  0x02
  87 #define RAM_SAVE_FLAG_MEM_SIZE  0x04
  88 #define RAM_SAVE_FLAG_PAGE      0x08
  89 #define RAM_SAVE_FLAG_EOS       0x10
  90
  91 static int is_dup_page(uint8_t *page, uint8_t ch)
  92 {
  93     uint32_t val = ch << 24 | ch << 16 | ch << 8 | ch;
  94     uint32_t *array = (uint32_t *)page;
  95     int i;
  96
  97     for (i = 0; i < (TARGET_PAGE_SIZE / 4); i++) {
  98         if (array[i] != val) {
  99             return 0;
 100         }
 101     }
 102
 103     return 1;
 104 }
 105
 106 static int ram_save_block(QEMUFile *f)
 107 {
 108     static ram_addr_t current_addr = 0;
 109     ram_addr_t saved_addr = current_addr;
 110     ram_addr_t addr = 0;
 111     uint64_t total_ram = ram_bytes_total();
 112     int bytes_sent = 0;
 113
 114     while (addr < total_ram) {
 115         if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
 116             uint8_t *p;
 117
 118             cpu_physical_memory_reset_dirty(current_addr,
 119                                             current_addr + TARGET_PAGE_SIZE,
 120                                             MIGRATION_DIRTY_FLAG);
 121
 122             p = qemu_get_ram_ptr(current_addr);
 123
 124             if (is_dup_page(p, *p)) {
 125                 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
 126                 qemu_put_byte(f, *p);
 127                 bytes_sent = 1;
 128             } else {
 129                 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
 130                 qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
 131                 bytes_sent = TARGET_PAGE_SIZE;
 132             }
 133
 134             break;
 135         }
 136         addr += TARGET_PAGE_SIZE;
 137         current_addr = (saved_addr + addr) % total_ram;
 138     }
 139
 140     return bytes_sent;
 141 }
 142
 143 static uint64_t bytes_transferred;
 144
 145 static ram_addr_t ram_save_remaining(void)
 146 {
 147     ram_addr_t addr;
 148     ram_addr_t count = 0;
 149     uint64_t total_ram = ram_bytes_total();
 150
 151     for (addr = 0; addr < total_ram; addr += TARGET_PAGE_SIZE) {
 152         if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG)) {
 153             count++;
 154         }
 155     }
 156
 157     return count;
 158 }
 159
 160 uint64_t ram_bytes_remaining(void)
 161 {
 162     return ram_save_remaining() * TARGET_PAGE_SIZE;
 163 }
 164
 165 uint64_t ram_bytes_transferred(void)
 166 {
 167     return bytes_transferred;
 168 }
 169
 170 uint64_t ram_bytes_total(void)
 171 {
 172     RAMBlock *block;
 173     uint64_t total = 0;
 174
 175     QLIST_FOREACH(block, &ram_list.blocks, next)
 176         total += block->length;
 177
 178     return total;
 179 }
 180
 181 int ram_save_live(Monitor *mon, QEMUFile *f, int stage, void *opaque)
 182 {
 183     ram_addr_t addr;
 184     uint64_t bytes_transferred_last;
 185     double bwidth = 0;
 186     uint64_t expected_time = 0;
 187
 188     if (stage < 0) {
 189         cpu_physical_memory_set_dirty_tracking(0);
 190         return 0;
 191     }
 192
 193     if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX) != 0) {
 194         qemu_file_set_error(f);
 195         return 0;
 196     }
 197
 198     if (stage == 1) {
 199         uint64_t total_ram = ram_bytes_total();
 200         bytes_transferred = 0;
 201
 202         /* Make sure all dirty bits are set */
 203         for (addr = 0; addr < total_ram; addr += TARGET_PAGE_SIZE) {
 204             if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG)) {
 205                 cpu_physical_memory_set_dirty(addr);
 206             }
 207         }
 208
 209         /* Enable dirty memory tracking */
 210         cpu_physical_memory_set_dirty_tracking(1);
 211
 212         qemu_put_be64(f, total_ram | RAM_SAVE_FLAG_MEM_SIZE);
 213     }
 214
 215     bytes_transferred_last = bytes_transferred;
 216     bwidth = qemu_get_clock_ns(rt_clock);
 217
 218     while (!qemu_file_rate_limit(f)) {
 219         int bytes_sent;
 220
 221         bytes_sent = ram_save_block(f);
 222         bytes_transferred += bytes_sent;
 223         if (bytes_sent == 0) { /* no more blocks */
 224             break;
 225         }
 226     }
 227
 228     bwidth = qemu_get_clock_ns(rt_clock) - bwidth;
 229     bwidth = (bytes_transferred - bytes_transferred_last) / bwidth;
 230
 231     /* if we haven't transferred anything this round, force expected_time to a
 232      * a very high value, but without crashing */
 233     if (bwidth == 0) {
 234         bwidth = 0.000001;
 235     }
 236
 237     /* try transferring iterative blocks of memory */
 238     if (stage == 3) {
 239         int bytes_sent;
 240
 241         /* flush all remaining blocks regardless of rate limiting */
 242         while ((bytes_sent = ram_save_block(f)) != 0) {
 243             bytes_transferred += bytes_sent;
 244         }
 245         cpu_physical_memory_set_dirty_tracking(0);
 246     }
 247
 248     qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
 249
 250     expected_time = ram_save_remaining() * TARGET_PAGE_SIZE / bwidth;
 251
 252     return (stage == 2) && (expected_time <= migrate_max_downtime());
 253 }
 254
 255 int ram_load(QEMUFile *f, void *opaque, int version_id)
 256 {
 257     ram_addr_t addr;
 258     int flags;
 259
 260     if (version_id != 3) {
 261         return -EINVAL;
 262     }
 263
 264     do {
 265         addr = qemu_get_be64(f);
 266
 267         flags = addr & ~TARGET_PAGE_MASK;
 268         addr &= TARGET_PAGE_MASK;
 269
 270         if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
 271             if (addr != ram_bytes_total()) {
 272                 return -EINVAL;
 273             }
 274         }
 275
 276         if (flags & RAM_SAVE_FLAG_COMPRESS) {
 277             uint8_t ch = qemu_get_byte(f);
 278             memset(qemu_get_ram_ptr(addr), ch, TARGET_PAGE_SIZE);
 279 #ifndef _WIN32
 280             if (ch == 0 &&
 281                 (!kvm_enabled() || kvm_has_sync_mmu())) {
 282                 madvise(qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE,
 283                         MADV_DONTNEED);
 284             }
 285 #endif
 286         } else if (flags & RAM_SAVE_FLAG_PAGE) {
 287             qemu_get_buffer(f, qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE);
 288         }
 289         if (qemu_file_has_error(f)) {
 290             return -EIO;
 291         }
 292     } while (!(flags & RAM_SAVE_FLAG_EOS));
 293
 294     return 0;
 295 }
 296
 297 void qemu_service_io(void)
 298 {
 299     qemu_notify_event();
 300 }
 301
 302 #ifdef HAS_AUDIO
 303 struct soundhw soundhw[] = {
 304 #ifdef HAS_AUDIO_CHOICE
 305 #if defined(TARGET_I386) || defined(TARGET_MIPS)
 306     {
 307         "pcspk",
 308         "PC speaker",
 309         0,
 310         1,
 311         { .init_isa = pcspk_audio_init }
 312     },
 313 #endif
 314
 315 #ifdef CONFIG_SB16
 316     {
 317         "sb16",
 318         "Creative Sound Blaster 16",
 319         0,
 320         1,
 321         { .init_isa = SB16_init }
 322     },
 323 #endif
 324
 325 #ifdef CONFIG_CS4231A
 326     {
 327         "cs4231a",
 328         "CS4231A",
 329         0,
 330         1,
 331         { .init_isa = cs4231a_init }
 332     },
 333 #endif
 334
 335 #ifdef CONFIG_ADLIB
 336     {
 337         "adlib",
 338 #ifdef HAS_YMF262
 339         "Yamaha YMF262 (OPL3)",
 340 #else
 341         "Yamaha YM3812 (OPL2)",
 342 #endif
 343         0,
 344         1,
 345         { .init_isa = Adlib_init }
 346     },
 347 #endif
 348
 349 #ifdef CONFIG_GUS
 350     {
 351         "gus",
 352         "Gravis Ultrasound GF1",
 353         0,
 354         1,
 355         { .init_isa = GUS_init }
 356     },
 357 #endif
 358
 359 #ifdef CONFIG_AC97
 360     {
 361         "ac97",
 362         "Intel 82801AA AC97 Audio",
 363         0,
 364         0,
 365         { .init_pci = ac97_init }
 366     },
 367 #endif
 368
 369 #ifdef CONFIG_ES1370
 370     {
 371         "es1370",
 372         "ENSONIQ AudioPCI ES1370",
 373         0,
 374         0,
 375         { .init_pci = es1370_init }
 376     },
 377 #endif
 378
 379 #endif /* HAS_AUDIO_CHOICE */
 380
 381     { NULL, NULL, 0, 0, { NULL } }
 382 };
 383
 384 void select_soundhw(const char *optarg)
 385 {
 386     struct soundhw *c;
 387
 388     if (*optarg == '?') {
 389     show_valid_cards:
 390
 391         printf("Valid sound card names (comma separated):\n");
 392         for (c = soundhw; c->name; ++c) {
 393             printf ("%-11s %s\n", c->name, c->descr);
 394         }
 395         printf("\n-soundhw all will enable all of the above\n");
 396         exit(*optarg != '?');
 397     }
 398     else {
 399         size_t l;
 400         const char *p;
 401         char *e;
 402         int bad_card = 0;
 403
 404         if (!strcmp(optarg, "all")) {
 405             for (c = soundhw; c->name; ++c) {
 406                 c->enabled = 1;
 407             }
 408             return;
 409         }
 410
 411         p = optarg;
 412         while (*p) {
 413             e = strchr(p, ',');
 414             l = !e ? strlen(p) : (size_t) (e - p);
 415
 416             for (c = soundhw; c->name; ++c) {
 417                 if (!strncmp(c->name, p, l) && !c->name[l]) {
 418                     c->enabled = 1;
 419                     break;
 420                 }
 421             }
 422
 423             if (!c->name) {
 424                 if (l > 80) {
 425                     fprintf(stderr,
 426                             "Unknown sound card name (too big to show)\n");
 427                 }
 428                 else {
 429                     fprintf(stderr, "Unknown sound card name `%.*s'\n",
 430                             (int) l, p);
 431                 }
 432                 bad_card = 1;
 433             }
 434             p += l + (e != NULL);
 435         }
 436
 437         if (bad_card) {
 438             goto show_valid_cards;
 439         }
 440     }
 441 }
 442 #else
 443 void select_soundhw(const char *optarg)
 444 {
 445 }
 446 #endif
 447
 448 int qemu_uuid_parse(const char *str, uint8_t *uuid)
 449 {
 450     int ret;
 451
 452     if (strlen(str) != 36) {
 453         return -1;
 454     }
 455
 456     ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
 457                  &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
 458                  &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14],
 459                  &uuid[15]);
 460
 461     if (ret != 16) {
 462         return -1;
 463     }
 464 #ifdef TARGET_I386
 465     smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
 466 #endif
 467     return 0;
 468 }
 469
 470 void do_acpitable_option(const char *optarg)
 471 {
 472 #ifdef TARGET_I386
 473     if (acpi_table_add(optarg) < 0) {
 474         fprintf(stderr, "Wrong acpi table provided\n");
 475         exit(1);
 476     }
 477 #endif
 478 }
 479
 480 void do_smbios_option(const char *optarg)
 481 {
 482 #ifdef TARGET_I386
 483     if (smbios_entry_add(optarg) < 0) {
 484         fprintf(stderr, "Wrong smbios provided\n");
 485         exit(1);
 486     }
 487 #endif
 488 }
 489
 490 void cpudef_init(void)
 491 {
 492 #if defined(cpudef_setup)
 493     cpudef_setup(); /* parse cpu definitions in target config file */
 494 #endif
 495 }
 496
 497 int audio_available(void)
 498 {
 499 #ifdef HAS_AUDIO
 500     return 1;
 501 #else
 502     return 0;
 503 #endif
 504 }
 505
 506 int kvm_available(void)
 507 {
 508 #ifdef CONFIG_KVM
 509     return 1;
 510 #else
 511     return 0;
 512 #endif
 513 }
 514
 515 int xen_available(void)
 516 {
 517 #ifdef CONFIG_XEN
 518     return 1;
 519 #else
 520     return 0;
 521 #endif
 522 }