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     int bytes_sent = 0;
 112
 113     while (addr < ram_list.last_offset) {
 114         if (cpu_physical_memory_get_dirty(current_addr, MIGRATION_DIRTY_FLAG)) {
 115             uint8_t *p;
 116
 117             cpu_physical_memory_reset_dirty(current_addr,
 118                                             current_addr + TARGET_PAGE_SIZE,
 119                                             MIGRATION_DIRTY_FLAG);
 120
 121             p = qemu_get_ram_ptr(current_addr);
 122
 123             if (is_dup_page(p, *p)) {
 124                 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_COMPRESS);
 125                 qemu_put_byte(f, *p);
 126                 bytes_sent = 1;
 127             } else {
 128                 qemu_put_be64(f, current_addr | RAM_SAVE_FLAG_PAGE);
 129                 qemu_put_buffer(f, p, TARGET_PAGE_SIZE);
 130                 bytes_sent = TARGET_PAGE_SIZE;
 131             }
 132
 133             break;
 134         }
 135         addr += TARGET_PAGE_SIZE;
 136         current_addr = (saved_addr + addr) % ram_list.last_offset;
 137     }
 138
 139     return bytes_sent;
 140 }
 141
 142 static uint64_t bytes_transferred;
 143
 144 static ram_addr_t ram_save_remaining(void)
 145 {
 146     ram_addr_t addr;
 147     ram_addr_t count = 0;
 148
 149     for (addr = 0; addr < ram_list.last_offset; addr += TARGET_PAGE_SIZE) {
 150         if (cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG)) {
 151             count++;
 152         }
 153     }
 154
 155     return count;
 156 }
 157
 158 uint64_t ram_bytes_remaining(void)
 159 {
 160     return ram_save_remaining() * TARGET_PAGE_SIZE;
 161 }
 162
 163 uint64_t ram_bytes_transferred(void)
 164 {
 165     return bytes_transferred;
 166 }
 167
 168 uint64_t ram_bytes_total(void)
 169 {
 170     return ram_list.last_offset;
 171 }
 172
 173 int ram_save_live(Monitor *mon, QEMUFile *f, int stage, void *opaque)
 174 {
 175     ram_addr_t addr;
 176     uint64_t bytes_transferred_last;
 177     double bwidth = 0;
 178     uint64_t expected_time = 0;
 179
 180     if (stage < 0) {
 181         cpu_physical_memory_set_dirty_tracking(0);
 182         return 0;
 183     }
 184
 185     if (cpu_physical_sync_dirty_bitmap(0, TARGET_PHYS_ADDR_MAX) != 0) {
 186         qemu_file_set_error(f);
 187         return 0;
 188     }
 189
 190     if (stage == 1) {
 191         bytes_transferred = 0;
 192
 193         /* Make sure all dirty bits are set */
 194         for (addr = 0; addr < ram_list.last_offset; addr += TARGET_PAGE_SIZE) {
 195             if (!cpu_physical_memory_get_dirty(addr, MIGRATION_DIRTY_FLAG)) {
 196                 cpu_physical_memory_set_dirty(addr);
 197             }
 198         }
 199
 200         /* Enable dirty memory tracking */
 201         cpu_physical_memory_set_dirty_tracking(1);
 202
 203         qemu_put_be64(f, ram_list.last_offset | RAM_SAVE_FLAG_MEM_SIZE);
 204     }
 205
 206     bytes_transferred_last = bytes_transferred;
 207     bwidth = qemu_get_clock_ns(rt_clock);
 208
 209     while (!qemu_file_rate_limit(f)) {
 210         int bytes_sent;
 211
 212         bytes_sent = ram_save_block(f);
 213         bytes_transferred += bytes_sent;
 214         if (bytes_sent == 0) { /* no more blocks */
 215             break;
 216         }
 217     }
 218
 219     bwidth = qemu_get_clock_ns(rt_clock) - bwidth;
 220     bwidth = (bytes_transferred - bytes_transferred_last) / bwidth;
 221
 222     /* if we haven't transferred anything this round, force expected_time to a
 223      * a very high value, but without crashing */
 224     if (bwidth == 0) {
 225         bwidth = 0.000001;
 226     }
 227
 228     /* try transferring iterative blocks of memory */
 229     if (stage == 3) {
 230         int bytes_sent;
 231
 232         /* flush all remaining blocks regardless of rate limiting */
 233         while ((bytes_sent = ram_save_block(f)) != 0) {
 234             bytes_transferred += bytes_sent;
 235         }
 236         cpu_physical_memory_set_dirty_tracking(0);
 237     }
 238
 239     qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
 240
 241     expected_time = ram_save_remaining() * TARGET_PAGE_SIZE / bwidth;
 242
 243     return (stage == 2) && (expected_time <= migrate_max_downtime());
 244 }
 245
 246 int ram_load(QEMUFile *f, void *opaque, int version_id)
 247 {
 248     ram_addr_t addr;
 249     int flags;
 250
 251     if (version_id != 3) {
 252         return -EINVAL;
 253     }
 254
 255     do {
 256         addr = qemu_get_be64(f);
 257
 258         flags = addr & ~TARGET_PAGE_MASK;
 259         addr &= TARGET_PAGE_MASK;
 260
 261         if (flags & RAM_SAVE_FLAG_MEM_SIZE) {
 262             if (addr != ram_list.last_offset) {
 263                 return -EINVAL;
 264             }
 265         }
 266
 267         if (flags & RAM_SAVE_FLAG_COMPRESS) {
 268             uint8_t ch = qemu_get_byte(f);
 269             memset(qemu_get_ram_ptr(addr), ch, TARGET_PAGE_SIZE);
 270 #ifndef _WIN32
 271             if (ch == 0 &&
 272                 (!kvm_enabled() || kvm_has_sync_mmu())) {
 273                 madvise(qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE,
 274                         MADV_DONTNEED);
 275             }
 276 #endif
 277         } else if (flags & RAM_SAVE_FLAG_PAGE) {
 278             qemu_get_buffer(f, qemu_get_ram_ptr(addr), TARGET_PAGE_SIZE);
 279         }
 280         if (qemu_file_has_error(f)) {
 281             return -EIO;
 282         }
 283     } while (!(flags & RAM_SAVE_FLAG_EOS));
 284
 285     return 0;
 286 }
 287
 288 void qemu_service_io(void)
 289 {
 290     qemu_notify_event();
 291 }
 292
 293 #ifdef HAS_AUDIO
 294 struct soundhw soundhw[] = {
 295 #ifdef HAS_AUDIO_CHOICE
 296 #if defined(TARGET_I386) || defined(TARGET_MIPS)
 297     {
 298         "pcspk",
 299         "PC speaker",
 300         0,
 301         1,
 302         { .init_isa = pcspk_audio_init }
 303     },
 304 #endif
 305
 306 #ifdef CONFIG_SB16
 307     {
 308         "sb16",
 309         "Creative Sound Blaster 16",
 310         0,
 311         1,
 312         { .init_isa = SB16_init }
 313     },
 314 #endif
 315
 316 #ifdef CONFIG_CS4231A
 317     {
 318         "cs4231a",
 319         "CS4231A",
 320         0,
 321         1,
 322         { .init_isa = cs4231a_init }
 323     },
 324 #endif
 325
 326 #ifdef CONFIG_ADLIB
 327     {
 328         "adlib",
 329 #ifdef HAS_YMF262
 330         "Yamaha YMF262 (OPL3)",
 331 #else
 332         "Yamaha YM3812 (OPL2)",
 333 #endif
 334         0,
 335         1,
 336         { .init_isa = Adlib_init }
 337     },
 338 #endif
 339
 340 #ifdef CONFIG_GUS
 341     {
 342         "gus",
 343         "Gravis Ultrasound GF1",
 344         0,
 345         1,
 346         { .init_isa = GUS_init }
 347     },
 348 #endif
 349
 350 #ifdef CONFIG_AC97
 351     {
 352         "ac97",
 353         "Intel 82801AA AC97 Audio",
 354         0,
 355         0,
 356         { .init_pci = ac97_init }
 357     },
 358 #endif
 359
 360 #ifdef CONFIG_ES1370
 361     {
 362         "es1370",
 363         "ENSONIQ AudioPCI ES1370",
 364         0,
 365         0,
 366         { .init_pci = es1370_init }
 367     },
 368 #endif
 369
 370 #endif /* HAS_AUDIO_CHOICE */
 371
 372     { NULL, NULL, 0, 0, { NULL } }
 373 };
 374
 375 void select_soundhw(const char *optarg)
 376 {
 377     struct soundhw *c;
 378
 379     if (*optarg == '?') {
 380     show_valid_cards:
 381
 382         printf("Valid sound card names (comma separated):\n");
 383         for (c = soundhw; c->name; ++c) {
 384             printf ("%-11s %s\n", c->name, c->descr);
 385         }
 386         printf("\n-soundhw all will enable all of the above\n");
 387         exit(*optarg != '?');
 388     }
 389     else {
 390         size_t l;
 391         const char *p;
 392         char *e;
 393         int bad_card = 0;
 394
 395         if (!strcmp(optarg, "all")) {
 396             for (c = soundhw; c->name; ++c) {
 397                 c->enabled = 1;
 398             }
 399             return;
 400         }
 401
 402         p = optarg;
 403         while (*p) {
 404             e = strchr(p, ',');
 405             l = !e ? strlen(p) : (size_t) (e - p);
 406
 407             for (c = soundhw; c->name; ++c) {
 408                 if (!strncmp(c->name, p, l) && !c->name[l]) {
 409                     c->enabled = 1;
 410                     break;
 411                 }
 412             }
 413
 414             if (!c->name) {
 415                 if (l > 80) {
 416                     fprintf(stderr,
 417                             "Unknown sound card name (too big to show)\n");
 418                 }
 419                 else {
 420                     fprintf(stderr, "Unknown sound card name `%.*s'\n",
 421                             (int) l, p);
 422                 }
 423                 bad_card = 1;
 424             }
 425             p += l + (e != NULL);
 426         }
 427
 428         if (bad_card) {
 429             goto show_valid_cards;
 430         }
 431     }
 432 }
 433 #else
 434 void select_soundhw(const char *optarg)
 435 {
 436 }
 437 #endif
 438
 439 int qemu_uuid_parse(const char *str, uint8_t *uuid)
 440 {
 441     int ret;
 442
 443     if (strlen(str) != 36) {
 444         return -1;
 445     }
 446
 447     ret = sscanf(str, UUID_FMT, &uuid[0], &uuid[1], &uuid[2], &uuid[3],
 448                  &uuid[4], &uuid[5], &uuid[6], &uuid[7], &uuid[8], &uuid[9],
 449                  &uuid[10], &uuid[11], &uuid[12], &uuid[13], &uuid[14],
 450                  &uuid[15]);
 451
 452     if (ret != 16) {
 453         return -1;
 454     }
 455 #ifdef TARGET_I386
 456     smbios_add_field(1, offsetof(struct smbios_type_1, uuid), 16, uuid);
 457 #endif
 458     return 0;
 459 }
 460
 461 void do_acpitable_option(const char *optarg)
 462 {
 463 #ifdef TARGET_I386
 464     if (acpi_table_add(optarg) < 0) {
 465         fprintf(stderr, "Wrong acpi table provided\n");
 466         exit(1);
 467     }
 468 #endif
 469 }
 470
 471 void do_smbios_option(const char *optarg)
 472 {
 473 #ifdef TARGET_I386
 474     if (smbios_entry_add(optarg) < 0) {
 475         fprintf(stderr, "Wrong smbios provided\n");
 476         exit(1);
 477     }
 478 #endif
 479 }
 480
 481 void cpudef_init(void)
 482 {
 483 #if defined(cpudef_setup)
 484     cpudef_setup(); /* parse cpu definitions in target config file */
 485 #endif
 486 }
 487
 488 int audio_available(void)
 489 {
 490 #ifdef HAS_AUDIO
 491     return 1;
 492 #else
 493     return 0;
 494 #endif
 495 }
 496
 497 int kvm_available(void)
 498 {
 499 #ifdef CONFIG_KVM
 500     return 1;
 501 #else
 502     return 0;
 503 #endif
 504 }
 505
 506 int xen_available(void)
 507 {
 508 #ifdef CONFIG_XEN
 509     return 1;
 510 #else
 511     return 0;
 512 #endif
 513 }