hw/ppc/spapr.c

   1 /*
   2  * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator
   3  *
   4  * Copyright (c) 2004-2007 Fabrice Bellard
   5  * Copyright (c) 2007 Jocelyn Mayer
   6  * Copyright (c) 2010 David Gibson, IBM Corporation.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a copy
   9  * of this software and associated documentation files (the "Software"), to deal
  10  * in the Software without restriction, including without limitation the rights
  11  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12  * copies of the Software, and to permit persons to whom the Software is
  13  * furnished to do so, subject to the following conditions:
  14  *
  15  * The above copyright notice and this permission notice shall be included in
  16  * all copies or substantial portions of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  21  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  24  * THE SOFTWARE.
  25  *
  26  */
  27 #include "sysemu/sysemu.h"
  28 #include "sysemu/numa.h"
  29 #include "hw/hw.h"
  30 #include "hw/fw-path-provider.h"
  31 #include "elf.h"
  32 #include "net/net.h"
  33 #include "sysemu/device_tree.h"
  34 #include "sysemu/block-backend.h"
  35 #include "sysemu/cpus.h"
  36 #include "sysemu/kvm.h"
  37 #include "sysemu/device_tree.h"
  38 #include "kvm_ppc.h"
  39 #include "migration/migration.h"
  40 #include "mmu-hash64.h"
  41 #include "qom/cpu.h"
  42
  43 #include "hw/boards.h"
  44 #include "hw/ppc/ppc.h"
  45 #include "hw/loader.h"
  46
  47 #include "hw/ppc/spapr.h"
  48 #include "hw/ppc/spapr_vio.h"
  49 #include "hw/pci-host/spapr.h"
  50 #include "hw/ppc/xics.h"
  51 #include "hw/pci/msi.h"
  52
  53 #include "hw/pci/pci.h"
  54 #include "hw/scsi/scsi.h"
  55 #include "hw/virtio/virtio-scsi.h"
  56
  57 #include "exec/address-spaces.h"
  58 #include "hw/usb.h"
  59 #include "qemu/config-file.h"
  60 #include "qemu/error-report.h"
  61 #include "trace.h"
  62 #include "hw/nmi.h"
  63
  64 #include "hw/compat.h"
  65 #include "qemu-common.h"
  66
  67 #include <libfdt.h>
  68
  69 /* SLOF memory layout:
  70  *
  71  * SLOF raw image loaded at 0, copies its romfs right below the flat
  72  * device-tree, then position SLOF itself 31M below that
  73  *
  74  * So we set FW_OVERHEAD to 40MB which should account for all of that
  75  * and more
  76  *
  77  * We load our kernel at 4M, leaving space for SLOF initial image
  78  */
  79 #define FDT_MAX_SIZE            0x100000
  80 #define RTAS_MAX_SIZE           0x10000
  81 #define RTAS_MAX_ADDR           0x80000000 /* RTAS must stay below that */
  82 #define FW_MAX_SIZE             0x400000
  83 #define FW_FILE_NAME            "slof.bin"
  84 #define FW_OVERHEAD             0x2800000
  85 #define KERNEL_LOAD_ADDR        FW_MAX_SIZE
  86
  87 #define MIN_RMA_SLOF            128UL
  88
  89 #define TIMEBASE_FREQ           512000000ULL
  90
  91 #define PHANDLE_XICP            0x00001111
  92
  93 #define HTAB_SIZE(spapr)        (1ULL << ((spapr)->htab_shift))
  94
  95 static XICSState *try_create_xics(const char *type, int nr_servers,
  96                                   int nr_irqs, Error **errp)
  97 {
  98     Error *err = NULL;
  99     DeviceState *dev;
 100
 101     dev = qdev_create(NULL, type);
 102     qdev_prop_set_uint32(dev, "nr_servers", nr_servers);
 103     qdev_prop_set_uint32(dev, "nr_irqs", nr_irqs);
 104     object_property_set_bool(OBJECT(dev), true, "realized", &err);
 105     if (err) {
 106         error_propagate(errp, err);
 107         object_unparent(OBJECT(dev));
 108         return NULL;
 109     }
 110     return XICS_COMMON(dev);
 111 }
 112
 113 static XICSState *xics_system_init(MachineState *machine,
 114                                    int nr_servers, int nr_irqs)
 115 {
 116     XICSState *icp = NULL;
 117
 118     if (kvm_enabled()) {
 119         Error *err = NULL;
 120
 121         if (machine_kernel_irqchip_allowed(machine)) {
 122             icp = try_create_xics(TYPE_KVM_XICS, nr_servers, nr_irqs, &err);
 123         }
 124         if (machine_kernel_irqchip_required(machine) && !icp) {
 125             error_report("kernel_irqchip requested but unavailable: %s",
 126                          error_get_pretty(err));
 127         }
 128     }
 129
 130     if (!icp) {
 131         icp = try_create_xics(TYPE_XICS, nr_servers, nr_irqs, &error_abort);
 132     }
 133
 134     return icp;
 135 }
 136
 137 static int spapr_fixup_cpu_smt_dt(void *fdt, int offset, PowerPCCPU *cpu,
 138                                   int smt_threads)
 139 {
 140     int i, ret = 0;
 141     uint32_t servers_prop[smt_threads];
 142     uint32_t gservers_prop[smt_threads * 2];
 143     int index = ppc_get_vcpu_dt_id(cpu);
 144
 145     if (cpu->cpu_version) {
 146         ret = fdt_setprop_cell(fdt, offset, "cpu-version", cpu->cpu_version);
 147         if (ret < 0) {
 148             return ret;
 149         }
 150     }
 151
 152     /* Build interrupt servers and gservers properties */
 153     for (i = 0; i < smt_threads; i++) {
 154         servers_prop[i] = cpu_to_be32(index + i);
 155         /* Hack, direct the group queues back to cpu 0 */
 156         gservers_prop[i*2] = cpu_to_be32(index + i);
 157         gservers_prop[i*2 + 1] = 0;
 158     }
 159     ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-server#s",
 160                       servers_prop, sizeof(servers_prop));
 161     if (ret < 0) {
 162         return ret;
 163     }
 164     ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-gserver#s",
 165                       gservers_prop, sizeof(gservers_prop));
 166
 167     return ret;
 168 }
 169
 170 static int spapr_fixup_cpu_numa_dt(void *fdt, int offset, CPUState *cs)
 171 {
 172     int ret = 0;
 173     PowerPCCPU *cpu = POWERPC_CPU(cs);
 174     int index = ppc_get_vcpu_dt_id(cpu);
 175     uint32_t associativity[] = {cpu_to_be32(0x5),
 176                                 cpu_to_be32(0x0),
 177                                 cpu_to_be32(0x0),
 178                                 cpu_to_be32(0x0),
 179                                 cpu_to_be32(cs->numa_node),
 180                                 cpu_to_be32(index)};
 181
 182     /* Advertise NUMA via ibm,associativity */
 183     if (nb_numa_nodes > 1) {
 184         ret = fdt_setprop(fdt, offset, "ibm,associativity", associativity,
 185                           sizeof(associativity));
 186     }
 187
 188     return ret;
 189 }
 190
 191 static int spapr_fixup_cpu_dt(void *fdt, sPAPRMachineState *spapr)
 192 {
 193     int ret = 0, offset, cpus_offset;
 194     CPUState *cs;
 195     char cpu_model[32];
 196     int smt = kvmppc_smt_threads();
 197     uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)};
 198
 199     CPU_FOREACH(cs) {
 200         PowerPCCPU *cpu = POWERPC_CPU(cs);
 201         DeviceClass *dc = DEVICE_GET_CLASS(cs);
 202         int index = ppc_get_vcpu_dt_id(cpu);
 203
 204         if ((index % smt) != 0) {
 205             continue;
 206         }
 207
 208         snprintf(cpu_model, 32, "%s@%x", dc->fw_name, index);
 209
 210         cpus_offset = fdt_path_offset(fdt, "/cpus");
 211         if (cpus_offset < 0) {
 212             cpus_offset = fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"),
 213                                           "cpus");
 214             if (cpus_offset < 0) {
 215                 return cpus_offset;
 216             }
 217         }
 218         offset = fdt_subnode_offset(fdt, cpus_offset, cpu_model);
 219         if (offset < 0) {
 220             offset = fdt_add_subnode(fdt, cpus_offset, cpu_model);
 221             if (offset < 0) {
 222                 return offset;
 223             }
 224         }
 225
 226         ret = fdt_setprop(fdt, offset, "ibm,pft-size",
 227                           pft_size_prop, sizeof(pft_size_prop));
 228         if (ret < 0) {
 229             return ret;
 230         }
 231
 232         ret = spapr_fixup_cpu_numa_dt(fdt, offset, cs);
 233         if (ret < 0) {
 234             return ret;
 235         }
 236
 237         ret = spapr_fixup_cpu_smt_dt(fdt, offset, cpu,
 238                                      ppc_get_compat_smt_threads(cpu));
 239         if (ret < 0) {
 240             return ret;
 241         }
 242     }
 243     return ret;
 244 }
 245
 246
 247 static size_t create_page_sizes_prop(CPUPPCState *env, uint32_t *prop,
 248                                      size_t maxsize)
 249 {
 250     size_t maxcells = maxsize / sizeof(uint32_t);
 251     int i, j, count;
 252     uint32_t *p = prop;
 253
 254     for (i = 0; i < PPC_PAGE_SIZES_MAX_SZ; i++) {
 255         struct ppc_one_seg_page_size *sps = &env->sps.sps[i];
 256
 257         if (!sps->page_shift) {
 258             break;
 259         }
 260         for (count = 0; count < PPC_PAGE_SIZES_MAX_SZ; count++) {
 261             if (sps->enc[count].page_shift == 0) {
 262                 break;
 263             }
 264         }
 265         if ((p - prop) >= (maxcells - 3 - count * 2)) {
 266             break;
 267         }
 268         *(p++) = cpu_to_be32(sps->page_shift);
 269         *(p++) = cpu_to_be32(sps->slb_enc);
 270         *(p++) = cpu_to_be32(count);
 271         for (j = 0; j < count; j++) {
 272             *(p++) = cpu_to_be32(sps->enc[j].page_shift);
 273             *(p++) = cpu_to_be32(sps->enc[j].pte_enc);
 274         }
 275     }
 276
 277     return (p - prop) * sizeof(uint32_t);
 278 }
 279
 280 static hwaddr spapr_node0_size(void)
 281 {
 282     MachineState *machine = MACHINE(qdev_get_machine());
 283
 284     if (nb_numa_nodes) {
 285         int i;
 286         for (i = 0; i < nb_numa_nodes; ++i) {
 287             if (numa_info[i].node_mem) {
 288                 return MIN(pow2floor(numa_info[i].node_mem),
 289                            machine->ram_size);
 290             }
 291         }
 292     }
 293     return machine->ram_size;
 294 }
 295
 296 #define _FDT(exp) \
 297     do { \
 298         int ret = (exp);                                           \
 299         if (ret < 0) {                                             \
 300             fprintf(stderr, "qemu: error creating device tree: %s: %s\n", \
 301                     #exp, fdt_strerror(ret));                      \
 302             exit(1);                                               \
 303         }                                                          \
 304     } while (0)
 305
 306 static void add_str(GString *s, const gchar *s1)
 307 {
 308     g_string_append_len(s, s1, strlen(s1) + 1);
 309 }
 310
 311 static void *spapr_create_fdt_skel(hwaddr initrd_base,
 312                                    hwaddr initrd_size,
 313                                    hwaddr kernel_size,
 314                                    bool little_endian,
 315                                    const char *kernel_cmdline,
 316                                    uint32_t epow_irq)
 317 {
 318     void *fdt;
 319     uint32_t start_prop = cpu_to_be32(initrd_base);
 320     uint32_t end_prop = cpu_to_be32(initrd_base + initrd_size);
 321     GString *hypertas = g_string_sized_new(256);
 322     GString *qemu_hypertas = g_string_sized_new(256);
 323     uint32_t refpoints[] = {cpu_to_be32(0x4), cpu_to_be32(0x4)};
 324     uint32_t interrupt_server_ranges_prop[] = {0, cpu_to_be32(max_cpus)};
 325     unsigned char vec5[] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x80};
 326     char *buf;
 327
 328     add_str(hypertas, "hcall-pft");
 329     add_str(hypertas, "hcall-term");
 330     add_str(hypertas, "hcall-dabr");
 331     add_str(hypertas, "hcall-interrupt");
 332     add_str(hypertas, "hcall-tce");
 333     add_str(hypertas, "hcall-vio");
 334     add_str(hypertas, "hcall-splpar");
 335     add_str(hypertas, "hcall-bulk");
 336     add_str(hypertas, "hcall-set-mode");
 337     add_str(qemu_hypertas, "hcall-memop1");
 338
 339     fdt = g_malloc0(FDT_MAX_SIZE);
 340     _FDT((fdt_create(fdt, FDT_MAX_SIZE)));
 341
 342     if (kernel_size) {
 343         _FDT((fdt_add_reservemap_entry(fdt, KERNEL_LOAD_ADDR, kernel_size)));
 344     }
 345     if (initrd_size) {
 346         _FDT((fdt_add_reservemap_entry(fdt, initrd_base, initrd_size)));
 347     }
 348     _FDT((fdt_finish_reservemap(fdt)));
 349
 350     /* Root node */
 351     _FDT((fdt_begin_node(fdt, "")));
 352     _FDT((fdt_property_string(fdt, "device_type", "chrp")));
 353     _FDT((fdt_property_string(fdt, "model", "IBM pSeries (emulated by qemu)")));
 354     _FDT((fdt_property_string(fdt, "compatible", "qemu,pseries")));
 355
 356     /*
 357      * Add info to guest to indentify which host is it being run on
 358      * and what is the uuid of the guest
 359      */
 360     if (kvmppc_get_host_model(&buf)) {
 361         _FDT((fdt_property_string(fdt, "host-model", buf)));
 362         g_free(buf);
 363     }
 364     if (kvmppc_get_host_serial(&buf)) {
 365         _FDT((fdt_property_string(fdt, "host-serial", buf)));
 366         g_free(buf);
 367     }
 368
 369     buf = g_strdup_printf(UUID_FMT, qemu_uuid[0], qemu_uuid[1],
 370                           qemu_uuid[2], qemu_uuid[3], qemu_uuid[4],
 371                           qemu_uuid[5], qemu_uuid[6], qemu_uuid[7],
 372                           qemu_uuid[8], qemu_uuid[9], qemu_uuid[10],
 373                           qemu_uuid[11], qemu_uuid[12], qemu_uuid[13],
 374                           qemu_uuid[14], qemu_uuid[15]);
 375
 376     _FDT((fdt_property_string(fdt, "vm,uuid", buf)));
 377     g_free(buf);
 378
 379     if (qemu_get_vm_name()) {
 380         _FDT((fdt_property_string(fdt, "ibm,partition-name",
 381                                   qemu_get_vm_name())));
 382     }
 383
 384     _FDT((fdt_property_cell(fdt, "#address-cells", 0x2)));
 385     _FDT((fdt_property_cell(fdt, "#size-cells", 0x2)));
 386
 387     /* /chosen */
 388     _FDT((fdt_begin_node(fdt, "chosen")));
 389
 390     /* Set Form1_affinity */
 391     _FDT((fdt_property(fdt, "ibm,architecture-vec-5", vec5, sizeof(vec5))));
 392
 393     _FDT((fdt_property_string(fdt, "bootargs", kernel_cmdline)));
 394     _FDT((fdt_property(fdt, "linux,initrd-start",
 395                        &start_prop, sizeof(start_prop))));
 396     _FDT((fdt_property(fdt, "linux,initrd-end",
 397                        &end_prop, sizeof(end_prop))));
 398     if (kernel_size) {
 399         uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR),
 400                               cpu_to_be64(kernel_size) };
 401
 402         _FDT((fdt_property(fdt, "qemu,boot-kernel", &kprop, sizeof(kprop))));
 403         if (little_endian) {
 404             _FDT((fdt_property(fdt, "qemu,boot-kernel-le", NULL, 0)));
 405         }
 406     }
 407     if (boot_menu) {
 408         _FDT((fdt_property_cell(fdt, "qemu,boot-menu", boot_menu)));
 409     }
 410     _FDT((fdt_property_cell(fdt, "qemu,graphic-width", graphic_width)));
 411     _FDT((fdt_property_cell(fdt, "qemu,graphic-height", graphic_height)));
 412     _FDT((fdt_property_cell(fdt, "qemu,graphic-depth", graphic_depth)));
 413
 414     _FDT((fdt_end_node(fdt)));
 415
 416     /* RTAS */
 417     _FDT((fdt_begin_node(fdt, "rtas")));
 418
 419     if (!kvm_enabled() || kvmppc_spapr_use_multitce()) {
 420         add_str(hypertas, "hcall-multi-tce");
 421     }
 422     _FDT((fdt_property(fdt, "ibm,hypertas-functions", hypertas->str,
 423                        hypertas->len)));
 424     g_string_free(hypertas, TRUE);
 425     _FDT((fdt_property(fdt, "qemu,hypertas-functions", qemu_hypertas->str,
 426                        qemu_hypertas->len)));
 427     g_string_free(qemu_hypertas, TRUE);
 428
 429     _FDT((fdt_property(fdt, "ibm,associativity-reference-points",
 430         refpoints, sizeof(refpoints))));
 431
 432     _FDT((fdt_property_cell(fdt, "rtas-error-log-max", RTAS_ERROR_LOG_MAX)));
 433     _FDT((fdt_property_cell(fdt, "rtas-event-scan-rate",
 434                             RTAS_EVENT_SCAN_RATE)));
 435
 436     if (msi_supported) {
 437         _FDT((fdt_property(fdt, "ibm,change-msix-capable", NULL, 0)));
 438     }
 439
 440     /*
 441      * According to PAPR, rtas ibm,os-term does not guarantee a return
 442      * back to the guest cpu.
 443      *
 444      * While an additional ibm,extended-os-term property indicates that
 445      * rtas call return will always occur. Set this property.
 446      */
 447     _FDT((fdt_property(fdt, "ibm,extended-os-term", NULL, 0)));
 448
 449     _FDT((fdt_end_node(fdt)));
 450
 451     /* interrupt controller */
 452     _FDT((fdt_begin_node(fdt, "interrupt-controller")));
 453
 454     _FDT((fdt_property_string(fdt, "device_type",
 455                               "PowerPC-External-Interrupt-Presentation")));
 456     _FDT((fdt_property_string(fdt, "compatible", "IBM,ppc-xicp")));
 457     _FDT((fdt_property(fdt, "interrupt-controller", NULL, 0)));
 458     _FDT((fdt_property(fdt, "ibm,interrupt-server-ranges",
 459                        interrupt_server_ranges_prop,
 460                        sizeof(interrupt_server_ranges_prop))));
 461     _FDT((fdt_property_cell(fdt, "#interrupt-cells", 2)));
 462     _FDT((fdt_property_cell(fdt, "linux,phandle", PHANDLE_XICP)));
 463     _FDT((fdt_property_cell(fdt, "phandle", PHANDLE_XICP)));
 464
 465     _FDT((fdt_end_node(fdt)));
 466
 467     /* vdevice */
 468     _FDT((fdt_begin_node(fdt, "vdevice")));
 469
 470     _FDT((fdt_property_string(fdt, "device_type", "vdevice")));
 471     _FDT((fdt_property_string(fdt, "compatible", "IBM,vdevice")));
 472     _FDT((fdt_property_cell(fdt, "#address-cells", 0x1)));
 473     _FDT((fdt_property_cell(fdt, "#size-cells", 0x0)));
 474     _FDT((fdt_property_cell(fdt, "#interrupt-cells", 0x2)));
 475     _FDT((fdt_property(fdt, "interrupt-controller", NULL, 0)));
 476
 477     _FDT((fdt_end_node(fdt)));
 478
 479     /* event-sources */
 480     spapr_events_fdt_skel(fdt, epow_irq);
 481
 482     /* /hypervisor node */
 483     if (kvm_enabled()) {
 484         uint8_t hypercall[16];
 485
 486         /* indicate KVM hypercall interface */
 487         _FDT((fdt_begin_node(fdt, "hypervisor")));
 488         _FDT((fdt_property_string(fdt, "compatible", "linux,kvm")));
 489         if (kvmppc_has_cap_fixup_hcalls()) {
 490             /*
 491              * Older KVM versions with older guest kernels were broken with the
 492              * magic page, don't allow the guest to map it.
 493              */
 494             kvmppc_get_hypercall(first_cpu->env_ptr, hypercall,
 495                                  sizeof(hypercall));
 496             _FDT((fdt_property(fdt, "hcall-instructions", hypercall,
 497                               sizeof(hypercall))));
 498         }
 499         _FDT((fdt_end_node(fdt)));
 500     }
 501
 502     _FDT((fdt_end_node(fdt))); /* close root node */
 503     _FDT((fdt_finish(fdt)));
 504
 505     return fdt;
 506 }
 507
 508 static int spapr_populate_memory_node(void *fdt, int nodeid, hwaddr start,
 509                                        hwaddr size)
 510 {
 511     uint32_t associativity[] = {
 512         cpu_to_be32(0x4), /* length */
 513         cpu_to_be32(0x0), cpu_to_be32(0x0),
 514         cpu_to_be32(0x0), cpu_to_be32(nodeid)
 515     };
 516     char mem_name[32];
 517     uint64_t mem_reg_property[2];
 518     int off;
 519
 520     mem_reg_property[0] = cpu_to_be64(start);
 521     mem_reg_property[1] = cpu_to_be64(size);
 522
 523     sprintf(mem_name, "memory@" TARGET_FMT_lx, start);
 524     off = fdt_add_subnode(fdt, 0, mem_name);
 525     _FDT(off);
 526     _FDT((fdt_setprop_string(fdt, off, "device_type", "memory")));
 527     _FDT((fdt_setprop(fdt, off, "reg", mem_reg_property,
 528                       sizeof(mem_reg_property))));
 529     _FDT((fdt_setprop(fdt, off, "ibm,associativity", associativity,
 530                       sizeof(associativity))));
 531     return off;
 532 }
 533
 534 static int spapr_populate_memory(sPAPRMachineState *spapr, void *fdt)
 535 {
 536     MachineState *machine = MACHINE(spapr);
 537     hwaddr mem_start, node_size;
 538     int i, nb_nodes = nb_numa_nodes;
 539     NodeInfo *nodes = numa_info;
 540     NodeInfo ramnode;
 541
 542     /* No NUMA nodes, assume there is just one node with whole RAM */
 543     if (!nb_numa_nodes) {
 544         nb_nodes = 1;
 545         ramnode.node_mem = machine->ram_size;
 546         nodes = &ramnode;
 547     }
 548
 549     for (i = 0, mem_start = 0; i < nb_nodes; ++i) {
 550         if (!nodes[i].node_mem) {
 551             continue;
 552         }
 553         if (mem_start >= machine->ram_size) {
 554             node_size = 0;
 555         } else {
 556             node_size = nodes[i].node_mem;
 557             if (node_size > machine->ram_size - mem_start) {
 558                 node_size = machine->ram_size - mem_start;
 559             }
 560         }
 561         if (!mem_start) {
 562             /* ppc_spapr_init() checks for rma_size <= node0_size already */
 563             spapr_populate_memory_node(fdt, i, 0, spapr->rma_size);
 564             mem_start += spapr->rma_size;
 565             node_size -= spapr->rma_size;
 566         }
 567         for ( ; node_size; ) {
 568             hwaddr sizetmp = pow2floor(node_size);
 569
 570             /* mem_start != 0 here */
 571             if (ctzl(mem_start) < ctzl(sizetmp)) {
 572                 sizetmp = 1ULL << ctzl(mem_start);
 573             }
 574
 575             spapr_populate_memory_node(fdt, i, mem_start, sizetmp);
 576             node_size -= sizetmp;
 577             mem_start += sizetmp;
 578         }
 579     }
 580
 581     return 0;
 582 }
 583
 584 static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset,
 585                                   sPAPRMachineState *spapr)
 586 {
 587     PowerPCCPU *cpu = POWERPC_CPU(cs);
 588     CPUPPCState *env = &cpu->env;
 589     PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs);
 590     int index = ppc_get_vcpu_dt_id(cpu);
 591     uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40),
 592                        0xffffffff, 0xffffffff};
 593     uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq() : TIMEBASE_FREQ;
 594     uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000;
 595     uint32_t page_sizes_prop[64];
 596     size_t page_sizes_prop_size;
 597     uint32_t vcpus_per_socket = smp_threads * smp_cores;
 598     uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)};
 599
 600     _FDT((fdt_setprop_cell(fdt, offset, "reg", index)));
 601     _FDT((fdt_setprop_string(fdt, offset, "device_type", "cpu")));
 602
 603     _FDT((fdt_setprop_cell(fdt, offset, "cpu-version", env->spr[SPR_PVR])));
 604     _FDT((fdt_setprop_cell(fdt, offset, "d-cache-block-size",
 605                            env->dcache_line_size)));
 606     _FDT((fdt_setprop_cell(fdt, offset, "d-cache-line-size",
 607                            env->dcache_line_size)));
 608     _FDT((fdt_setprop_cell(fdt, offset, "i-cache-block-size",
 609                            env->icache_line_size)));
 610     _FDT((fdt_setprop_cell(fdt, offset, "i-cache-line-size",
 611                            env->icache_line_size)));
 612
 613     if (pcc->l1_dcache_size) {
 614         _FDT((fdt_setprop_cell(fdt, offset, "d-cache-size",
 615                                pcc->l1_dcache_size)));
 616     } else {
 617         fprintf(stderr, "Warning: Unknown L1 dcache size for cpu\n");
 618     }
 619     if (pcc->l1_icache_size) {
 620         _FDT((fdt_setprop_cell(fdt, offset, "i-cache-size",
 621                                pcc->l1_icache_size)));
 622     } else {
 623         fprintf(stderr, "Warning: Unknown L1 icache size for cpu\n");
 624     }
 625
 626     _FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq)));
 627     _FDT((fdt_setprop_cell(fdt, offset, "clock-frequency", cpufreq)));
 628     _FDT((fdt_setprop_cell(fdt, offset, "ibm,slb-size", env->slb_nr)));
 629     _FDT((fdt_setprop_string(fdt, offset, "status", "okay")));
 630     _FDT((fdt_setprop(fdt, offset, "64-bit", NULL, 0)));
 631
 632     if (env->spr_cb[SPR_PURR].oea_read) {
 633         _FDT((fdt_setprop(fdt, offset, "ibm,purr", NULL, 0)));
 634     }
 635
 636     if (env->mmu_model & POWERPC_MMU_1TSEG) {
 637         _FDT((fdt_setprop(fdt, offset, "ibm,processor-segment-sizes",
 638                           segs, sizeof(segs))));
 639     }
 640
 641     /* Advertise VMX/VSX (vector extensions) if available
 642      *   0 / no property == no vector extensions
 643      *   1               == VMX / Altivec available
 644      *   2               == VSX available */
 645     if (env->insns_flags & PPC_ALTIVEC) {
 646         uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1;
 647
 648         _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", vmx)));
 649     }
 650
 651     /* Advertise DFP (Decimal Floating Point) if available
 652      *   0 / no property == no DFP
 653      *   1               == DFP available */
 654     if (env->insns_flags2 & PPC2_DFP) {
 655         _FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1)));
 656     }
 657
 658     page_sizes_prop_size = create_page_sizes_prop(env, page_sizes_prop,
 659                                                   sizeof(page_sizes_prop));
 660     if (page_sizes_prop_size) {
 661         _FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes",
 662                           page_sizes_prop, page_sizes_prop_size)));
 663     }
 664
 665     _FDT((fdt_setprop_cell(fdt, offset, "ibm,chip-id",
 666                            cs->cpu_index / vcpus_per_socket)));
 667
 668     _FDT((fdt_setprop(fdt, offset, "ibm,pft-size",
 669                       pft_size_prop, sizeof(pft_size_prop))));
 670
 671     _FDT(spapr_fixup_cpu_numa_dt(fdt, offset, cs));
 672
 673     _FDT(spapr_fixup_cpu_smt_dt(fdt, offset, cpu,
 674                                 ppc_get_compat_smt_threads(cpu)));
 675 }
 676
 677 static void spapr_populate_cpus_dt_node(void *fdt, sPAPRMachineState *spapr)
 678 {
 679     CPUState *cs;
 680     int cpus_offset;
 681     char *nodename;
 682     int smt = kvmppc_smt_threads();
 683
 684     cpus_offset = fdt_add_subnode(fdt, 0, "cpus");
 685     _FDT(cpus_offset);
 686     _FDT((fdt_setprop_cell(fdt, cpus_offset, "#address-cells", 0x1)));
 687     _FDT((fdt_setprop_cell(fdt, cpus_offset, "#size-cells", 0x0)));
 688
 689     /*
 690      * We walk the CPUs in reverse order to ensure that CPU DT nodes
 691      * created by fdt_add_subnode() end up in the right order in FDT
 692      * for the guest kernel the enumerate the CPUs correctly.
 693      */
 694     CPU_FOREACH_REVERSE(cs) {
 695         PowerPCCPU *cpu = POWERPC_CPU(cs);
 696         int index = ppc_get_vcpu_dt_id(cpu);
 697         DeviceClass *dc = DEVICE_GET_CLASS(cs);
 698         int offset;
 699
 700         if ((index % smt) != 0) {
 701             continue;
 702         }
 703
 704         nodename = g_strdup_printf("%s@%x", dc->fw_name, index);
 705         offset = fdt_add_subnode(fdt, cpus_offset, nodename);
 706         g_free(nodename);
 707         _FDT(offset);
 708         spapr_populate_cpu_dt(cs, fdt, offset, spapr);
 709     }
 710
 711 }
 712
 713 /*
 714  * Adds ibm,dynamic-reconfiguration-memory node.
 715  * Refer to docs/specs/ppc-spapr-hotplug.txt for the documentation
 716  * of this device tree node.
 717  */
 718 static int spapr_populate_drconf_memory(sPAPRMachineState *spapr, void *fdt)
 719 {
 720     MachineState *machine = MACHINE(spapr);
 721     int ret, i, offset;
 722     uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE;
 723     uint32_t prop_lmb_size[] = {0, cpu_to_be32(lmb_size)};
 724     uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size;
 725     uint32_t *int_buf, *cur_index, buf_len;
 726     int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1;
 727
 728     /*
 729      * Allocate enough buffer size to fit in ibm,dynamic-memory
 730      * or ibm,associativity-lookup-arrays
 731      */
 732     buf_len = MAX(nr_lmbs * SPAPR_DR_LMB_LIST_ENTRY_SIZE + 1, nr_nodes * 4 + 2)
 733               * sizeof(uint32_t);
 734     cur_index = int_buf = g_malloc0(buf_len);
 735
 736     offset = fdt_add_subnode(fdt, 0, "ibm,dynamic-reconfiguration-memory");
 737
 738     ret = fdt_setprop(fdt, offset, "ibm,lmb-size", prop_lmb_size,
 739                     sizeof(prop_lmb_size));
 740     if (ret < 0) {
 741         goto out;
 742     }
 743
 744     ret = fdt_setprop_cell(fdt, offset, "ibm,memory-flags-mask", 0xff);
 745     if (ret < 0) {
 746         goto out;
 747     }
 748
 749     ret = fdt_setprop_cell(fdt, offset, "ibm,memory-preservation-time", 0x0);
 750     if (ret < 0) {
 751         goto out;
 752     }
 753
 754     /* ibm,dynamic-memory */
 755     int_buf[0] = cpu_to_be32(nr_lmbs);
 756     cur_index++;
 757     for (i = 0; i < nr_lmbs; i++) {
 758         sPAPRDRConnector *drc;
 759         sPAPRDRConnectorClass *drck;
 760         uint64_t addr = i * lmb_size + spapr->hotplug_memory.base;;
 761         uint32_t *dynamic_memory = cur_index;
 762
 763         drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB,
 764                                        addr/lmb_size);
 765         g_assert(drc);
 766         drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
 767
 768         dynamic_memory[0] = cpu_to_be32(addr >> 32);
 769         dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff);
 770         dynamic_memory[2] = cpu_to_be32(drck->get_index(drc));
 771         dynamic_memory[3] = cpu_to_be32(0); /* reserved */
 772         dynamic_memory[4] = cpu_to_be32(numa_get_node(addr, NULL));
 773         if (addr < machine->ram_size ||
 774                     memory_region_present(get_system_memory(), addr)) {
 775             dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_ASSIGNED);
 776         } else {
 777             dynamic_memory[5] = cpu_to_be32(0);
 778         }
 779
 780         cur_index += SPAPR_DR_LMB_LIST_ENTRY_SIZE;
 781     }
 782     ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory", int_buf, buf_len);
 783     if (ret < 0) {
 784         goto out;
 785     }
 786
 787     /* ibm,associativity-lookup-arrays */
 788     cur_index = int_buf;
 789     int_buf[0] = cpu_to_be32(nr_nodes);
 790     int_buf[1] = cpu_to_be32(4); /* Number of entries per associativity list */
 791     cur_index += 2;
 792     for (i = 0; i < nr_nodes; i++) {
 793         uint32_t associativity[] = {
 794             cpu_to_be32(0x0),
 795             cpu_to_be32(0x0),
 796             cpu_to_be32(0x0),
 797             cpu_to_be32(i)
 798         };
 799         memcpy(cur_index, associativity, sizeof(associativity));
 800         cur_index += 4;
 801     }
 802     ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf,
 803             (cur_index - int_buf) * sizeof(uint32_t));
 804 out:
 805     g_free(int_buf);
 806     return ret;
 807 }
 808
 809 int spapr_h_cas_compose_response(sPAPRMachineState *spapr,
 810                                  target_ulong addr, target_ulong size,
 811                                  bool cpu_update, bool memory_update)
 812 {
 813     void *fdt, *fdt_skel;
 814     sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 };
 815     sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine());
 816
 817     size -= sizeof(hdr);
 818
 819     /* Create sceleton */
 820     fdt_skel = g_malloc0(size);
 821     _FDT((fdt_create(fdt_skel, size)));
 822     _FDT((fdt_begin_node(fdt_skel, "")));
 823     _FDT((fdt_end_node(fdt_skel)));
 824     _FDT((fdt_finish(fdt_skel)));
 825     fdt = g_malloc0(size);
 826     _FDT((fdt_open_into(fdt_skel, fdt, size)));
 827     g_free(fdt_skel);
 828
 829     /* Fixup cpu nodes */
 830     if (cpu_update) {
 831         _FDT((spapr_fixup_cpu_dt(fdt, spapr)));
 832     }
 833
 834     /* Generate memory nodes or ibm,dynamic-reconfiguration-memory node */
 835     if (memory_update && smc->dr_lmb_enabled) {
 836         _FDT((spapr_populate_drconf_memory(spapr, fdt)));
 837     }
 838
 839     /* Pack resulting tree */
 840     _FDT((fdt_pack(fdt)));
 841
 842     if (fdt_totalsize(fdt) + sizeof(hdr) > size) {
 843         trace_spapr_cas_failed(size);
 844         return -1;
 845     }
 846
 847     cpu_physical_memory_write(addr, &hdr, sizeof(hdr));
 848     cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt));
 849     trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr));
 850     g_free(fdt);
 851
 852     return 0;
 853 }
 854
 855 static void spapr_finalize_fdt(sPAPRMachineState *spapr,
 856                                hwaddr fdt_addr,
 857                                hwaddr rtas_addr,
 858                                hwaddr rtas_size)
 859 {
 860     MachineState *machine = MACHINE(qdev_get_machine());
 861     sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine);
 862     const char *boot_device = machine->boot_order;
 863     int ret, i;
 864     size_t cb = 0;
 865     char *bootlist;
 866     void *fdt;
 867     sPAPRPHBState *phb;
 868
 869     fdt = g_malloc(FDT_MAX_SIZE);
 870
 871     /* open out the base tree into a temp buffer for the final tweaks */
 872     _FDT((fdt_open_into(spapr->fdt_skel, fdt, FDT_MAX_SIZE)));
 873
 874     ret = spapr_populate_memory(spapr, fdt);
 875     if (ret < 0) {
 876         fprintf(stderr, "couldn't setup memory nodes in fdt\n");
 877         exit(1);
 878     }
 879
 880     ret = spapr_populate_vdevice(spapr->vio_bus, fdt);
 881     if (ret < 0) {
 882         fprintf(stderr, "couldn't setup vio devices in fdt\n");
 883         exit(1);
 884     }
 885
 886     QLIST_FOREACH(phb, &spapr->phbs, list) {
 887         ret = spapr_populate_pci_dt(phb, PHANDLE_XICP, fdt);
 888     }
 889
 890     if (ret < 0) {
 891         fprintf(stderr, "couldn't setup PCI devices in fdt\n");
 892         exit(1);
 893     }
 894
 895     /* RTAS */
 896     ret = spapr_rtas_device_tree_setup(fdt, rtas_addr, rtas_size);
 897     if (ret < 0) {
 898         fprintf(stderr, "Couldn't set up RTAS device tree properties\n");
 899     }
 900
 901     /* cpus */
 902     spapr_populate_cpus_dt_node(fdt, spapr);
 903
 904     bootlist = get_boot_devices_list(&cb, true);
 905     if (cb && bootlist) {
 906         int offset = fdt_path_offset(fdt, "/chosen");
 907         if (offset < 0) {
 908             exit(1);
 909         }
 910         for (i = 0; i < cb; i++) {
 911             if (bootlist[i] == '\n') {
 912                 bootlist[i] = ' ';
 913             }
 914
 915         }
 916         ret = fdt_setprop_string(fdt, offset, "qemu,boot-list", bootlist);
 917     }
 918
 919     if (boot_device && strlen(boot_device)) {
 920         int offset = fdt_path_offset(fdt, "/chosen");
 921
 922         if (offset < 0) {
 923             exit(1);
 924         }
 925         fdt_setprop_string(fdt, offset, "qemu,boot-device", boot_device);
 926     }
 927
 928     if (!spapr->has_graphics) {
 929         spapr_populate_chosen_stdout(fdt, spapr->vio_bus);
 930     }
 931
 932     if (smc->dr_lmb_enabled) {
 933         _FDT(spapr_drc_populate_dt(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_LMB));
 934     }
 935
 936     _FDT((fdt_pack(fdt)));
 937
 938     if (fdt_totalsize(fdt) > FDT_MAX_SIZE) {
 939         error_report("FDT too big ! 0x%x bytes (max is 0x%x)",
 940                      fdt_totalsize(fdt), FDT_MAX_SIZE);
 941         exit(1);
 942     }
 943
 944     qemu_fdt_dumpdtb(fdt, fdt_totalsize(fdt));
 945     cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt));
 946
 947     g_free(bootlist);
 948     g_free(fdt);
 949 }
 950
 951 static uint64_t translate_kernel_address(void *opaque, uint64_t addr)
 952 {
 953     return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR;
 954 }
 955
 956 static void emulate_spapr_hypercall(PowerPCCPU *cpu)
 957 {
 958     CPUPPCState *env = &cpu->env;
 959
 960     if (msr_pr) {
 961         hcall_dprintf("Hypercall made with MSR[PR]=1\n");
 962         env->gpr[3] = H_PRIVILEGE;
 963     } else {
 964         env->gpr[3] = spapr_hypercall(cpu, env->gpr[3], &env->gpr[4]);
 965     }
 966 }
 967
 968 #define HPTE(_table, _i)   (void *)(((uint64_t *)(_table)) + ((_i) * 2))
 969 #define HPTE_VALID(_hpte)  (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_VALID)
 970 #define HPTE_DIRTY(_hpte)  (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_HPTE_DIRTY)
 971 #define CLEAN_HPTE(_hpte)  ((*(uint64_t *)(_hpte)) &= tswap64(~HPTE64_V_HPTE_DIRTY))
 972 #define DIRTY_HPTE(_hpte)  ((*(uint64_t *)(_hpte)) |= tswap64(HPTE64_V_HPTE_DIRTY))
 973
 974 static void spapr_reset_htab(sPAPRMachineState *spapr)
 975 {
 976     long shift;
 977     int index;
 978
 979     /* allocate hash page table.  For now we always make this 16mb,
 980      * later we should probably make it scale to the size of guest
 981      * RAM */
 982
 983     shift = kvmppc_reset_htab(spapr->htab_shift);
 984
 985     if (shift > 0) {
 986         /* Kernel handles htab, we don't need to allocate one */
 987         spapr->htab_shift = shift;
 988         kvmppc_kern_htab = true;
 989
 990         /* Tell readers to update their file descriptor */
 991         if (spapr->htab_fd >= 0) {
 992             spapr->htab_fd_stale = true;
 993         }
 994     } else {
 995         if (!spapr->htab) {
 996             /* Allocate an htab if we don't yet have one */
 997             spapr->htab = qemu_memalign(HTAB_SIZE(spapr), HTAB_SIZE(spapr));
 998         }
 999
1000         /* And clear it */
1001         memset(spapr->htab, 0, HTAB_SIZE(spapr));
1002
1003         for (index = 0; index < HTAB_SIZE(spapr) / HASH_PTE_SIZE_64; index++) {
1004             DIRTY_HPTE(HPTE(spapr->htab, index));
1005         }
1006     }
1007
1008     /* Update the RMA size if necessary */
1009     if (spapr->vrma_adjust) {
1010         spapr->rma_size = kvmppc_rma_size(spapr_node0_size(),
1011                                           spapr->htab_shift);
1012     }
1013 }
1014
1015 static int find_unknown_sysbus_device(SysBusDevice *sbdev, void *opaque)
1016 {
1017     bool matched = false;
1018
1019     if (object_dynamic_cast(OBJECT(sbdev), TYPE_SPAPR_PCI_HOST_BRIDGE)) {
1020         matched = true;
1021     }
1022
1023     if (!matched) {
1024         error_report("Device %s is not supported by this machine yet.",
1025                      qdev_fw_name(DEVICE(sbdev)));
1026         exit(1);
1027     }
1028
1029     return 0;
1030 }
1031
1032 /*
1033  * A guest reset will cause spapr->htab_fd to become stale if being used.
1034  * Reopen the file descriptor to make sure the whole HTAB is properly read.
1035  */
1036 static int spapr_check_htab_fd(sPAPRMachineState *spapr)
1037 {
1038     int rc = 0;
1039
1040     if (spapr->htab_fd_stale) {
1041         close(spapr->htab_fd);
1042         spapr->htab_fd = kvmppc_get_htab_fd(false);
1043         if (spapr->htab_fd < 0) {
1044             error_report("Unable to open fd for reading hash table from KVM: "
1045                          "%s", strerror(errno));
1046             rc = -1;
1047         }
1048         spapr->htab_fd_stale = false;
1049     }
1050
1051     return rc;
1052 }
1053
1054 static void ppc_spapr_reset(void)
1055 {
1056     sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
1057     PowerPCCPU *first_ppc_cpu;
1058     uint32_t rtas_limit;
1059
1060     /* Check for unknown sysbus devices */
1061     foreach_dynamic_sysbus_device(find_unknown_sysbus_device, NULL);
1062
1063     /* Reset the hash table & recalc the RMA */
1064     spapr_reset_htab(spapr);
1065
1066     qemu_devices_reset();
1067
1068     /*
1069      * We place the device tree and RTAS just below either the top of the RMA,
1070      * or just below 2GB, whichever is lowere, so that it can be
1071      * processed with 32-bit real mode code if necessary
1072      */
1073     rtas_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR);
1074     spapr->rtas_addr = rtas_limit - RTAS_MAX_SIZE;
1075     spapr->fdt_addr = spapr->rtas_addr - FDT_MAX_SIZE;
1076
1077     /* Load the fdt */
1078     spapr_finalize_fdt(spapr, spapr->fdt_addr, spapr->rtas_addr,
1079                        spapr->rtas_size);
1080
1081     /* Copy RTAS over */
1082     cpu_physical_memory_write(spapr->rtas_addr, spapr->rtas_blob,
1083                               spapr->rtas_size);
1084
1085     /* Set up the entry state */
1086     first_ppc_cpu = POWERPC_CPU(first_cpu);
1087     first_ppc_cpu->env.gpr[3] = spapr->fdt_addr;
1088     first_ppc_cpu->env.gpr[5] = 0;
1089     first_cpu->halted = 0;
1090     first_ppc_cpu->env.nip = SPAPR_ENTRY_POINT;
1091
1092 }
1093
1094 static void spapr_cpu_reset(void *opaque)
1095 {
1096     sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
1097     PowerPCCPU *cpu = opaque;
1098     CPUState *cs = CPU(cpu);
1099     CPUPPCState *env = &cpu->env;
1100
1101     cpu_reset(cs);
1102
1103     /* All CPUs start halted.  CPU0 is unhalted from the machine level
1104      * reset code and the rest are explicitly started up by the guest
1105      * using an RTAS call */
1106     cs->halted = 1;
1107
1108     env->spr[SPR_HIOR] = 0;
1109
1110     env->external_htab = (uint8_t *)spapr->htab;
1111     if (kvm_enabled() && !env->external_htab) {
1112         /*
1113          * HV KVM, set external_htab to 1 so our ppc_hash64_load_hpte*
1114          * functions do the right thing.
1115          */
1116         env->external_htab = (void *)1;
1117     }
1118     env->htab_base = -1;
1119     /*
1120      * htab_mask is the mask used to normalize hash value to PTEG index.
1121      * htab_shift is log2 of hash table size.
1122      * We have 8 hpte per group, and each hpte is 16 bytes.
1123      * ie have 128 bytes per hpte entry.
1124      */
1125     env->htab_mask = (1ULL << (spapr->htab_shift - 7)) - 1;
1126     env->spr[SPR_SDR1] = (target_ulong)(uintptr_t)spapr->htab |
1127         (spapr->htab_shift - 18);
1128 }
1129
1130 static void spapr_create_nvram(sPAPRMachineState *spapr)
1131 {
1132     DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram");
1133     DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0);
1134
1135     if (dinfo) {
1136         qdev_prop_set_drive_nofail(dev, "drive", blk_by_legacy_dinfo(dinfo));
1137     }
1138
1139     qdev_init_nofail(dev);
1140
1141     spapr->nvram = (struct sPAPRNVRAM *)dev;
1142 }
1143
1144 static void spapr_rtc_create(sPAPRMachineState *spapr)
1145 {
1146     DeviceState *dev = qdev_create(NULL, TYPE_SPAPR_RTC);
1147
1148     qdev_init_nofail(dev);
1149     spapr->rtc = dev;
1150
1151     object_property_add_alias(qdev_get_machine(), "rtc-time",
1152                               OBJECT(spapr->rtc), "date", NULL);
1153 }
1154
1155 /* Returns whether we want to use VGA or not */
1156 static int spapr_vga_init(PCIBus *pci_bus)
1157 {
1158     switch (vga_interface_type) {
1159     case VGA_NONE:
1160         return false;
1161     case VGA_DEVICE:
1162         return true;
1163     case VGA_STD:
1164         return pci_vga_init(pci_bus) != NULL;
1165     default:
1166         fprintf(stderr, "This vga model is not supported,"
1167                 "currently it only supports -vga std\n");
1168         exit(0);
1169     }
1170 }
1171
1172 static int spapr_post_load(void *opaque, int version_id)
1173 {
1174     sPAPRMachineState *spapr = (sPAPRMachineState *)opaque;
1175     int err = 0;
1176
1177     /* In earlier versions, there was no separate qdev for the PAPR
1178      * RTC, so the RTC offset was stored directly in sPAPREnvironment.
1179      * So when migrating from those versions, poke the incoming offset
1180      * value into the RTC device */
1181     if (version_id < 3) {
1182         err = spapr_rtc_import_offset(spapr->rtc, spapr->rtc_offset);
1183     }
1184
1185     return err;
1186 }
1187
1188 static bool version_before_3(void *opaque, int version_id)
1189 {
1190     return version_id < 3;
1191 }
1192
1193 static const VMStateDescription vmstate_spapr = {
1194     .name = "spapr",
1195     .version_id = 3,
1196     .minimum_version_id = 1,
1197     .post_load = spapr_post_load,
1198     .fields = (VMStateField[]) {
1199         /* used to be @next_irq */
1200         VMSTATE_UNUSED_BUFFER(version_before_3, 0, 4),
1201
1202         /* RTC offset */
1203         VMSTATE_UINT64_TEST(rtc_offset, sPAPRMachineState, version_before_3),
1204
1205         VMSTATE_PPC_TIMEBASE_V(tb, sPAPRMachineState, 2),
1206         VMSTATE_END_OF_LIST()
1207     },
1208 };
1209
1210 static int htab_save_setup(QEMUFile *f, void *opaque)
1211 {
1212     sPAPRMachineState *spapr = opaque;
1213
1214     /* "Iteration" header */
1215     qemu_put_be32(f, spapr->htab_shift);
1216
1217     if (spapr->htab) {
1218         spapr->htab_save_index = 0;
1219         spapr->htab_first_pass = true;
1220     } else {
1221         assert(kvm_enabled());
1222
1223         spapr->htab_fd = kvmppc_get_htab_fd(false);
1224         spapr->htab_fd_stale = false;
1225         if (spapr->htab_fd < 0) {
1226             fprintf(stderr, "Unable to open fd for reading hash table from KVM: %s\n",
1227                     strerror(errno));
1228             return -1;
1229         }
1230     }
1231
1232
1233     return 0;
1234 }
1235
1236 static void htab_save_first_pass(QEMUFile *f, sPAPRMachineState *spapr,
1237                                  int64_t max_ns)
1238 {
1239     int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64;
1240     int index = spapr->htab_save_index;
1241     int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
1242
1243     assert(spapr->htab_first_pass);
1244
1245     do {
1246         int chunkstart;
1247
1248         /* Consume invalid HPTEs */
1249         while ((index < htabslots)
1250                && !HPTE_VALID(HPTE(spapr->htab, index))) {
1251             index++;
1252             CLEAN_HPTE(HPTE(spapr->htab, index));
1253         }
1254
1255         /* Consume valid HPTEs */
1256         chunkstart = index;
1257         while ((index < htabslots) && (index - chunkstart < USHRT_MAX)
1258                && HPTE_VALID(HPTE(spapr->htab, index))) {
1259             index++;
1260             CLEAN_HPTE(HPTE(spapr->htab, index));
1261         }
1262
1263         if (index > chunkstart) {
1264             int n_valid = index - chunkstart;
1265
1266             qemu_put_be32(f, chunkstart);
1267             qemu_put_be16(f, n_valid);
1268             qemu_put_be16(f, 0);
1269             qemu_put_buffer(f, HPTE(spapr->htab, chunkstart),
1270                             HASH_PTE_SIZE_64 * n_valid);
1271
1272             if ((qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) {
1273                 break;
1274             }
1275         }
1276     } while ((index < htabslots) && !qemu_file_rate_limit(f));
1277
1278     if (index >= htabslots) {
1279         assert(index == htabslots);
1280         index = 0;
1281         spapr->htab_first_pass = false;
1282     }
1283     spapr->htab_save_index = index;
1284 }
1285
1286 static int htab_save_later_pass(QEMUFile *f, sPAPRMachineState *spapr,
1287                                 int64_t max_ns)
1288 {
1289     bool final = max_ns < 0;
1290     int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64;
1291     int examined = 0, sent = 0;
1292     int index = spapr->htab_save_index;
1293     int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
1294
1295     assert(!spapr->htab_first_pass);
1296
1297     do {
1298         int chunkstart, invalidstart;
1299
1300         /* Consume non-dirty HPTEs */
1301         while ((index < htabslots)
1302                && !HPTE_DIRTY(HPTE(spapr->htab, index))) {
1303             index++;
1304             examined++;
1305         }
1306
1307         chunkstart = index;
1308         /* Consume valid dirty HPTEs */
1309         while ((index < htabslots) && (index - chunkstart < USHRT_MAX)
1310                && HPTE_DIRTY(HPTE(spapr->htab, index))
1311                && HPTE_VALID(HPTE(spapr->htab, index))) {
1312             CLEAN_HPTE(HPTE(spapr->htab, index));
1313             index++;
1314             examined++;
1315         }
1316
1317         invalidstart = index;
1318         /* Consume invalid dirty HPTEs */
1319         while ((index < htabslots) && (index - invalidstart < USHRT_MAX)
1320                && HPTE_DIRTY(HPTE(spapr->htab, index))
1321                && !HPTE_VALID(HPTE(spapr->htab, index))) {
1322             CLEAN_HPTE(HPTE(spapr->htab, index));
1323             index++;
1324             examined++;
1325         }
1326
1327         if (index > chunkstart) {
1328             int n_valid = invalidstart - chunkstart;
1329             int n_invalid = index - invalidstart;
1330
1331             qemu_put_be32(f, chunkstart);
1332             qemu_put_be16(f, n_valid);
1333             qemu_put_be16(f, n_invalid);
1334             qemu_put_buffer(f, HPTE(spapr->htab, chunkstart),
1335                             HASH_PTE_SIZE_64 * n_valid);
1336             sent += index - chunkstart;
1337
1338             if (!final && (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) {
1339                 break;
1340             }
1341         }
1342
1343         if (examined >= htabslots) {
1344             break;
1345         }
1346
1347         if (index >= htabslots) {
1348             assert(index == htabslots);
1349             index = 0;
1350         }
1351     } while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final));
1352
1353     if (index >= htabslots) {
1354         assert(index == htabslots);
1355         index = 0;
1356     }
1357
1358     spapr->htab_save_index = index;
1359
1360     return (examined >= htabslots) && (sent == 0) ? 1 : 0;
1361 }
1362
1363 #define MAX_ITERATION_NS    5000000 /* 5 ms */
1364 #define MAX_KVM_BUF_SIZE    2048
1365
1366 static int htab_save_iterate(QEMUFile *f, void *opaque)
1367 {
1368     sPAPRMachineState *spapr = opaque;
1369     int rc = 0;
1370
1371     /* Iteration header */
1372     qemu_put_be32(f, 0);
1373
1374     if (!spapr->htab) {
1375         assert(kvm_enabled());
1376
1377         rc = spapr_check_htab_fd(spapr);
1378         if (rc < 0) {
1379             return rc;
1380         }
1381
1382         rc = kvmppc_save_htab(f, spapr->htab_fd,
1383                               MAX_KVM_BUF_SIZE, MAX_ITERATION_NS);
1384         if (rc < 0) {
1385             return rc;
1386         }
1387     } else  if (spapr->htab_first_pass) {
1388         htab_save_first_pass(f, spapr, MAX_ITERATION_NS);
1389     } else {
1390         rc = htab_save_later_pass(f, spapr, MAX_ITERATION_NS);
1391     }
1392
1393     /* End marker */
1394     qemu_put_be32(f, 0);
1395     qemu_put_be16(f, 0);
1396     qemu_put_be16(f, 0);
1397
1398     return rc;
1399 }
1400
1401 static int htab_save_complete(QEMUFile *f, void *opaque)
1402 {
1403     sPAPRMachineState *spapr = opaque;
1404
1405     /* Iteration header */
1406     qemu_put_be32(f, 0);
1407
1408     if (!spapr->htab) {
1409         int rc;
1410
1411         assert(kvm_enabled());
1412
1413         rc = spapr_check_htab_fd(spapr);
1414         if (rc < 0) {
1415             return rc;
1416         }
1417
1418         rc = kvmppc_save_htab(f, spapr->htab_fd, MAX_KVM_BUF_SIZE, -1);
1419         if (rc < 0) {
1420             return rc;
1421         }
1422         close(spapr->htab_fd);
1423         spapr->htab_fd = -1;
1424     } else {
1425         htab_save_later_pass(f, spapr, -1);
1426     }
1427
1428     /* End marker */
1429     qemu_put_be32(f, 0);
1430     qemu_put_be16(f, 0);
1431     qemu_put_be16(f, 0);
1432
1433     return 0;
1434 }
1435
1436 static int htab_load(QEMUFile *f, void *opaque, int version_id)
1437 {
1438     sPAPRMachineState *spapr = opaque;
1439     uint32_t section_hdr;
1440     int fd = -1;
1441
1442     if (version_id < 1 || version_id > 1) {
1443         fprintf(stderr, "htab_load() bad version\n");
1444         return -EINVAL;
1445     }
1446
1447     section_hdr = qemu_get_be32(f);
1448
1449     if (section_hdr) {
1450         /* First section, just the hash shift */
1451         if (spapr->htab_shift != section_hdr) {
1452             error_report("htab_shift mismatch: source %d target %d",
1453                          section_hdr, spapr->htab_shift);
1454             return -EINVAL;
1455         }
1456         return 0;
1457     }
1458
1459     if (!spapr->htab) {
1460         assert(kvm_enabled());
1461
1462         fd = kvmppc_get_htab_fd(true);
1463         if (fd < 0) {
1464             fprintf(stderr, "Unable to open fd to restore KVM hash table: %s\n",
1465                     strerror(errno));
1466         }
1467     }
1468
1469     while (true) {
1470         uint32_t index;
1471         uint16_t n_valid, n_invalid;
1472
1473         index = qemu_get_be32(f);
1474         n_valid = qemu_get_be16(f);
1475         n_invalid = qemu_get_be16(f);
1476
1477         if ((index == 0) && (n_valid == 0) && (n_invalid == 0)) {
1478             /* End of Stream */
1479             break;
1480         }
1481
1482         if ((index + n_valid + n_invalid) >
1483             (HTAB_SIZE(spapr) / HASH_PTE_SIZE_64)) {
1484             /* Bad index in stream */
1485             fprintf(stderr, "htab_load() bad index %d (%hd+%hd entries) "
1486                     "in htab stream (htab_shift=%d)\n", index, n_valid, n_invalid,
1487                     spapr->htab_shift);
1488             return -EINVAL;
1489         }
1490
1491         if (spapr->htab) {
1492             if (n_valid) {
1493                 qemu_get_buffer(f, HPTE(spapr->htab, index),
1494                                 HASH_PTE_SIZE_64 * n_valid);
1495             }
1496             if (n_invalid) {
1497                 memset(HPTE(spapr->htab, index + n_valid), 0,
1498                        HASH_PTE_SIZE_64 * n_invalid);
1499             }
1500         } else {
1501             int rc;
1502
1503             assert(fd >= 0);
1504
1505             rc = kvmppc_load_htab_chunk(f, fd, index, n_valid, n_invalid);
1506             if (rc < 0) {
1507                 return rc;
1508             }
1509         }
1510     }
1511
1512     if (!spapr->htab) {
1513         assert(fd >= 0);
1514         close(fd);
1515     }
1516
1517     return 0;
1518 }
1519
1520 static SaveVMHandlers savevm_htab_handlers = {
1521     .save_live_setup = htab_save_setup,
1522     .save_live_iterate = htab_save_iterate,
1523     .save_live_complete = htab_save_complete,
1524     .load_state = htab_load,
1525 };
1526
1527 static void spapr_boot_set(void *opaque, const char *boot_device,
1528                            Error **errp)
1529 {
1530     MachineState *machine = MACHINE(qdev_get_machine());
1531     machine->boot_order = g_strdup(boot_device);
1532 }
1533
1534 static void spapr_cpu_init(sPAPRMachineState *spapr, PowerPCCPU *cpu)
1535 {
1536     CPUPPCState *env = &cpu->env;
1537
1538     /* Set time-base frequency to 512 MHz */
1539     cpu_ppc_tb_init(env, TIMEBASE_FREQ);
1540
1541     /* PAPR always has exception vectors in RAM not ROM. To ensure this,
1542      * MSR[IP] should never be set.
1543      */
1544     env->msr_mask &= ~(1 << 6);
1545
1546     /* Tell KVM that we're in PAPR mode */
1547     if (kvm_enabled()) {
1548         kvmppc_set_papr(cpu);
1549     }
1550
1551     if (cpu->max_compat) {
1552         if (ppc_set_compat(cpu, cpu->max_compat) < 0) {
1553             exit(1);
1554         }
1555     }
1556
1557     xics_cpu_setup(spapr->icp, cpu);
1558
1559     qemu_register_reset(spapr_cpu_reset, cpu);
1560 }
1561
1562 /*
1563  * Reset routine for LMB DR devices.
1564  *
1565  * Unlike PCI DR devices, LMB DR devices explicitly register this reset
1566  * routine. Reset for PCI DR devices will be handled by PHB reset routine
1567  * when it walks all its children devices. LMB devices reset occurs
1568  * as part of spapr_ppc_reset().
1569  */
1570 static void spapr_drc_reset(void *opaque)
1571 {
1572     sPAPRDRConnector *drc = opaque;
1573     DeviceState *d = DEVICE(drc);
1574
1575     if (d) {
1576         device_reset(d);
1577     }
1578 }
1579
1580 static void spapr_create_lmb_dr_connectors(sPAPRMachineState *spapr)
1581 {
1582     MachineState *machine = MACHINE(spapr);
1583     uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE;
1584     uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size;
1585     int i;
1586
1587     for (i = 0; i < nr_lmbs; i++) {
1588         sPAPRDRConnector *drc;
1589         uint64_t addr;
1590
1591         addr = i * lmb_size + spapr->hotplug_memory.base;
1592         drc = spapr_dr_connector_new(OBJECT(spapr), SPAPR_DR_CONNECTOR_TYPE_LMB,
1593                                      addr/lmb_size);
1594         qemu_register_reset(spapr_drc_reset, drc);
1595     }
1596 }
1597
1598 /*
1599  * If RAM size, maxmem size and individual node mem sizes aren't aligned
1600  * to SPAPR_MEMORY_BLOCK_SIZE(256MB), then refuse to start the guest
1601  * since we can't support such unaligned sizes with DRCONF_MEMORY.
1602  */
1603 static void spapr_validate_node_memory(MachineState *machine)
1604 {
1605     int i;
1606
1607     if (machine->maxram_size % SPAPR_MEMORY_BLOCK_SIZE ||
1608         machine->ram_size % SPAPR_MEMORY_BLOCK_SIZE) {
1609         error_report("Can't support memory configuration where RAM size "
1610                      "0x" RAM_ADDR_FMT " or maxmem size "
1611                      "0x" RAM_ADDR_FMT " isn't aligned to %llu MB",
1612                      machine->ram_size, machine->maxram_size,
1613                      SPAPR_MEMORY_BLOCK_SIZE/M_BYTE);
1614         exit(EXIT_FAILURE);
1615     }
1616
1617     for (i = 0; i < nb_numa_nodes; i++) {
1618         if (numa_info[i].node_mem % SPAPR_MEMORY_BLOCK_SIZE) {
1619             error_report("Can't support memory configuration where memory size"
1620                          " %" PRIx64 " of node %d isn't aligned to %llu MB",
1621                          numa_info[i].node_mem, i,
1622                          SPAPR_MEMORY_BLOCK_SIZE/M_BYTE);
1623             exit(EXIT_FAILURE);
1624         }
1625     }
1626 }
1627
1628 /* pSeries LPAR / sPAPR hardware init */
1629 static void ppc_spapr_init(MachineState *machine)
1630 {
1631     sPAPRMachineState *spapr = SPAPR_MACHINE(machine);
1632     sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine);
1633     const char *kernel_filename = machine->kernel_filename;
1634     const char *kernel_cmdline = machine->kernel_cmdline;
1635     const char *initrd_filename = machine->initrd_filename;
1636     PowerPCCPU *cpu;
1637     PCIHostState *phb;
1638     int i;
1639     MemoryRegion *sysmem = get_system_memory();
1640     MemoryRegion *ram = g_new(MemoryRegion, 1);
1641     MemoryRegion *rma_region;
1642     void *rma = NULL;
1643     hwaddr rma_alloc_size;
1644     hwaddr node0_size = spapr_node0_size();
1645     uint32_t initrd_base = 0;
1646     long kernel_size = 0, initrd_size = 0;
1647     long load_limit, fw_size;
1648     bool kernel_le = false;
1649     char *filename;
1650
1651     msi_supported = true;
1652
1653     QLIST_INIT(&spapr->phbs);
1654
1655     cpu_ppc_hypercall = emulate_spapr_hypercall;
1656
1657     /* Allocate RMA if necessary */
1658     rma_alloc_size = kvmppc_alloc_rma(&rma);
1659
1660     if (rma_alloc_size == -1) {
1661         error_report("Unable to create RMA");
1662         exit(1);
1663     }
1664
1665     if (rma_alloc_size && (rma_alloc_size < node0_size)) {
1666         spapr->rma_size = rma_alloc_size;
1667     } else {
1668         spapr->rma_size = node0_size;
1669
1670         /* With KVM, we don't actually know whether KVM supports an
1671          * unbounded RMA (PR KVM) or is limited by the hash table size
1672          * (HV KVM using VRMA), so we always assume the latter
1673          *
1674          * In that case, we also limit the initial allocations for RTAS
1675          * etc... to 256M since we have no way to know what the VRMA size
1676          * is going to be as it depends on the size of the hash table
1677          * isn't determined yet.
1678          */
1679         if (kvm_enabled()) {
1680             spapr->vrma_adjust = 1;
1681             spapr->rma_size = MIN(spapr->rma_size, 0x10000000);
1682         }
1683     }
1684
1685     if (spapr->rma_size > node0_size) {
1686         fprintf(stderr, "Error: Numa node 0 has to span the RMA (%#08"HWADDR_PRIx")\n",
1687                 spapr->rma_size);
1688         exit(1);
1689     }
1690
1691     /* Setup a load limit for the ramdisk leaving room for SLOF and FDT */
1692     load_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR) - FW_OVERHEAD;
1693
1694     /* We aim for a hash table of size 1/128 the size of RAM.  The
1695      * normal rule of thumb is 1/64 the size of RAM, but that's much
1696      * more than needed for the Linux guests we support. */
1697     spapr->htab_shift = 18; /* Minimum architected size */
1698     while (spapr->htab_shift <= 46) {
1699         if ((1ULL << (spapr->htab_shift + 7)) >= machine->maxram_size) {
1700             break;
1701         }
1702         spapr->htab_shift++;
1703     }
1704
1705     /* Set up Interrupt Controller before we create the VCPUs */
1706     spapr->icp = xics_system_init(machine,
1707                                   DIV_ROUND_UP(max_cpus * kvmppc_smt_threads(),
1708                                                smp_threads),
1709                                   XICS_IRQS);
1710
1711     if (smc->dr_lmb_enabled) {
1712         spapr_validate_node_memory(machine);
1713     }
1714
1715     /* init CPUs */
1716     if (machine->cpu_model == NULL) {
1717         machine->cpu_model = kvm_enabled() ? "host" : "POWER7";
1718     }
1719     for (i = 0; i < smp_cpus; i++) {
1720         cpu = cpu_ppc_init(machine->cpu_model);
1721         if (cpu == NULL) {
1722             fprintf(stderr, "Unable to find PowerPC CPU definition\n");
1723             exit(1);
1724         }
1725         spapr_cpu_init(spapr, cpu);
1726     }
1727
1728     if (kvm_enabled()) {
1729         /* Enable H_LOGICAL_CI_* so SLOF can talk to in-kernel devices */
1730         kvmppc_enable_logical_ci_hcalls();
1731         kvmppc_enable_set_mode_hcall();
1732     }
1733
1734     /* allocate RAM */
1735     memory_region_allocate_system_memory(ram, NULL, "ppc_spapr.ram",
1736                                          machine->ram_size);
1737     memory_region_add_subregion(sysmem, 0, ram);
1738
1739     if (rma_alloc_size && rma) {
1740         rma_region = g_new(MemoryRegion, 1);
1741         memory_region_init_ram_ptr(rma_region, NULL, "ppc_spapr.rma",
1742                                    rma_alloc_size, rma);
1743         vmstate_register_ram_global(rma_region);
1744         memory_region_add_subregion(sysmem, 0, rma_region);
1745     }
1746
1747     /* initialize hotplug memory address space */
1748     if (machine->ram_size < machine->maxram_size) {
1749         ram_addr_t hotplug_mem_size = machine->maxram_size - machine->ram_size;
1750
1751         if (machine->ram_slots > SPAPR_MAX_RAM_SLOTS) {
1752             error_report("Specified number of memory slots %"PRIu64" exceeds max supported %d\n",
1753                          machine->ram_slots, SPAPR_MAX_RAM_SLOTS);
1754             exit(EXIT_FAILURE);
1755         }
1756
1757         spapr->hotplug_memory.base = ROUND_UP(machine->ram_size,
1758                                               SPAPR_HOTPLUG_MEM_ALIGN);
1759         memory_region_init(&spapr->hotplug_memory.mr, OBJECT(spapr),
1760                            "hotplug-memory", hotplug_mem_size);
1761         memory_region_add_subregion(sysmem, spapr->hotplug_memory.base,
1762                                     &spapr->hotplug_memory.mr);
1763     }
1764
1765     if (smc->dr_lmb_enabled) {
1766         spapr_create_lmb_dr_connectors(spapr);
1767     }
1768
1769     filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin");
1770     if (!filename) {
1771         error_report("Could not find LPAR rtas '%s'", "spapr-rtas.bin");
1772         exit(1);
1773     }
1774     spapr->rtas_size = get_image_size(filename);
1775     spapr->rtas_blob = g_malloc(spapr->rtas_size);
1776     if (load_image_size(filename, spapr->rtas_blob, spapr->rtas_size) < 0) {
1777         error_report("Could not load LPAR rtas '%s'", filename);
1778         exit(1);
1779     }
1780     if (spapr->rtas_size > RTAS_MAX_SIZE) {
1781         error_report("RTAS too big ! 0x%zx bytes (max is 0x%x)",
1782                      (size_t)spapr->rtas_size, RTAS_MAX_SIZE);
1783         exit(1);
1784     }
1785     g_free(filename);
1786
1787     /* Set up EPOW events infrastructure */
1788     spapr_events_init(spapr);
1789
1790     /* Set up the RTC RTAS interfaces */
1791     spapr_rtc_create(spapr);
1792
1793     /* Set up VIO bus */
1794     spapr->vio_bus = spapr_vio_bus_init();
1795
1796     for (i = 0; i < MAX_SERIAL_PORTS; i++) {
1797         if (serial_hds[i]) {
1798             spapr_vty_create(spapr->vio_bus, serial_hds[i]);
1799         }
1800     }
1801
1802     /* We always have at least the nvram device on VIO */
1803     spapr_create_nvram(spapr);
1804
1805     /* Set up PCI */
1806     spapr_pci_rtas_init();
1807
1808     phb = spapr_create_phb(spapr, 0);
1809
1810     for (i = 0; i < nb_nics; i++) {
1811         NICInfo *nd = &nd_table[i];
1812
1813         if (!nd->model) {
1814             nd->model = g_strdup("ibmveth");
1815         }
1816
1817         if (strcmp(nd->model, "ibmveth") == 0) {
1818             spapr_vlan_create(spapr->vio_bus, nd);
1819         } else {
1820             pci_nic_init_nofail(&nd_table[i], phb->bus, nd->model, NULL);
1821         }
1822     }
1823
1824     for (i = 0; i <= drive_get_max_bus(IF_SCSI); i++) {
1825         spapr_vscsi_create(spapr->vio_bus);
1826     }
1827
1828     /* Graphics */
1829     if (spapr_vga_init(phb->bus)) {
1830         spapr->has_graphics = true;
1831         machine->usb |= defaults_enabled() && !machine->usb_disabled;
1832     }
1833
1834     if (machine->usb) {
1835         pci_create_simple(phb->bus, -1, "pci-ohci");
1836
1837         if (spapr->has_graphics) {
1838             USBBus *usb_bus = usb_bus_find(-1);
1839
1840             usb_create_simple(usb_bus, "usb-kbd");
1841             usb_create_simple(usb_bus, "usb-mouse");
1842         }
1843     }
1844
1845     if (spapr->rma_size < (MIN_RMA_SLOF << 20)) {
1846         fprintf(stderr, "qemu: pSeries SLOF firmware requires >= "
1847                 "%ldM guest RMA (Real Mode Area memory)\n", MIN_RMA_SLOF);
1848         exit(1);
1849     }
1850
1851     if (kernel_filename) {
1852         uint64_t lowaddr = 0;
1853
1854         kernel_size = load_elf(kernel_filename, translate_kernel_address, NULL,
1855                                NULL, &lowaddr, NULL, 1, ELF_MACHINE, 0);
1856         if (kernel_size == ELF_LOAD_WRONG_ENDIAN) {
1857             kernel_size = load_elf(kernel_filename,
1858                                    translate_kernel_address, NULL,
1859                                    NULL, &lowaddr, NULL, 0, ELF_MACHINE, 0);
1860             kernel_le = kernel_size > 0;
1861         }
1862         if (kernel_size < 0) {
1863             fprintf(stderr, "qemu: error loading %s: %s\n",
1864                     kernel_filename, load_elf_strerror(kernel_size));
1865             exit(1);
1866         }
1867
1868         /* load initrd */
1869         if (initrd_filename) {
1870             /* Try to locate the initrd in the gap between the kernel
1871              * and the firmware. Add a bit of space just in case
1872              */
1873             initrd_base = (KERNEL_LOAD_ADDR + kernel_size + 0x1ffff) & ~0xffff;
1874             initrd_size = load_image_targphys(initrd_filename, initrd_base,
1875                                               load_limit - initrd_base);
1876             if (initrd_size < 0) {
1877                 fprintf(stderr, "qemu: could not load initial ram disk '%s'\n",
1878                         initrd_filename);
1879                 exit(1);
1880             }
1881         } else {
1882             initrd_base = 0;
1883             initrd_size = 0;
1884         }
1885     }
1886
1887     if (bios_name == NULL) {
1888         bios_name = FW_FILE_NAME;
1889     }
1890     filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
1891     if (!filename) {
1892         error_report("Could not find LPAR firmware '%s'", bios_name);
1893         exit(1);
1894     }
1895     fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE);
1896     if (fw_size <= 0) {
1897         error_report("Could not load LPAR firmware '%s'", filename);
1898         exit(1);
1899     }
1900     g_free(filename);
1901
1902     /* FIXME: Should register things through the MachineState's qdev
1903      * interface, this is a legacy from the sPAPREnvironment structure
1904      * which predated MachineState but had a similar function */
1905     vmstate_register(NULL, 0, &vmstate_spapr, spapr);
1906     register_savevm_live(NULL, "spapr/htab", -1, 1,
1907                          &savevm_htab_handlers, spapr);
1908
1909     /* Prepare the device tree */
1910     spapr->fdt_skel = spapr_create_fdt_skel(initrd_base, initrd_size,
1911                                             kernel_size, kernel_le,
1912                                             kernel_cmdline,
1913                                             spapr->check_exception_irq);
1914     assert(spapr->fdt_skel != NULL);
1915
1916     /* used by RTAS */
1917     QTAILQ_INIT(&spapr->ccs_list);
1918     qemu_register_reset(spapr_ccs_reset_hook, spapr);
1919
1920     qemu_register_boot_set(spapr_boot_set, spapr);
1921 }
1922
1923 static int spapr_kvm_type(const char *vm_type)
1924 {
1925     if (!vm_type) {
1926         return 0;
1927     }
1928
1929     if (!strcmp(vm_type, "HV")) {
1930         return 1;
1931     }
1932
1933     if (!strcmp(vm_type, "PR")) {
1934         return 2;
1935     }
1936
1937     error_report("Unknown kvm-type specified '%s'", vm_type);
1938     exit(1);
1939 }
1940
1941 /*
1942  * Implementation of an interface to adjust firmware path
1943  * for the bootindex property handling.
1944  */
1945 static char *spapr_get_fw_dev_path(FWPathProvider *p, BusState *bus,
1946                                    DeviceState *dev)
1947 {
1948 #define CAST(type, obj, name) \
1949     ((type *)object_dynamic_cast(OBJECT(obj), (name)))
1950     SCSIDevice *d = CAST(SCSIDevice,  dev, TYPE_SCSI_DEVICE);
1951     sPAPRPHBState *phb = CAST(sPAPRPHBState, dev, TYPE_SPAPR_PCI_HOST_BRIDGE);
1952
1953     if (d) {
1954         void *spapr = CAST(void, bus->parent, "spapr-vscsi");
1955         VirtIOSCSI *virtio = CAST(VirtIOSCSI, bus->parent, TYPE_VIRTIO_SCSI);
1956         USBDevice *usb = CAST(USBDevice, bus->parent, TYPE_USB_DEVICE);
1957
1958         if (spapr) {
1959             /*
1960              * Replace "channel@0/disk@0,0" with "disk@8000000000000000":
1961              * We use SRP luns of the form 8000 | (bus << 8) | (id << 5) | lun
1962              * in the top 16 bits of the 64-bit LUN
1963              */
1964             unsigned id = 0x8000 | (d->id << 8) | d->lun;
1965             return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev),
1966                                    (uint64_t)id << 48);
1967         } else if (virtio) {
1968             /*
1969              * We use SRP luns of the form 01000000 | (target << 8) | lun
1970              * in the top 32 bits of the 64-bit LUN
1971              * Note: the quote above is from SLOF and it is wrong,
1972              * the actual binding is:
1973              * swap 0100 or 10 << or 20 << ( target lun-id -- srplun )
1974              */
1975             unsigned id = 0x1000000 | (d->id << 16) | d->lun;
1976             return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev),
1977                                    (uint64_t)id << 32);
1978         } else if (usb) {
1979             /*
1980              * We use SRP luns of the form 01000000 | (usb-port << 16) | lun
1981              * in the top 32 bits of the 64-bit LUN
1982              */
1983             unsigned usb_port = atoi(usb->port->path);
1984             unsigned id = 0x1000000 | (usb_port << 16) | d->lun;
1985             return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev),
1986                                    (uint64_t)id << 32);
1987         }
1988     }
1989
1990     if (phb) {
1991         /* Replace "pci" with "pci@800000020000000" */
1992         return g_strdup_printf("pci@%"PRIX64, phb->buid);
1993     }
1994
1995     return NULL;
1996 }
1997
1998 static char *spapr_get_kvm_type(Object *obj, Error **errp)
1999 {
2000     sPAPRMachineState *spapr = SPAPR_MACHINE(obj);
2001
2002     return g_strdup(spapr->kvm_type);
2003 }
2004
2005 static void spapr_set_kvm_type(Object *obj, const char *value, Error **errp)
2006 {
2007     sPAPRMachineState *spapr = SPAPR_MACHINE(obj);
2008
2009     g_free(spapr->kvm_type);
2010     spapr->kvm_type = g_strdup(value);
2011 }
2012
2013 static void spapr_machine_initfn(Object *obj)
2014 {
2015     object_property_add_str(obj, "kvm-type",
2016                             spapr_get_kvm_type, spapr_set_kvm_type, NULL);
2017     object_property_set_description(obj, "kvm-type",
2018                                     "Specifies the KVM virtualization mode (HV, PR)",
2019                                     NULL);
2020 }
2021
2022 static void ppc_cpu_do_nmi_on_cpu(void *arg)
2023 {
2024     CPUState *cs = arg;
2025
2026     cpu_synchronize_state(cs);
2027     ppc_cpu_do_system_reset(cs);
2028 }
2029
2030 static void spapr_nmi(NMIState *n, int cpu_index, Error **errp)
2031 {
2032     CPUState *cs;
2033
2034     CPU_FOREACH(cs) {
2035         async_run_on_cpu(cs, ppc_cpu_do_nmi_on_cpu, cs);
2036     }
2037 }
2038
2039 static void spapr_add_lmbs(DeviceState *dev, uint64_t addr, uint64_t size,
2040                            uint32_t node, Error **errp)
2041 {
2042     sPAPRDRConnector *drc;
2043     sPAPRDRConnectorClass *drck;
2044     uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE;
2045     int i, fdt_offset, fdt_size;
2046     void *fdt;
2047
2048     /*
2049      * Check for DRC connectors and send hotplug notification to the
2050      * guest only in case of hotplugged memory. This allows cold plugged
2051      * memory to be specified at boot time.
2052      */
2053     if (!dev->hotplugged) {
2054         return;
2055     }
2056
2057     for (i = 0; i < nr_lmbs; i++) {
2058         drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB,
2059                 addr/SPAPR_MEMORY_BLOCK_SIZE);
2060         g_assert(drc);
2061
2062         fdt = create_device_tree(&fdt_size);
2063         fdt_offset = spapr_populate_memory_node(fdt, node, addr,
2064                                                 SPAPR_MEMORY_BLOCK_SIZE);
2065
2066         drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
2067         drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, errp);
2068         addr += SPAPR_MEMORY_BLOCK_SIZE;
2069     }
2070     spapr_hotplug_req_add_by_count(SPAPR_DR_CONNECTOR_TYPE_LMB, nr_lmbs);
2071 }
2072
2073 static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev,
2074                               uint32_t node, Error **errp)
2075 {
2076     Error *local_err = NULL;
2077     sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev);
2078     PCDIMMDevice *dimm = PC_DIMM(dev);
2079     PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm);
2080     MemoryRegion *mr = ddc->get_memory_region(dimm);
2081     uint64_t align = memory_region_get_alignment(mr);
2082     uint64_t size = memory_region_size(mr);
2083     uint64_t addr;
2084
2085     if (size % SPAPR_MEMORY_BLOCK_SIZE) {
2086         error_setg(&local_err, "Hotplugged memory size must be a multiple of "
2087                       "%lld MB", SPAPR_MEMORY_BLOCK_SIZE/M_BYTE);
2088         goto out;
2089     }
2090
2091     pc_dimm_memory_plug(dev, &ms->hotplug_memory, mr, align, &local_err);
2092     if (local_err) {
2093         goto out;
2094     }
2095
2096     addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err);
2097     if (local_err) {
2098         pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr);
2099         goto out;
2100     }
2101
2102     spapr_add_lmbs(dev, addr, size, node, &error_abort);
2103
2104 out:
2105     error_propagate(errp, local_err);
2106 }
2107
2108 static void spapr_machine_device_plug(HotplugHandler *hotplug_dev,
2109                                       DeviceState *dev, Error **errp)
2110 {
2111     sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine());
2112
2113     if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) {
2114         int node;
2115
2116         if (!smc->dr_lmb_enabled) {
2117             error_setg(errp, "Memory hotplug not supported for this machine");
2118             return;
2119         }
2120         node = object_property_get_int(OBJECT(dev), PC_DIMM_NODE_PROP, errp);
2121         if (*errp) {
2122             return;
2123         }
2124
2125         /*
2126          * Currently PowerPC kernel doesn't allow hot-adding memory to
2127          * memory-less node, but instead will silently add the memory
2128          * to the first node that has some memory. This causes two
2129          * unexpected behaviours for the user.
2130          *
2131          * - Memory gets hotplugged to a different node than what the user
2132          *   specified.
2133          * - Since pc-dimm subsystem in QEMU still thinks that memory belongs
2134          *   to memory-less node, a reboot will set things accordingly
2135          *   and the previously hotplugged memory now ends in the right node.
2136          *   This appears as if some memory moved from one node to another.
2137          *
2138          * So until kernel starts supporting memory hotplug to memory-less
2139          * nodes, just prevent such attempts upfront in QEMU.
2140          */
2141         if (nb_numa_nodes && !numa_info[node].node_mem) {
2142             error_setg(errp, "Can't hotplug memory to memory-less node %d",
2143                        node);
2144             return;
2145         }
2146
2147         spapr_memory_plug(hotplug_dev, dev, node, errp);
2148     }
2149 }
2150
2151 static void spapr_machine_device_unplug(HotplugHandler *hotplug_dev,
2152                                       DeviceState *dev, Error **errp)
2153 {
2154     if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) {
2155         error_setg(errp, "Memory hot unplug not supported by sPAPR");
2156     }
2157 }
2158
2159 static HotplugHandler *spapr_get_hotpug_handler(MachineState *machine,
2160                                              DeviceState *dev)
2161 {
2162     if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) {
2163         return HOTPLUG_HANDLER(machine);
2164     }
2165     return NULL;
2166 }
2167
2168 static unsigned spapr_cpu_index_to_socket_id(unsigned cpu_index)
2169 {
2170     /* Allocate to NUMA nodes on a "socket" basis (not that concept of
2171      * socket means much for the paravirtualized PAPR platform) */
2172     return cpu_index / smp_threads / smp_cores;
2173 }
2174
2175 static void spapr_machine_class_init(ObjectClass *oc, void *data)
2176 {
2177     MachineClass *mc = MACHINE_CLASS(oc);
2178     sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc);
2179     FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc);
2180     NMIClass *nc = NMI_CLASS(oc);
2181     HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc);
2182
2183     mc->init = ppc_spapr_init;
2184     mc->reset = ppc_spapr_reset;
2185     mc->block_default_type = IF_SCSI;
2186     mc->max_cpus = MAX_CPUMASK_BITS;
2187     mc->no_parallel = 1;
2188     mc->default_boot_order = "";
2189     mc->default_ram_size = 512 * M_BYTE;
2190     mc->kvm_type = spapr_kvm_type;
2191     mc->has_dynamic_sysbus = true;
2192     mc->pci_allow_0_address = true;
2193     mc->get_hotplug_handler = spapr_get_hotpug_handler;
2194     hc->plug = spapr_machine_device_plug;
2195     hc->unplug = spapr_machine_device_unplug;
2196     mc->cpu_index_to_socket_id = spapr_cpu_index_to_socket_id;
2197
2198     smc->dr_lmb_enabled = false;
2199     fwc->get_dev_path = spapr_get_fw_dev_path;
2200     nc->nmi_monitor_handler = spapr_nmi;
2201 }
2202
2203 static const TypeInfo spapr_machine_info = {
2204     .name          = TYPE_SPAPR_MACHINE,
2205     .parent        = TYPE_MACHINE,
2206     .abstract      = true,
2207     .instance_size = sizeof(sPAPRMachineState),
2208     .instance_init = spapr_machine_initfn,
2209     .class_size    = sizeof(sPAPRMachineClass),
2210     .class_init    = spapr_machine_class_init,
2211     .interfaces = (InterfaceInfo[]) {
2212         { TYPE_FW_PATH_PROVIDER },
2213         { TYPE_NMI },
2214         { TYPE_HOTPLUG_HANDLER },
2215         { }
2216     },
2217 };
2218
2219 #define SPAPR_COMPAT_2_3 \
2220         HW_COMPAT_2_3 \
2221         {\
2222             .driver   = "spapr-pci-host-bridge",\
2223             .property = "dynamic-reconfiguration",\
2224             .value    = "off",\
2225         },
2226
2227 #define SPAPR_COMPAT_2_2 \
2228         SPAPR_COMPAT_2_3 \
2229         HW_COMPAT_2_2 \
2230         {\
2231             .driver   = TYPE_SPAPR_PCI_HOST_BRIDGE,\
2232             .property = "mem_win_size",\
2233             .value    = "0x20000000",\
2234         },
2235
2236 #define SPAPR_COMPAT_2_1 \
2237         SPAPR_COMPAT_2_2 \
2238         HW_COMPAT_2_1
2239
2240 static void spapr_compat_2_3(Object *obj)
2241 {
2242     savevm_skip_section_footers();
2243     global_state_set_optional();
2244 }
2245
2246 static void spapr_compat_2_2(Object *obj)
2247 {
2248     spapr_compat_2_3(obj);
2249 }
2250
2251 static void spapr_compat_2_1(Object *obj)
2252 {
2253     spapr_compat_2_2(obj);
2254 }
2255
2256 static void spapr_machine_2_3_instance_init(Object *obj)
2257 {
2258     spapr_compat_2_3(obj);
2259     spapr_machine_initfn(obj);
2260 }
2261
2262 static void spapr_machine_2_2_instance_init(Object *obj)
2263 {
2264     spapr_compat_2_2(obj);
2265     spapr_machine_initfn(obj);
2266 }
2267
2268 static void spapr_machine_2_1_instance_init(Object *obj)
2269 {
2270     spapr_compat_2_1(obj);
2271     spapr_machine_initfn(obj);
2272 }
2273
2274 static void spapr_machine_2_1_class_init(ObjectClass *oc, void *data)
2275 {
2276     MachineClass *mc = MACHINE_CLASS(oc);
2277     static GlobalProperty compat_props[] = {
2278         SPAPR_COMPAT_2_1
2279         { /* end of list */ }
2280     };
2281
2282     mc->desc = "pSeries Logical Partition (PAPR compliant) v2.1";
2283     mc->compat_props = compat_props;
2284 }
2285
2286 static const TypeInfo spapr_machine_2_1_info = {
2287     .name          = MACHINE_TYPE_NAME("pseries-2.1"),
2288     .parent        = TYPE_SPAPR_MACHINE,
2289     .class_init    = spapr_machine_2_1_class_init,
2290     .instance_init = spapr_machine_2_1_instance_init,
2291 };
2292
2293 static void spapr_machine_2_2_class_init(ObjectClass *oc, void *data)
2294 {
2295     static GlobalProperty compat_props[] = {
2296         SPAPR_COMPAT_2_2
2297         { /* end of list */ }
2298     };
2299     MachineClass *mc = MACHINE_CLASS(oc);
2300
2301     mc->desc = "pSeries Logical Partition (PAPR compliant) v2.2";
2302     mc->compat_props = compat_props;
2303 }
2304
2305 static const TypeInfo spapr_machine_2_2_info = {
2306     .name          = MACHINE_TYPE_NAME("pseries-2.2"),
2307     .parent        = TYPE_SPAPR_MACHINE,
2308     .class_init    = spapr_machine_2_2_class_init,
2309     .instance_init = spapr_machine_2_2_instance_init,
2310 };
2311
2312 static void spapr_machine_2_3_class_init(ObjectClass *oc, void *data)
2313 {
2314     static GlobalProperty compat_props[] = {
2315         SPAPR_COMPAT_2_3
2316         { /* end of list */ }
2317     };
2318     MachineClass *mc = MACHINE_CLASS(oc);
2319
2320     mc->desc = "pSeries Logical Partition (PAPR compliant) v2.3";
2321     mc->compat_props = compat_props;
2322 }
2323
2324 static const TypeInfo spapr_machine_2_3_info = {
2325     .name          = MACHINE_TYPE_NAME("pseries-2.3"),
2326     .parent        = TYPE_SPAPR_MACHINE,
2327     .class_init    = spapr_machine_2_3_class_init,
2328     .instance_init = spapr_machine_2_3_instance_init,
2329 };
2330
2331 static void spapr_machine_2_4_class_init(ObjectClass *oc, void *data)
2332 {
2333     MachineClass *mc = MACHINE_CLASS(oc);
2334
2335     mc->desc = "pSeries Logical Partition (PAPR compliant) v2.4";
2336     mc->alias = "pseries";
2337     mc->is_default = 0;
2338 }
2339
2340 static const TypeInfo spapr_machine_2_4_info = {
2341     .name          = MACHINE_TYPE_NAME("pseries-2.4"),
2342     .parent        = TYPE_SPAPR_MACHINE,
2343     .class_init    = spapr_machine_2_4_class_init,
2344 };
2345
2346 static void spapr_machine_2_5_class_init(ObjectClass *oc, void *data)
2347 {
2348     MachineClass *mc = MACHINE_CLASS(oc);
2349     sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc);
2350
2351     mc->name = "pseries-2.5";
2352     mc->desc = "pSeries Logical Partition (PAPR compliant) v2.5";
2353     mc->alias = "pseries";
2354     mc->is_default = 1;
2355     smc->dr_lmb_enabled = true;
2356 }
2357
2358 static const TypeInfo spapr_machine_2_5_info = {
2359     .name          = MACHINE_TYPE_NAME("pseries-2.5"),
2360     .parent        = TYPE_SPAPR_MACHINE,
2361     .class_init    = spapr_machine_2_5_class_init,
2362 };
2363
2364 static void spapr_machine_register_types(void)
2365 {
2366     type_register_static(&spapr_machine_info);
2367     type_register_static(&spapr_machine_2_1_info);
2368     type_register_static(&spapr_machine_2_2_info);
2369     type_register_static(&spapr_machine_2_3_info);
2370     type_register_static(&spapr_machine_2_4_info);
2371     type_register_static(&spapr_machine_2_5_info);
2372 }
2373
2374 type_init(spapr_machine_register_types)