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 "qemu/osdep.h"
  28 #include "qemu-common.h"
  29 #include "qapi/error.h"
  30 #include "qapi/visitor.h"
  31 #include "sysemu/sysemu.h"
  32 #include "sysemu/hostmem.h"
  33 #include "sysemu/numa.h"
  34 #include "sysemu/qtest.h"
  35 #include "sysemu/reset.h"
  36 #include "sysemu/runstate.h"
  37 #include "qemu/log.h"
  38 #include "hw/fw-path-provider.h"
  39 #include "elf.h"
  40 #include "net/net.h"
  41 #include "sysemu/device_tree.h"
  42 #include "sysemu/cpus.h"
  43 #include "sysemu/hw_accel.h"
  44 #include "kvm_ppc.h"
  45 #include "migration/misc.h"
  46 #include "migration/qemu-file-types.h"
  47 #include "migration/global_state.h"
  48 #include "migration/register.h"
  49 #include "mmu-hash64.h"
  50 #include "mmu-book3s-v3.h"
  51 #include "cpu-models.h"
  52 #include "hw/core/cpu.h"
  53
  54 #include "hw/boards.h"
  55 #include "hw/ppc/ppc.h"
  56 #include "hw/loader.h"
  57
  58 #include "hw/ppc/fdt.h"
  59 #include "hw/ppc/spapr.h"
  60 #include "hw/ppc/spapr_vio.h"
  61 #include "hw/qdev-properties.h"
  62 #include "hw/pci-host/spapr.h"
  63 #include "hw/pci/msi.h"
  64
  65 #include "hw/pci/pci.h"
  66 #include "hw/scsi/scsi.h"
  67 #include "hw/virtio/virtio-scsi.h"
  68 #include "hw/virtio/vhost-scsi-common.h"
  69
  70 #include "exec/address-spaces.h"
  71 #include "exec/ram_addr.h"
  72 #include "hw/usb.h"
  73 #include "qemu/config-file.h"
  74 #include "qemu/error-report.h"
  75 #include "trace.h"
  76 #include "hw/nmi.h"
  77 #include "hw/intc/intc.h"
  78
  79 #include "qemu/cutils.h"
  80 #include "hw/ppc/spapr_cpu_core.h"
  81 #include "hw/mem/memory-device.h"
  82 #include "hw/ppc/spapr_tpm_proxy.h"
  83
  84 #include "monitor/monitor.h"
  85
  86 #include <libfdt.h>
  87
  88 /* SLOF memory layout:
  89  *
  90  * SLOF raw image loaded at 0, copies its romfs right below the flat
  91  * device-tree, then position SLOF itself 31M below that
  92  *
  93  * So we set FW_OVERHEAD to 40MB which should account for all of that
  94  * and more
  95  *
  96  * We load our kernel at 4M, leaving space for SLOF initial image
  97  */
  98 #define FDT_MAX_SIZE            0x100000
  99 #define RTAS_MAX_SIZE           0x10000
 100 #define RTAS_MAX_ADDR           0x80000000 /* RTAS must stay below that */
 101 #define FW_MAX_SIZE             0x400000
 102 #define FW_FILE_NAME            "slof.bin"
 103 #define FW_OVERHEAD             0x2800000
 104 #define KERNEL_LOAD_ADDR        FW_MAX_SIZE
 105
 106 #define MIN_RMA_SLOF            128UL
 107
 108 #define PHANDLE_INTC            0x00001111
 109
 110 /* These two functions implement the VCPU id numbering: one to compute them
 111  * all and one to identify thread 0 of a VCORE. Any change to the first one
 112  * is likely to have an impact on the second one, so let's keep them close.
 113  */
 114 static int spapr_vcpu_id(SpaprMachineState *spapr, int cpu_index)
 115 {
 116     MachineState *ms = MACHINE(spapr);
 117     unsigned int smp_threads = ms->smp.threads;
 118
 119     assert(spapr->vsmt);
 120     return
 121         (cpu_index / smp_threads) * spapr->vsmt + cpu_index % smp_threads;
 122 }
 123 static bool spapr_is_thread0_in_vcore(SpaprMachineState *spapr,
 124                                       PowerPCCPU *cpu)
 125 {
 126     assert(spapr->vsmt);
 127     return spapr_get_vcpu_id(cpu) % spapr->vsmt == 0;
 128 }
 129
 130 static bool pre_2_10_vmstate_dummy_icp_needed(void *opaque)
 131 {
 132     /* Dummy entries correspond to unused ICPState objects in older QEMUs,
 133      * and newer QEMUs don't even have them. In both cases, we don't want
 134      * to send anything on the wire.
 135      */
 136     return false;
 137 }
 138
 139 static const VMStateDescription pre_2_10_vmstate_dummy_icp = {
 140     .name = "icp/server",
 141     .version_id = 1,
 142     .minimum_version_id = 1,
 143     .needed = pre_2_10_vmstate_dummy_icp_needed,
 144     .fields = (VMStateField[]) {
 145         VMSTATE_UNUSED(4), /* uint32_t xirr */
 146         VMSTATE_UNUSED(1), /* uint8_t pending_priority */
 147         VMSTATE_UNUSED(1), /* uint8_t mfrr */
 148         VMSTATE_END_OF_LIST()
 149     },
 150 };
 151
 152 static void pre_2_10_vmstate_register_dummy_icp(int i)
 153 {
 154     vmstate_register(NULL, i, &pre_2_10_vmstate_dummy_icp,
 155                      (void *)(uintptr_t) i);
 156 }
 157
 158 static void pre_2_10_vmstate_unregister_dummy_icp(int i)
 159 {
 160     vmstate_unregister(NULL, &pre_2_10_vmstate_dummy_icp,
 161                        (void *)(uintptr_t) i);
 162 }
 163
 164 int spapr_max_server_number(SpaprMachineState *spapr)
 165 {
 166     MachineState *ms = MACHINE(spapr);
 167
 168     assert(spapr->vsmt);
 169     return DIV_ROUND_UP(ms->smp.max_cpus * spapr->vsmt, ms->smp.threads);
 170 }
 171
 172 static int spapr_fixup_cpu_smt_dt(void *fdt, int offset, PowerPCCPU *cpu,
 173                                   int smt_threads)
 174 {
 175     int i, ret = 0;
 176     uint32_t servers_prop[smt_threads];
 177     uint32_t gservers_prop[smt_threads * 2];
 178     int index = spapr_get_vcpu_id(cpu);
 179
 180     if (cpu->compat_pvr) {
 181         ret = fdt_setprop_cell(fdt, offset, "cpu-version", cpu->compat_pvr);
 182         if (ret < 0) {
 183             return ret;
 184         }
 185     }
 186
 187     /* Build interrupt servers and gservers properties */
 188     for (i = 0; i < smt_threads; i++) {
 189         servers_prop[i] = cpu_to_be32(index + i);
 190         /* Hack, direct the group queues back to cpu 0 */
 191         gservers_prop[i*2] = cpu_to_be32(index + i);
 192         gservers_prop[i*2 + 1] = 0;
 193     }
 194     ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-server#s",
 195                       servers_prop, sizeof(servers_prop));
 196     if (ret < 0) {
 197         return ret;
 198     }
 199     ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-gserver#s",
 200                       gservers_prop, sizeof(gservers_prop));
 201
 202     return ret;
 203 }
 204
 205 static int spapr_fixup_cpu_numa_dt(void *fdt, int offset, PowerPCCPU *cpu)
 206 {
 207     int index = spapr_get_vcpu_id(cpu);
 208     uint32_t associativity[] = {cpu_to_be32(0x5),
 209                                 cpu_to_be32(0x0),
 210                                 cpu_to_be32(0x0),
 211                                 cpu_to_be32(0x0),
 212                                 cpu_to_be32(cpu->node_id),
 213                                 cpu_to_be32(index)};
 214
 215     /* Advertise NUMA via ibm,associativity */
 216     return fdt_setprop(fdt, offset, "ibm,associativity", associativity,
 217                           sizeof(associativity));
 218 }
 219
 220 /* Populate the "ibm,pa-features" property */
 221 static void spapr_populate_pa_features(SpaprMachineState *spapr,
 222                                        PowerPCCPU *cpu,
 223                                        void *fdt, int offset)
 224 {
 225     uint8_t pa_features_206[] = { 6, 0,
 226         0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 };
 227     uint8_t pa_features_207[] = { 24, 0,
 228         0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0,
 229         0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
 230         0x00, 0x00, 0x00, 0x00, 0x80, 0x00,
 231         0x80, 0x00, 0x80, 0x00, 0x00, 0x00 };
 232     uint8_t pa_features_300[] = { 66, 0,
 233         /* 0: MMU|FPU|SLB|RUN|DABR|NX, 1: fri[nzpm]|DABRX|SPRG3|SLB0|PP110 */
 234         /* 2: VPM|DS205|PPR|DS202|DS206, 3: LSD|URG, SSO, 5: LE|CFAR|EB|LSQ */
 235         0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0, /* 0 - 5 */
 236         /* 6: DS207 */
 237         0x80, 0x00, 0x00, 0x00, 0x00, 0x00, /* 6 - 11 */
 238         /* 16: Vector */
 239         0x00, 0x00, 0x00, 0x00, 0x80, 0x00, /* 12 - 17 */
 240         /* 18: Vec. Scalar, 20: Vec. XOR, 22: HTM */
 241         0x80, 0x00, 0x80, 0x00, 0x00, 0x00, /* 18 - 23 */
 242         /* 24: Ext. Dec, 26: 64 bit ftrs, 28: PM ftrs */
 243         0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 24 - 29 */
 244         /* 30: MMR, 32: LE atomic, 34: EBB + ext EBB */
 245         0x80, 0x00, 0x80, 0x00, 0xC0, 0x00, /* 30 - 35 */
 246         /* 36: SPR SO, 38: Copy/Paste, 40: Radix MMU */
 247         0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 36 - 41 */
 248         /* 42: PM, 44: PC RA, 46: SC vec'd */
 249         0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 42 - 47 */
 250         /* 48: SIMD, 50: QP BFP, 52: String */
 251         0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 48 - 53 */
 252         /* 54: DecFP, 56: DecI, 58: SHA */
 253         0x80, 0x00, 0x80, 0x00, 0x80, 0x00, /* 54 - 59 */
 254         /* 60: NM atomic, 62: RNG */
 255         0x80, 0x00, 0x80, 0x00, 0x00, 0x00, /* 60 - 65 */
 256     };
 257     uint8_t *pa_features = NULL;
 258     size_t pa_size;
 259
 260     if (ppc_check_compat(cpu, CPU_POWERPC_LOGICAL_2_06, 0, cpu->compat_pvr)) {
 261         pa_features = pa_features_206;
 262         pa_size = sizeof(pa_features_206);
 263     }
 264     if (ppc_check_compat(cpu, CPU_POWERPC_LOGICAL_2_07, 0, cpu->compat_pvr)) {
 265         pa_features = pa_features_207;
 266         pa_size = sizeof(pa_features_207);
 267     }
 268     if (ppc_check_compat(cpu, CPU_POWERPC_LOGICAL_3_00, 0, cpu->compat_pvr)) {
 269         pa_features = pa_features_300;
 270         pa_size = sizeof(pa_features_300);
 271     }
 272     if (!pa_features) {
 273         return;
 274     }
 275
 276     if (ppc_hash64_has(cpu, PPC_HASH64_CI_LARGEPAGE)) {
 277         /*
 278          * Note: we keep CI large pages off by default because a 64K capable
 279          * guest provisioned with large pages might otherwise try to map a qemu
 280          * framebuffer (or other kind of memory mapped PCI BAR) using 64K pages
 281          * even if that qemu runs on a 4k host.
 282          * We dd this bit back here if we are confident this is not an issue
 283          */
 284         pa_features[3] |= 0x20;
 285     }
 286     if ((spapr_get_cap(spapr, SPAPR_CAP_HTM) != 0) && pa_size > 24) {
 287         pa_features[24] |= 0x80;    /* Transactional memory support */
 288     }
 289     if (spapr->cas_pre_isa3_guest && pa_size > 40) {
 290         /* Workaround for broken kernels that attempt (guest) radix
 291          * mode when they can't handle it, if they see the radix bit set
 292          * in pa-features. So hide it from them. */
 293         pa_features[40 + 2] &= ~0x80; /* Radix MMU */
 294     }
 295
 296     _FDT((fdt_setprop(fdt, offset, "ibm,pa-features", pa_features, pa_size)));
 297 }
 298
 299 static int spapr_fixup_cpu_dt(void *fdt, SpaprMachineState *spapr)
 300 {
 301     MachineState *ms = MACHINE(spapr);
 302     int ret = 0, offset, cpus_offset;
 303     CPUState *cs;
 304     char cpu_model[32];
 305     uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)};
 306
 307     CPU_FOREACH(cs) {
 308         PowerPCCPU *cpu = POWERPC_CPU(cs);
 309         DeviceClass *dc = DEVICE_GET_CLASS(cs);
 310         int index = spapr_get_vcpu_id(cpu);
 311         int compat_smt = MIN(ms->smp.threads, ppc_compat_max_vthreads(cpu));
 312
 313         if (!spapr_is_thread0_in_vcore(spapr, cpu)) {
 314             continue;
 315         }
 316
 317         snprintf(cpu_model, 32, "%s@%x", dc->fw_name, index);
 318
 319         cpus_offset = fdt_path_offset(fdt, "/cpus");
 320         if (cpus_offset < 0) {
 321             cpus_offset = fdt_add_subnode(fdt, 0, "cpus");
 322             if (cpus_offset < 0) {
 323                 return cpus_offset;
 324             }
 325         }
 326         offset = fdt_subnode_offset(fdt, cpus_offset, cpu_model);
 327         if (offset < 0) {
 328             offset = fdt_add_subnode(fdt, cpus_offset, cpu_model);
 329             if (offset < 0) {
 330                 return offset;
 331             }
 332         }
 333
 334         ret = fdt_setprop(fdt, offset, "ibm,pft-size",
 335                           pft_size_prop, sizeof(pft_size_prop));
 336         if (ret < 0) {
 337             return ret;
 338         }
 339
 340         if (ms->numa_state->num_nodes > 1) {
 341             ret = spapr_fixup_cpu_numa_dt(fdt, offset, cpu);
 342             if (ret < 0) {
 343                 return ret;
 344             }
 345         }
 346
 347         ret = spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt);
 348         if (ret < 0) {
 349             return ret;
 350         }
 351
 352         spapr_populate_pa_features(spapr, cpu, fdt, offset);
 353     }
 354     return ret;
 355 }
 356
 357 static hwaddr spapr_node0_size(MachineState *machine)
 358 {
 359     if (machine->numa_state->num_nodes) {
 360         int i;
 361         for (i = 0; i < machine->numa_state->num_nodes; ++i) {
 362             if (machine->numa_state->nodes[i].node_mem) {
 363                 return MIN(pow2floor(machine->numa_state->nodes[i].node_mem),
 364                            machine->ram_size);
 365             }
 366         }
 367     }
 368     return machine->ram_size;
 369 }
 370
 371 static void add_str(GString *s, const gchar *s1)
 372 {
 373     g_string_append_len(s, s1, strlen(s1) + 1);
 374 }
 375
 376 static int spapr_populate_memory_node(void *fdt, int nodeid, hwaddr start,
 377                                        hwaddr size)
 378 {
 379     uint32_t associativity[] = {
 380         cpu_to_be32(0x4), /* length */
 381         cpu_to_be32(0x0), cpu_to_be32(0x0),
 382         cpu_to_be32(0x0), cpu_to_be32(nodeid)
 383     };
 384     char mem_name[32];
 385     uint64_t mem_reg_property[2];
 386     int off;
 387
 388     mem_reg_property[0] = cpu_to_be64(start);
 389     mem_reg_property[1] = cpu_to_be64(size);
 390
 391     sprintf(mem_name, "memory@" TARGET_FMT_lx, start);
 392     off = fdt_add_subnode(fdt, 0, mem_name);
 393     _FDT(off);
 394     _FDT((fdt_setprop_string(fdt, off, "device_type", "memory")));
 395     _FDT((fdt_setprop(fdt, off, "reg", mem_reg_property,
 396                       sizeof(mem_reg_property))));
 397     _FDT((fdt_setprop(fdt, off, "ibm,associativity", associativity,
 398                       sizeof(associativity))));
 399     return off;
 400 }
 401
 402 static int spapr_populate_memory(SpaprMachineState *spapr, void *fdt)
 403 {
 404     MachineState *machine = MACHINE(spapr);
 405     hwaddr mem_start, node_size;
 406     int i, nb_nodes = machine->numa_state->num_nodes;
 407     NodeInfo *nodes = machine->numa_state->nodes;
 408     NodeInfo ramnode;
 409
 410     /* No NUMA nodes, assume there is just one node with whole RAM */
 411     if (!nb_nodes) {
 412         nb_nodes = 1;
 413         ramnode.node_mem = machine->ram_size;
 414         nodes = &ramnode;
 415     }
 416
 417     for (i = 0, mem_start = 0; i < nb_nodes; ++i) {
 418         if (!nodes[i].node_mem) {
 419             continue;
 420         }
 421         if (mem_start >= machine->ram_size) {
 422             node_size = 0;
 423         } else {
 424             node_size = nodes[i].node_mem;
 425             if (node_size > machine->ram_size - mem_start) {
 426                 node_size = machine->ram_size - mem_start;
 427             }
 428         }
 429         if (!mem_start) {
 430             /* spapr_machine_init() checks for rma_size <= node0_size
 431              * already */
 432             spapr_populate_memory_node(fdt, i, 0, spapr->rma_size);
 433             mem_start += spapr->rma_size;
 434             node_size -= spapr->rma_size;
 435         }
 436         for ( ; node_size; ) {
 437             hwaddr sizetmp = pow2floor(node_size);
 438
 439             /* mem_start != 0 here */
 440             if (ctzl(mem_start) < ctzl(sizetmp)) {
 441                 sizetmp = 1ULL << ctzl(mem_start);
 442             }
 443
 444             spapr_populate_memory_node(fdt, i, mem_start, sizetmp);
 445             node_size -= sizetmp;
 446             mem_start += sizetmp;
 447         }
 448     }
 449
 450     return 0;
 451 }
 452
 453 static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset,
 454                                   SpaprMachineState *spapr)
 455 {
 456     MachineState *ms = MACHINE(spapr);
 457     PowerPCCPU *cpu = POWERPC_CPU(cs);
 458     CPUPPCState *env = &cpu->env;
 459     PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs);
 460     int index = spapr_get_vcpu_id(cpu);
 461     uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40),
 462                        0xffffffff, 0xffffffff};
 463     uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq()
 464         : SPAPR_TIMEBASE_FREQ;
 465     uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000;
 466     uint32_t page_sizes_prop[64];
 467     size_t page_sizes_prop_size;
 468     unsigned int smp_threads = ms->smp.threads;
 469     uint32_t vcpus_per_socket = smp_threads * ms->smp.cores;
 470     uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)};
 471     int compat_smt = MIN(smp_threads, ppc_compat_max_vthreads(cpu));
 472     SpaprDrc *drc;
 473     int drc_index;
 474     uint32_t radix_AP_encodings[PPC_PAGE_SIZES_MAX_SZ];
 475     int i;
 476
 477     drc = spapr_drc_by_id(TYPE_SPAPR_DRC_CPU, index);
 478     if (drc) {
 479         drc_index = spapr_drc_index(drc);
 480         _FDT((fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index)));
 481     }
 482
 483     _FDT((fdt_setprop_cell(fdt, offset, "reg", index)));
 484     _FDT((fdt_setprop_string(fdt, offset, "device_type", "cpu")));
 485
 486     _FDT((fdt_setprop_cell(fdt, offset, "cpu-version", env->spr[SPR_PVR])));
 487     _FDT((fdt_setprop_cell(fdt, offset, "d-cache-block-size",
 488                            env->dcache_line_size)));
 489     _FDT((fdt_setprop_cell(fdt, offset, "d-cache-line-size",
 490                            env->dcache_line_size)));
 491     _FDT((fdt_setprop_cell(fdt, offset, "i-cache-block-size",
 492                            env->icache_line_size)));
 493     _FDT((fdt_setprop_cell(fdt, offset, "i-cache-line-size",
 494                            env->icache_line_size)));
 495
 496     if (pcc->l1_dcache_size) {
 497         _FDT((fdt_setprop_cell(fdt, offset, "d-cache-size",
 498                                pcc->l1_dcache_size)));
 499     } else {
 500         warn_report("Unknown L1 dcache size for cpu");
 501     }
 502     if (pcc->l1_icache_size) {
 503         _FDT((fdt_setprop_cell(fdt, offset, "i-cache-size",
 504                                pcc->l1_icache_size)));
 505     } else {
 506         warn_report("Unknown L1 icache size for cpu");
 507     }
 508
 509     _FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq)));
 510     _FDT((fdt_setprop_cell(fdt, offset, "clock-frequency", cpufreq)));
 511     _FDT((fdt_setprop_cell(fdt, offset, "slb-size", cpu->hash64_opts->slb_size)));
 512     _FDT((fdt_setprop_cell(fdt, offset, "ibm,slb-size", cpu->hash64_opts->slb_size)));
 513     _FDT((fdt_setprop_string(fdt, offset, "status", "okay")));
 514     _FDT((fdt_setprop(fdt, offset, "64-bit", NULL, 0)));
 515
 516     if (env->spr_cb[SPR_PURR].oea_read) {
 517         _FDT((fdt_setprop_cell(fdt, offset, "ibm,purr", 1)));
 518     }
 519     if (env->spr_cb[SPR_SPURR].oea_read) {
 520         _FDT((fdt_setprop_cell(fdt, offset, "ibm,spurr", 1)));
 521     }
 522
 523     if (ppc_hash64_has(cpu, PPC_HASH64_1TSEG)) {
 524         _FDT((fdt_setprop(fdt, offset, "ibm,processor-segment-sizes",
 525                           segs, sizeof(segs))));
 526     }
 527
 528     /* Advertise VSX (vector extensions) if available
 529      *   1               == VMX / Altivec available
 530      *   2               == VSX available
 531      *
 532      * Only CPUs for which we create core types in spapr_cpu_core.c
 533      * are possible, and all of those have VMX */
 534     if (spapr_get_cap(spapr, SPAPR_CAP_VSX) != 0) {
 535         _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", 2)));
 536     } else {
 537         _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", 1)));
 538     }
 539
 540     /* Advertise DFP (Decimal Floating Point) if available
 541      *   0 / no property == no DFP
 542      *   1               == DFP available */
 543     if (spapr_get_cap(spapr, SPAPR_CAP_DFP) != 0) {
 544         _FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1)));
 545     }
 546
 547     page_sizes_prop_size = ppc_create_page_sizes_prop(cpu, page_sizes_prop,
 548                                                       sizeof(page_sizes_prop));
 549     if (page_sizes_prop_size) {
 550         _FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes",
 551                           page_sizes_prop, page_sizes_prop_size)));
 552     }
 553
 554     spapr_populate_pa_features(spapr, cpu, fdt, offset);
 555
 556     _FDT((fdt_setprop_cell(fdt, offset, "ibm,chip-id",
 557                            cs->cpu_index / vcpus_per_socket)));
 558
 559     _FDT((fdt_setprop(fdt, offset, "ibm,pft-size",
 560                       pft_size_prop, sizeof(pft_size_prop))));
 561
 562     if (ms->numa_state->num_nodes > 1) {
 563         _FDT(spapr_fixup_cpu_numa_dt(fdt, offset, cpu));
 564     }
 565
 566     _FDT(spapr_fixup_cpu_smt_dt(fdt, offset, cpu, compat_smt));
 567
 568     if (pcc->radix_page_info) {
 569         for (i = 0; i < pcc->radix_page_info->count; i++) {
 570             radix_AP_encodings[i] =
 571                 cpu_to_be32(pcc->radix_page_info->entries[i]);
 572         }
 573         _FDT((fdt_setprop(fdt, offset, "ibm,processor-radix-AP-encodings",
 574                           radix_AP_encodings,
 575                           pcc->radix_page_info->count *
 576                           sizeof(radix_AP_encodings[0]))));
 577     }
 578
 579     /*
 580      * We set this property to let the guest know that it can use the large
 581      * decrementer and its width in bits.
 582      */
 583     if (spapr_get_cap(spapr, SPAPR_CAP_LARGE_DECREMENTER) != SPAPR_CAP_OFF)
 584         _FDT((fdt_setprop_u32(fdt, offset, "ibm,dec-bits",
 585                               pcc->lrg_decr_bits)));
 586 }
 587
 588 static void spapr_populate_cpus_dt_node(void *fdt, SpaprMachineState *spapr)
 589 {
 590     CPUState **rev;
 591     CPUState *cs;
 592     int n_cpus;
 593     int cpus_offset;
 594     char *nodename;
 595     int i;
 596
 597     cpus_offset = fdt_add_subnode(fdt, 0, "cpus");
 598     _FDT(cpus_offset);
 599     _FDT((fdt_setprop_cell(fdt, cpus_offset, "#address-cells", 0x1)));
 600     _FDT((fdt_setprop_cell(fdt, cpus_offset, "#size-cells", 0x0)));
 601
 602     /*
 603      * We walk the CPUs in reverse order to ensure that CPU DT nodes
 604      * created by fdt_add_subnode() end up in the right order in FDT
 605      * for the guest kernel the enumerate the CPUs correctly.
 606      *
 607      * The CPU list cannot be traversed in reverse order, so we need
 608      * to do extra work.
 609      */
 610     n_cpus = 0;
 611     rev = NULL;
 612     CPU_FOREACH(cs) {
 613         rev = g_renew(CPUState *, rev, n_cpus + 1);
 614         rev[n_cpus++] = cs;
 615     }
 616
 617     for (i = n_cpus - 1; i >= 0; i--) {
 618         CPUState *cs = rev[i];
 619         PowerPCCPU *cpu = POWERPC_CPU(cs);
 620         int index = spapr_get_vcpu_id(cpu);
 621         DeviceClass *dc = DEVICE_GET_CLASS(cs);
 622         int offset;
 623
 624         if (!spapr_is_thread0_in_vcore(spapr, cpu)) {
 625             continue;
 626         }
 627
 628         nodename = g_strdup_printf("%s@%x", dc->fw_name, index);
 629         offset = fdt_add_subnode(fdt, cpus_offset, nodename);
 630         g_free(nodename);
 631         _FDT(offset);
 632         spapr_populate_cpu_dt(cs, fdt, offset, spapr);
 633     }
 634
 635     g_free(rev);
 636 }
 637
 638 static int spapr_rng_populate_dt(void *fdt)
 639 {
 640     int node;
 641     int ret;
 642
 643     node = qemu_fdt_add_subnode(fdt, "/ibm,platform-facilities");
 644     if (node <= 0) {
 645         return -1;
 646     }
 647     ret = fdt_setprop_string(fdt, node, "device_type",
 648                              "ibm,platform-facilities");
 649     ret |= fdt_setprop_cell(fdt, node, "#address-cells", 0x1);
 650     ret |= fdt_setprop_cell(fdt, node, "#size-cells", 0x0);
 651
 652     node = fdt_add_subnode(fdt, node, "ibm,random-v1");
 653     if (node <= 0) {
 654         return -1;
 655     }
 656     ret |= fdt_setprop_string(fdt, node, "compatible", "ibm,random");
 657
 658     return ret ? -1 : 0;
 659 }
 660
 661 static uint32_t spapr_pc_dimm_node(MemoryDeviceInfoList *list, ram_addr_t addr)
 662 {
 663     MemoryDeviceInfoList *info;
 664
 665     for (info = list; info; info = info->next) {
 666         MemoryDeviceInfo *value = info->value;
 667
 668         if (value && value->type == MEMORY_DEVICE_INFO_KIND_DIMM) {
 669             PCDIMMDeviceInfo *pcdimm_info = value->u.dimm.data;
 670
 671             if (addr >= pcdimm_info->addr &&
 672                 addr < (pcdimm_info->addr + pcdimm_info->size)) {
 673                 return pcdimm_info->node;
 674             }
 675         }
 676     }
 677
 678     return -1;
 679 }
 680
 681 struct sPAPRDrconfCellV2 {
 682      uint32_t seq_lmbs;
 683      uint64_t base_addr;
 684      uint32_t drc_index;
 685      uint32_t aa_index;
 686      uint32_t flags;
 687 } QEMU_PACKED;
 688
 689 typedef struct DrconfCellQueue {
 690     struct sPAPRDrconfCellV2 cell;
 691     QSIMPLEQ_ENTRY(DrconfCellQueue) entry;
 692 } DrconfCellQueue;
 693
 694 static DrconfCellQueue *
 695 spapr_get_drconf_cell(uint32_t seq_lmbs, uint64_t base_addr,
 696                       uint32_t drc_index, uint32_t aa_index,
 697                       uint32_t flags)
 698 {
 699     DrconfCellQueue *elem;
 700
 701     elem = g_malloc0(sizeof(*elem));
 702     elem->cell.seq_lmbs = cpu_to_be32(seq_lmbs);
 703     elem->cell.base_addr = cpu_to_be64(base_addr);
 704     elem->cell.drc_index = cpu_to_be32(drc_index);
 705     elem->cell.aa_index = cpu_to_be32(aa_index);
 706     elem->cell.flags = cpu_to_be32(flags);
 707
 708     return elem;
 709 }
 710
 711 /* ibm,dynamic-memory-v2 */
 712 static int spapr_populate_drmem_v2(SpaprMachineState *spapr, void *fdt,
 713                                    int offset, MemoryDeviceInfoList *dimms)
 714 {
 715     MachineState *machine = MACHINE(spapr);
 716     uint8_t *int_buf, *cur_index;
 717     int ret;
 718     uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE;
 719     uint64_t addr, cur_addr, size;
 720     uint32_t nr_boot_lmbs = (machine->device_memory->base / lmb_size);
 721     uint64_t mem_end = machine->device_memory->base +
 722                        memory_region_size(&machine->device_memory->mr);
 723     uint32_t node, buf_len, nr_entries = 0;
 724     SpaprDrc *drc;
 725     DrconfCellQueue *elem, *next;
 726     MemoryDeviceInfoList *info;
 727     QSIMPLEQ_HEAD(, DrconfCellQueue) drconf_queue
 728         = QSIMPLEQ_HEAD_INITIALIZER(drconf_queue);
 729
 730     /* Entry to cover RAM and the gap area */
 731     elem = spapr_get_drconf_cell(nr_boot_lmbs, 0, 0, -1,
 732                                  SPAPR_LMB_FLAGS_RESERVED |
 733                                  SPAPR_LMB_FLAGS_DRC_INVALID);
 734     QSIMPLEQ_INSERT_TAIL(&drconf_queue, elem, entry);
 735     nr_entries++;
 736
 737     cur_addr = machine->device_memory->base;
 738     for (info = dimms; info; info = info->next) {
 739         PCDIMMDeviceInfo *di = info->value->u.dimm.data;
 740
 741         addr = di->addr;
 742         size = di->size;
 743         node = di->node;
 744
 745         /* Entry for hot-pluggable area */
 746         if (cur_addr < addr) {
 747             drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, cur_addr / lmb_size);
 748             g_assert(drc);
 749             elem = spapr_get_drconf_cell((addr - cur_addr) / lmb_size,
 750                                          cur_addr, spapr_drc_index(drc), -1, 0);
 751             QSIMPLEQ_INSERT_TAIL(&drconf_queue, elem, entry);
 752             nr_entries++;
 753         }
 754
 755         /* Entry for DIMM */
 756         drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, addr / lmb_size);
 757         g_assert(drc);
 758         elem = spapr_get_drconf_cell(size / lmb_size, addr,
 759                                      spapr_drc_index(drc), node,
 760                                      SPAPR_LMB_FLAGS_ASSIGNED);
 761         QSIMPLEQ_INSERT_TAIL(&drconf_queue, elem, entry);
 762         nr_entries++;
 763         cur_addr = addr + size;
 764     }
 765
 766     /* Entry for remaining hotpluggable area */
 767     if (cur_addr < mem_end) {
 768         drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, cur_addr / lmb_size);
 769         g_assert(drc);
 770         elem = spapr_get_drconf_cell((mem_end - cur_addr) / lmb_size,
 771                                      cur_addr, spapr_drc_index(drc), -1, 0);
 772         QSIMPLEQ_INSERT_TAIL(&drconf_queue, elem, entry);
 773         nr_entries++;
 774     }
 775
 776     buf_len = nr_entries * sizeof(struct sPAPRDrconfCellV2) + sizeof(uint32_t);
 777     int_buf = cur_index = g_malloc0(buf_len);
 778     *(uint32_t *)int_buf = cpu_to_be32(nr_entries);
 779     cur_index += sizeof(nr_entries);
 780
 781     QSIMPLEQ_FOREACH_SAFE(elem, &drconf_queue, entry, next) {
 782         memcpy(cur_index, &elem->cell, sizeof(elem->cell));
 783         cur_index += sizeof(elem->cell);
 784         QSIMPLEQ_REMOVE(&drconf_queue, elem, DrconfCellQueue, entry);
 785         g_free(elem);
 786     }
 787
 788     ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory-v2", int_buf, buf_len);
 789     g_free(int_buf);
 790     if (ret < 0) {
 791         return -1;
 792     }
 793     return 0;
 794 }
 795
 796 /* ibm,dynamic-memory */
 797 static int spapr_populate_drmem_v1(SpaprMachineState *spapr, void *fdt,
 798                                    int offset, MemoryDeviceInfoList *dimms)
 799 {
 800     MachineState *machine = MACHINE(spapr);
 801     int i, ret;
 802     uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE;
 803     uint32_t device_lmb_start = machine->device_memory->base / lmb_size;
 804     uint32_t nr_lmbs = (machine->device_memory->base +
 805                        memory_region_size(&machine->device_memory->mr)) /
 806                        lmb_size;
 807     uint32_t *int_buf, *cur_index, buf_len;
 808
 809     /*
 810      * Allocate enough buffer size to fit in ibm,dynamic-memory
 811      */
 812     buf_len = (nr_lmbs * SPAPR_DR_LMB_LIST_ENTRY_SIZE + 1) * sizeof(uint32_t);
 813     cur_index = int_buf = g_malloc0(buf_len);
 814     int_buf[0] = cpu_to_be32(nr_lmbs);
 815     cur_index++;
 816     for (i = 0; i < nr_lmbs; i++) {
 817         uint64_t addr = i * lmb_size;
 818         uint32_t *dynamic_memory = cur_index;
 819
 820         if (i >= device_lmb_start) {
 821             SpaprDrc *drc;
 822
 823             drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB, i);
 824             g_assert(drc);
 825
 826             dynamic_memory[0] = cpu_to_be32(addr >> 32);
 827             dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff);
 828             dynamic_memory[2] = cpu_to_be32(spapr_drc_index(drc));
 829             dynamic_memory[3] = cpu_to_be32(0); /* reserved */
 830             dynamic_memory[4] = cpu_to_be32(spapr_pc_dimm_node(dimms, addr));
 831             if (memory_region_present(get_system_memory(), addr)) {
 832                 dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_ASSIGNED);
 833             } else {
 834                 dynamic_memory[5] = cpu_to_be32(0);
 835             }
 836         } else {
 837             /*
 838              * LMB information for RMA, boot time RAM and gap b/n RAM and
 839              * device memory region -- all these are marked as reserved
 840              * and as having no valid DRC.
 841              */
 842             dynamic_memory[0] = cpu_to_be32(addr >> 32);
 843             dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff);
 844             dynamic_memory[2] = cpu_to_be32(0);
 845             dynamic_memory[3] = cpu_to_be32(0); /* reserved */
 846             dynamic_memory[4] = cpu_to_be32(-1);
 847             dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_RESERVED |
 848                                             SPAPR_LMB_FLAGS_DRC_INVALID);
 849         }
 850
 851         cur_index += SPAPR_DR_LMB_LIST_ENTRY_SIZE;
 852     }
 853     ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory", int_buf, buf_len);
 854     g_free(int_buf);
 855     if (ret < 0) {
 856         return -1;
 857     }
 858     return 0;
 859 }
 860
 861 /*
 862  * Adds ibm,dynamic-reconfiguration-memory node.
 863  * Refer to docs/specs/ppc-spapr-hotplug.txt for the documentation
 864  * of this device tree node.
 865  */
 866 static int spapr_populate_drconf_memory(SpaprMachineState *spapr, void *fdt)
 867 {
 868     MachineState *machine = MACHINE(spapr);
 869     int nb_numa_nodes = machine->numa_state->num_nodes;
 870     int ret, i, offset;
 871     uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE;
 872     uint32_t prop_lmb_size[] = {0, cpu_to_be32(lmb_size)};
 873     uint32_t *int_buf, *cur_index, buf_len;
 874     int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1;
 875     MemoryDeviceInfoList *dimms = NULL;
 876
 877     /*
 878      * Don't create the node if there is no device memory
 879      */
 880     if (machine->ram_size == machine->maxram_size) {
 881         return 0;
 882     }
 883
 884     offset = fdt_add_subnode(fdt, 0, "ibm,dynamic-reconfiguration-memory");
 885
 886     ret = fdt_setprop(fdt, offset, "ibm,lmb-size", prop_lmb_size,
 887                     sizeof(prop_lmb_size));
 888     if (ret < 0) {
 889         return ret;
 890     }
 891
 892     ret = fdt_setprop_cell(fdt, offset, "ibm,memory-flags-mask", 0xff);
 893     if (ret < 0) {
 894         return ret;
 895     }
 896
 897     ret = fdt_setprop_cell(fdt, offset, "ibm,memory-preservation-time", 0x0);
 898     if (ret < 0) {
 899         return ret;
 900     }
 901
 902     /* ibm,dynamic-memory or ibm,dynamic-memory-v2 */
 903     dimms = qmp_memory_device_list();
 904     if (spapr_ovec_test(spapr->ov5_cas, OV5_DRMEM_V2)) {
 905         ret = spapr_populate_drmem_v2(spapr, fdt, offset, dimms);
 906     } else {
 907         ret = spapr_populate_drmem_v1(spapr, fdt, offset, dimms);
 908     }
 909     qapi_free_MemoryDeviceInfoList(dimms);
 910
 911     if (ret < 0) {
 912         return ret;
 913     }
 914
 915     /* ibm,associativity-lookup-arrays */
 916     buf_len = (nr_nodes * 4 + 2) * sizeof(uint32_t);
 917     cur_index = int_buf = g_malloc0(buf_len);
 918     int_buf[0] = cpu_to_be32(nr_nodes);
 919     int_buf[1] = cpu_to_be32(4); /* Number of entries per associativity list */
 920     cur_index += 2;
 921     for (i = 0; i < nr_nodes; i++) {
 922         uint32_t associativity[] = {
 923             cpu_to_be32(0x0),
 924             cpu_to_be32(0x0),
 925             cpu_to_be32(0x0),
 926             cpu_to_be32(i)
 927         };
 928         memcpy(cur_index, associativity, sizeof(associativity));
 929         cur_index += 4;
 930     }
 931     ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf,
 932             (cur_index - int_buf) * sizeof(uint32_t));
 933     g_free(int_buf);
 934
 935     return ret;
 936 }
 937
 938 static int spapr_dt_cas_updates(SpaprMachineState *spapr, void *fdt,
 939                                 SpaprOptionVector *ov5_updates)
 940 {
 941     SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
 942     int ret = 0, offset;
 943
 944     /* Generate ibm,dynamic-reconfiguration-memory node if required */
 945     if (spapr_ovec_test(ov5_updates, OV5_DRCONF_MEMORY)) {
 946         g_assert(smc->dr_lmb_enabled);
 947         ret = spapr_populate_drconf_memory(spapr, fdt);
 948         if (ret) {
 949             goto out;
 950         }
 951     }
 952
 953     offset = fdt_path_offset(fdt, "/chosen");
 954     if (offset < 0) {
 955         offset = fdt_add_subnode(fdt, 0, "chosen");
 956         if (offset < 0) {
 957             return offset;
 958         }
 959     }
 960     ret = spapr_ovec_populate_dt(fdt, offset, spapr->ov5_cas,
 961                                  "ibm,architecture-vec-5");
 962
 963 out:
 964     return ret;
 965 }
 966
 967 static bool spapr_hotplugged_dev_before_cas(void)
 968 {
 969     Object *drc_container, *obj;
 970     ObjectProperty *prop;
 971     ObjectPropertyIterator iter;
 972
 973     drc_container = container_get(object_get_root(), "/dr-connector");
 974     object_property_iter_init(&iter, drc_container);
 975     while ((prop = object_property_iter_next(&iter))) {
 976         if (!strstart(prop->type, "link<", NULL)) {
 977             continue;
 978         }
 979         obj = object_property_get_link(drc_container, prop->name, NULL);
 980         if (spapr_drc_needed(obj)) {
 981             return true;
 982         }
 983     }
 984     return false;
 985 }
 986
 987 int spapr_h_cas_compose_response(SpaprMachineState *spapr,
 988                                  target_ulong addr, target_ulong size,
 989                                  SpaprOptionVector *ov5_updates)
 990 {
 991     void *fdt, *fdt_skel;
 992     SpaprDeviceTreeUpdateHeader hdr = { .version_id = 1 };
 993
 994     if (spapr_hotplugged_dev_before_cas()) {
 995         return 1;
 996     }
 997
 998     if (size < sizeof(hdr) || size > FW_MAX_SIZE) {
 999         error_report("SLOF provided an unexpected CAS buffer size "
1000                      TARGET_FMT_lu " (min: %zu, max: %u)",
1001                      size, sizeof(hdr), FW_MAX_SIZE);
1002         exit(EXIT_FAILURE);
1003     }
1004
1005     size -= sizeof(hdr);
1006
1007     /* Create skeleton */
1008     fdt_skel = g_malloc0(size);
1009     _FDT((fdt_create(fdt_skel, size)));
1010     _FDT((fdt_finish_reservemap(fdt_skel)));
1011     _FDT((fdt_begin_node(fdt_skel, "")));
1012     _FDT((fdt_end_node(fdt_skel)));
1013     _FDT((fdt_finish(fdt_skel)));
1014     fdt = g_malloc0(size);
1015     _FDT((fdt_open_into(fdt_skel, fdt, size)));
1016     g_free(fdt_skel);
1017
1018     /* Fixup cpu nodes */
1019     _FDT((spapr_fixup_cpu_dt(fdt, spapr)));
1020
1021     if (spapr_dt_cas_updates(spapr, fdt, ov5_updates)) {
1022         return -1;
1023     }
1024
1025     /* Pack resulting tree */
1026     _FDT((fdt_pack(fdt)));
1027
1028     if (fdt_totalsize(fdt) + sizeof(hdr) > size) {
1029         trace_spapr_cas_failed(size);
1030         return -1;
1031     }
1032
1033     cpu_physical_memory_write(addr, &hdr, sizeof(hdr));
1034     cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt));
1035     trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr));
1036     g_free(fdt);
1037
1038     return 0;
1039 }
1040
1041 static void spapr_dt_rtas(SpaprMachineState *spapr, void *fdt)
1042 {
1043     MachineState *ms = MACHINE(spapr);
1044     int rtas;
1045     GString *hypertas = g_string_sized_new(256);
1046     GString *qemu_hypertas = g_string_sized_new(256);
1047     uint32_t refpoints[] = { cpu_to_be32(0x4), cpu_to_be32(0x4) };
1048     uint64_t max_device_addr = MACHINE(spapr)->device_memory->base +
1049         memory_region_size(&MACHINE(spapr)->device_memory->mr);
1050     uint32_t lrdr_capacity[] = {
1051         cpu_to_be32(max_device_addr >> 32),
1052         cpu_to_be32(max_device_addr & 0xffffffff),
1053         0, cpu_to_be32(SPAPR_MEMORY_BLOCK_SIZE),
1054         cpu_to_be32(ms->smp.max_cpus / ms->smp.threads),
1055     };
1056     uint32_t maxdomain = cpu_to_be32(spapr->gpu_numa_id > 1 ? 1 : 0);
1057     uint32_t maxdomains[] = {
1058         cpu_to_be32(4),
1059         maxdomain,
1060         maxdomain,
1061         maxdomain,
1062         cpu_to_be32(spapr->gpu_numa_id),
1063     };
1064
1065     _FDT(rtas = fdt_add_subnode(fdt, 0, "rtas"));
1066
1067     /* hypertas */
1068     add_str(hypertas, "hcall-pft");
1069     add_str(hypertas, "hcall-term");
1070     add_str(hypertas, "hcall-dabr");
1071     add_str(hypertas, "hcall-interrupt");
1072     add_str(hypertas, "hcall-tce");
1073     add_str(hypertas, "hcall-vio");
1074     add_str(hypertas, "hcall-splpar");
1075     add_str(hypertas, "hcall-join");
1076     add_str(hypertas, "hcall-bulk");
1077     add_str(hypertas, "hcall-set-mode");
1078     add_str(hypertas, "hcall-sprg0");
1079     add_str(hypertas, "hcall-copy");
1080     add_str(hypertas, "hcall-debug");
1081     add_str(hypertas, "hcall-vphn");
1082     add_str(qemu_hypertas, "hcall-memop1");
1083
1084     if (!kvm_enabled() || kvmppc_spapr_use_multitce()) {
1085         add_str(hypertas, "hcall-multi-tce");
1086     }
1087
1088     if (spapr->resize_hpt != SPAPR_RESIZE_HPT_DISABLED) {
1089         add_str(hypertas, "hcall-hpt-resize");
1090     }
1091
1092     _FDT(fdt_setprop(fdt, rtas, "ibm,hypertas-functions",
1093                      hypertas->str, hypertas->len));
1094     g_string_free(hypertas, TRUE);
1095     _FDT(fdt_setprop(fdt, rtas, "qemu,hypertas-functions",
1096                      qemu_hypertas->str, qemu_hypertas->len));
1097     g_string_free(qemu_hypertas, TRUE);
1098
1099     _FDT(fdt_setprop(fdt, rtas, "ibm,associativity-reference-points",
1100                      refpoints, sizeof(refpoints)));
1101
1102     _FDT(fdt_setprop(fdt, rtas, "ibm,max-associativity-domains",
1103                      maxdomains, sizeof(maxdomains)));
1104
1105     _FDT(fdt_setprop_cell(fdt, rtas, "rtas-error-log-max",
1106                           RTAS_ERROR_LOG_MAX));
1107     _FDT(fdt_setprop_cell(fdt, rtas, "rtas-event-scan-rate",
1108                           RTAS_EVENT_SCAN_RATE));
1109
1110     g_assert(msi_nonbroken);
1111     _FDT(fdt_setprop(fdt, rtas, "ibm,change-msix-capable", NULL, 0));
1112
1113     /*
1114      * According to PAPR, rtas ibm,os-term does not guarantee a return
1115      * back to the guest cpu.
1116      *
1117      * While an additional ibm,extended-os-term property indicates
1118      * that rtas call return will always occur. Set this property.
1119      */
1120     _FDT(fdt_setprop(fdt, rtas, "ibm,extended-os-term", NULL, 0));
1121
1122     _FDT(fdt_setprop(fdt, rtas, "ibm,lrdr-capacity",
1123                      lrdr_capacity, sizeof(lrdr_capacity)));
1124
1125     spapr_dt_rtas_tokens(fdt, rtas);
1126 }
1127
1128 /*
1129  * Prepare ibm,arch-vec-5-platform-support, which indicates the MMU
1130  * and the XIVE features that the guest may request and thus the valid
1131  * values for bytes 23..26 of option vector 5:
1132  */
1133 static void spapr_dt_ov5_platform_support(SpaprMachineState *spapr, void *fdt,
1134                                           int chosen)
1135 {
1136     PowerPCCPU *first_ppc_cpu = POWERPC_CPU(first_cpu);
1137
1138     char val[2 * 4] = {
1139         23, spapr->irq->ov5, /* Xive mode. */
1140         24, 0x00, /* Hash/Radix, filled in below. */
1141         25, 0x00, /* Hash options: Segment Tables == no, GTSE == no. */
1142         26, 0x40, /* Radix options: GTSE == yes. */
1143     };
1144
1145     if (!ppc_check_compat(first_ppc_cpu, CPU_POWERPC_LOGICAL_3_00, 0,
1146                           first_ppc_cpu->compat_pvr)) {
1147         /*
1148          * If we're in a pre POWER9 compat mode then the guest should
1149          * do hash and use the legacy interrupt mode
1150          */
1151         val[1] = 0x00; /* XICS */
1152         val[3] = 0x00; /* Hash */
1153     } else if (kvm_enabled()) {
1154         if (kvmppc_has_cap_mmu_radix() && kvmppc_has_cap_mmu_hash_v3()) {
1155             val[3] = 0x80; /* OV5_MMU_BOTH */
1156         } else if (kvmppc_has_cap_mmu_radix()) {
1157             val[3] = 0x40; /* OV5_MMU_RADIX_300 */
1158         } else {
1159             val[3] = 0x00; /* Hash */
1160         }
1161     } else {
1162         /* V3 MMU supports both hash and radix in tcg (with dynamic switching) */
1163         val[3] = 0xC0;
1164     }
1165     _FDT(fdt_setprop(fdt, chosen, "ibm,arch-vec-5-platform-support",
1166                      val, sizeof(val)));
1167 }
1168
1169 static void spapr_dt_chosen(SpaprMachineState *spapr, void *fdt)
1170 {
1171     MachineState *machine = MACHINE(spapr);
1172     SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine);
1173     int chosen;
1174     const char *boot_device = machine->boot_order;
1175     char *stdout_path = spapr_vio_stdout_path(spapr->vio_bus);
1176     size_t cb = 0;
1177     char *bootlist = get_boot_devices_list(&cb);
1178
1179     _FDT(chosen = fdt_add_subnode(fdt, 0, "chosen"));
1180
1181     _FDT(fdt_setprop_string(fdt, chosen, "bootargs", machine->kernel_cmdline));
1182     _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-start",
1183                           spapr->initrd_base));
1184     _FDT(fdt_setprop_cell(fdt, chosen, "linux,initrd-end",
1185                           spapr->initrd_base + spapr->initrd_size));
1186
1187     if (spapr->kernel_size) {
1188         uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR),
1189                               cpu_to_be64(spapr->kernel_size) };
1190
1191         _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel",
1192                          &kprop, sizeof(kprop)));
1193         if (spapr->kernel_le) {
1194             _FDT(fdt_setprop(fdt, chosen, "qemu,boot-kernel-le", NULL, 0));
1195         }
1196     }
1197     if (boot_menu) {
1198         _FDT((fdt_setprop_cell(fdt, chosen, "qemu,boot-menu", boot_menu)));
1199     }
1200     _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-width", graphic_width));
1201     _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-height", graphic_height));
1202     _FDT(fdt_setprop_cell(fdt, chosen, "qemu,graphic-depth", graphic_depth));
1203
1204     if (cb && bootlist) {
1205         int i;
1206
1207         for (i = 0; i < cb; i++) {
1208             if (bootlist[i] == '\n') {
1209                 bootlist[i] = ' ';
1210             }
1211         }
1212         _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-list", bootlist));
1213     }
1214
1215     if (boot_device && strlen(boot_device)) {
1216         _FDT(fdt_setprop_string(fdt, chosen, "qemu,boot-device", boot_device));
1217     }
1218
1219     if (!spapr->has_graphics && stdout_path) {
1220         /*
1221          * "linux,stdout-path" and "stdout" properties are deprecated by linux
1222          * kernel. New platforms should only use the "stdout-path" property. Set
1223          * the new property and continue using older property to remain
1224          * compatible with the existing firmware.
1225          */
1226         _FDT(fdt_setprop_string(fdt, chosen, "linux,stdout-path", stdout_path));
1227         _FDT(fdt_setprop_string(fdt, chosen, "stdout-path", stdout_path));
1228     }
1229
1230     /* We can deal with BAR reallocation just fine, advertise it to the guest */
1231     if (smc->linux_pci_probe) {
1232         _FDT(fdt_setprop_cell(fdt, chosen, "linux,pci-probe-only", 0));
1233     }
1234
1235     spapr_dt_ov5_platform_support(spapr, fdt, chosen);
1236
1237     g_free(stdout_path);
1238     g_free(bootlist);
1239 }
1240
1241 static void spapr_dt_hypervisor(SpaprMachineState *spapr, void *fdt)
1242 {
1243     /* The /hypervisor node isn't in PAPR - this is a hack to allow PR
1244      * KVM to work under pHyp with some guest co-operation */
1245     int hypervisor;
1246     uint8_t hypercall[16];
1247
1248     _FDT(hypervisor = fdt_add_subnode(fdt, 0, "hypervisor"));
1249     /* indicate KVM hypercall interface */
1250     _FDT(fdt_setprop_string(fdt, hypervisor, "compatible", "linux,kvm"));
1251     if (kvmppc_has_cap_fixup_hcalls()) {
1252         /*
1253          * Older KVM versions with older guest kernels were broken
1254          * with the magic page, don't allow the guest to map it.
1255          */
1256         if (!kvmppc_get_hypercall(first_cpu->env_ptr, hypercall,
1257                                   sizeof(hypercall))) {
1258             _FDT(fdt_setprop(fdt, hypervisor, "hcall-instructions",
1259                              hypercall, sizeof(hypercall)));
1260         }
1261     }
1262 }
1263
1264 static void *spapr_build_fdt(SpaprMachineState *spapr)
1265 {
1266     MachineState *machine = MACHINE(spapr);
1267     MachineClass *mc = MACHINE_GET_CLASS(machine);
1268     SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine);
1269     int ret;
1270     void *fdt;
1271     SpaprPhbState *phb;
1272     char *buf;
1273
1274     fdt = g_malloc0(FDT_MAX_SIZE);
1275     _FDT((fdt_create_empty_tree(fdt, FDT_MAX_SIZE)));
1276
1277     /* Root node */
1278     _FDT(fdt_setprop_string(fdt, 0, "device_type", "chrp"));
1279     _FDT(fdt_setprop_string(fdt, 0, "model", "IBM pSeries (emulated by qemu)"));
1280     _FDT(fdt_setprop_string(fdt, 0, "compatible", "qemu,pseries"));
1281
1282     /* Guest UUID & Name*/
1283     buf = qemu_uuid_unparse_strdup(&qemu_uuid);
1284     _FDT(fdt_setprop_string(fdt, 0, "vm,uuid", buf));
1285     if (qemu_uuid_set) {
1286         _FDT(fdt_setprop_string(fdt, 0, "system-id", buf));
1287     }
1288     g_free(buf);
1289
1290     if (qemu_get_vm_name()) {
1291         _FDT(fdt_setprop_string(fdt, 0, "ibm,partition-name",
1292                                 qemu_get_vm_name()));
1293     }
1294
1295     /* Host Model & Serial Number */
1296     if (spapr->host_model) {
1297         _FDT(fdt_setprop_string(fdt, 0, "host-model", spapr->host_model));
1298     } else if (smc->broken_host_serial_model && kvmppc_get_host_model(&buf)) {
1299         _FDT(fdt_setprop_string(fdt, 0, "host-model", buf));
1300         g_free(buf);
1301     }
1302
1303     if (spapr->host_serial) {
1304         _FDT(fdt_setprop_string(fdt, 0, "host-serial", spapr->host_serial));
1305     } else if (smc->broken_host_serial_model && kvmppc_get_host_serial(&buf)) {
1306         _FDT(fdt_setprop_string(fdt, 0, "host-serial", buf));
1307         g_free(buf);
1308     }
1309
1310     _FDT(fdt_setprop_cell(fdt, 0, "#address-cells", 2));
1311     _FDT(fdt_setprop_cell(fdt, 0, "#size-cells", 2));
1312
1313     /* /interrupt controller */
1314     spapr->irq->dt_populate(spapr, spapr_max_server_number(spapr), fdt,
1315                           PHANDLE_INTC);
1316
1317     ret = spapr_populate_memory(spapr, fdt);
1318     if (ret < 0) {
1319         error_report("couldn't setup memory nodes in fdt");
1320         exit(1);
1321     }
1322
1323     /* /vdevice */
1324     spapr_dt_vdevice(spapr->vio_bus, fdt);
1325
1326     if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)) {
1327         ret = spapr_rng_populate_dt(fdt);
1328         if (ret < 0) {
1329             error_report("could not set up rng device in the fdt");
1330             exit(1);
1331         }
1332     }
1333
1334     QLIST_FOREACH(phb, &spapr->phbs, list) {
1335         ret = spapr_dt_phb(phb, PHANDLE_INTC, fdt, spapr->irq->nr_msis, NULL);
1336         if (ret < 0) {
1337             error_report("couldn't setup PCI devices in fdt");
1338             exit(1);
1339         }
1340     }
1341
1342     /* cpus */
1343     spapr_populate_cpus_dt_node(fdt, spapr);
1344
1345     if (smc->dr_lmb_enabled) {
1346         _FDT(spapr_dt_drc(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_LMB));
1347     }
1348
1349     if (mc->has_hotpluggable_cpus) {
1350         int offset = fdt_path_offset(fdt, "/cpus");
1351         ret = spapr_dt_drc(fdt, offset, NULL, SPAPR_DR_CONNECTOR_TYPE_CPU);
1352         if (ret < 0) {
1353             error_report("Couldn't set up CPU DR device tree properties");
1354             exit(1);
1355         }
1356     }
1357
1358     /* /event-sources */
1359     spapr_dt_events(spapr, fdt);
1360
1361     /* /rtas */
1362     spapr_dt_rtas(spapr, fdt);
1363
1364     /* /chosen */
1365     spapr_dt_chosen(spapr, fdt);
1366
1367     /* /hypervisor */
1368     if (kvm_enabled()) {
1369         spapr_dt_hypervisor(spapr, fdt);
1370     }
1371
1372     /* Build memory reserve map */
1373     if (spapr->kernel_size) {
1374         _FDT((fdt_add_mem_rsv(fdt, KERNEL_LOAD_ADDR, spapr->kernel_size)));
1375     }
1376     if (spapr->initrd_size) {
1377         _FDT((fdt_add_mem_rsv(fdt, spapr->initrd_base, spapr->initrd_size)));
1378     }
1379
1380     /* ibm,client-architecture-support updates */
1381     ret = spapr_dt_cas_updates(spapr, fdt, spapr->ov5_cas);
1382     if (ret < 0) {
1383         error_report("couldn't setup CAS properties fdt");
1384         exit(1);
1385     }
1386
1387     if (smc->dr_phb_enabled) {
1388         ret = spapr_dt_drc(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_PHB);
1389         if (ret < 0) {
1390             error_report("Couldn't set up PHB DR device tree properties");
1391             exit(1);
1392         }
1393     }
1394
1395     return fdt;
1396 }
1397
1398 static uint64_t translate_kernel_address(void *opaque, uint64_t addr)
1399 {
1400     return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR;
1401 }
1402
1403 static void emulate_spapr_hypercall(PPCVirtualHypervisor *vhyp,
1404                                     PowerPCCPU *cpu)
1405 {
1406     CPUPPCState *env = &cpu->env;
1407
1408     /* The TCG path should also be holding the BQL at this point */
1409     g_assert(qemu_mutex_iothread_locked());
1410
1411     if (msr_pr) {
1412         hcall_dprintf("Hypercall made with MSR[PR]=1\n");
1413         env->gpr[3] = H_PRIVILEGE;
1414     } else {
1415         env->gpr[3] = spapr_hypercall(cpu, env->gpr[3], &env->gpr[4]);
1416     }
1417 }
1418
1419 struct LPCRSyncState {
1420     target_ulong value;
1421     target_ulong mask;
1422 };
1423
1424 static void do_lpcr_sync(CPUState *cs, run_on_cpu_data arg)
1425 {
1426     struct LPCRSyncState *s = arg.host_ptr;
1427     PowerPCCPU *cpu = POWERPC_CPU(cs);
1428     CPUPPCState *env = &cpu->env;
1429     target_ulong lpcr;
1430
1431     cpu_synchronize_state(cs);
1432     lpcr = env->spr[SPR_LPCR];
1433     lpcr &= ~s->mask;
1434     lpcr |= s->value;
1435     ppc_store_lpcr(cpu, lpcr);
1436 }
1437
1438 void spapr_set_all_lpcrs(target_ulong value, target_ulong mask)
1439 {
1440     CPUState *cs;
1441     struct LPCRSyncState s = {
1442         .value = value,
1443         .mask = mask
1444     };
1445     CPU_FOREACH(cs) {
1446         run_on_cpu(cs, do_lpcr_sync, RUN_ON_CPU_HOST_PTR(&s));
1447     }
1448 }
1449
1450 static void spapr_get_pate(PPCVirtualHypervisor *vhyp, ppc_v3_pate_t *entry)
1451 {
1452     SpaprMachineState *spapr = SPAPR_MACHINE(vhyp);
1453
1454     /* Copy PATE1:GR into PATE0:HR */
1455     entry->dw0 = spapr->patb_entry & PATE0_HR;
1456     entry->dw1 = spapr->patb_entry;
1457 }
1458
1459 #define HPTE(_table, _i)   (void *)(((uint64_t *)(_table)) + ((_i) * 2))
1460 #define HPTE_VALID(_hpte)  (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_VALID)
1461 #define HPTE_DIRTY(_hpte)  (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_HPTE_DIRTY)
1462 #define CLEAN_HPTE(_hpte)  ((*(uint64_t *)(_hpte)) &= tswap64(~HPTE64_V_HPTE_DIRTY))
1463 #define DIRTY_HPTE(_hpte)  ((*(uint64_t *)(_hpte)) |= tswap64(HPTE64_V_HPTE_DIRTY))
1464
1465 /*
1466  * Get the fd to access the kernel htab, re-opening it if necessary
1467  */
1468 static int get_htab_fd(SpaprMachineState *spapr)
1469 {
1470     Error *local_err = NULL;
1471
1472     if (spapr->htab_fd >= 0) {
1473         return spapr->htab_fd;
1474     }
1475
1476     spapr->htab_fd = kvmppc_get_htab_fd(false, 0, &local_err);
1477     if (spapr->htab_fd < 0) {
1478         error_report_err(local_err);
1479     }
1480
1481     return spapr->htab_fd;
1482 }
1483
1484 void close_htab_fd(SpaprMachineState *spapr)
1485 {
1486     if (spapr->htab_fd >= 0) {
1487         close(spapr->htab_fd);
1488     }
1489     spapr->htab_fd = -1;
1490 }
1491
1492 static hwaddr spapr_hpt_mask(PPCVirtualHypervisor *vhyp)
1493 {
1494     SpaprMachineState *spapr = SPAPR_MACHINE(vhyp);
1495
1496     return HTAB_SIZE(spapr) / HASH_PTEG_SIZE_64 - 1;
1497 }
1498
1499 static target_ulong spapr_encode_hpt_for_kvm_pr(PPCVirtualHypervisor *vhyp)
1500 {
1501     SpaprMachineState *spapr = SPAPR_MACHINE(vhyp);
1502
1503     assert(kvm_enabled());
1504
1505     if (!spapr->htab) {
1506         return 0;
1507     }
1508
1509     return (target_ulong)(uintptr_t)spapr->htab | (spapr->htab_shift - 18);
1510 }
1511
1512 static const ppc_hash_pte64_t *spapr_map_hptes(PPCVirtualHypervisor *vhyp,
1513                                                 hwaddr ptex, int n)
1514 {
1515     SpaprMachineState *spapr = SPAPR_MACHINE(vhyp);
1516     hwaddr pte_offset = ptex * HASH_PTE_SIZE_64;
1517
1518     if (!spapr->htab) {
1519         /*
1520          * HTAB is controlled by KVM. Fetch into temporary buffer
1521          */
1522         ppc_hash_pte64_t *hptes = g_malloc(n * HASH_PTE_SIZE_64);
1523         kvmppc_read_hptes(hptes, ptex, n);
1524         return hptes;
1525     }
1526
1527     /*
1528      * HTAB is controlled by QEMU. Just point to the internally
1529      * accessible PTEG.
1530      */
1531     return (const ppc_hash_pte64_t *)(spapr->htab + pte_offset);
1532 }
1533
1534 static void spapr_unmap_hptes(PPCVirtualHypervisor *vhyp,
1535                               const ppc_hash_pte64_t *hptes,
1536                               hwaddr ptex, int n)
1537 {
1538     SpaprMachineState *spapr = SPAPR_MACHINE(vhyp);
1539
1540     if (!spapr->htab) {
1541         g_free((void *)hptes);
1542     }
1543
1544     /* Nothing to do for qemu managed HPT */
1545 }
1546
1547 void spapr_store_hpte(PowerPCCPU *cpu, hwaddr ptex,
1548                       uint64_t pte0, uint64_t pte1)
1549 {
1550     SpaprMachineState *spapr = SPAPR_MACHINE(cpu->vhyp);
1551     hwaddr offset = ptex * HASH_PTE_SIZE_64;
1552
1553     if (!spapr->htab) {
1554         kvmppc_write_hpte(ptex, pte0, pte1);
1555     } else {
1556         if (pte0 & HPTE64_V_VALID) {
1557             stq_p(spapr->htab + offset + HASH_PTE_SIZE_64 / 2, pte1);
1558             /*
1559              * When setting valid, we write PTE1 first. This ensures
1560              * proper synchronization with the reading code in
1561              * ppc_hash64_pteg_search()
1562              */
1563             smp_wmb();
1564             stq_p(spapr->htab + offset, pte0);
1565         } else {
1566             stq_p(spapr->htab + offset, pte0);
1567             /*
1568              * When clearing it we set PTE0 first. This ensures proper
1569              * synchronization with the reading code in
1570              * ppc_hash64_pteg_search()
1571              */
1572             smp_wmb();
1573             stq_p(spapr->htab + offset + HASH_PTE_SIZE_64 / 2, pte1);
1574         }
1575     }
1576 }
1577
1578 static void spapr_hpte_set_c(PPCVirtualHypervisor *vhyp, hwaddr ptex,
1579                              uint64_t pte1)
1580 {
1581     hwaddr offset = ptex * HASH_PTE_SIZE_64 + 15;
1582     SpaprMachineState *spapr = SPAPR_MACHINE(vhyp);
1583
1584     if (!spapr->htab) {
1585         /* There should always be a hash table when this is called */
1586         error_report("spapr_hpte_set_c called with no hash table !");
1587         return;
1588     }
1589
1590     /* The HW performs a non-atomic byte update */
1591     stb_p(spapr->htab + offset, (pte1 & 0xff) | 0x80);
1592 }
1593
1594 static void spapr_hpte_set_r(PPCVirtualHypervisor *vhyp, hwaddr ptex,
1595                              uint64_t pte1)
1596 {
1597     hwaddr offset = ptex * HASH_PTE_SIZE_64 + 14;
1598     SpaprMachineState *spapr = SPAPR_MACHINE(vhyp);
1599
1600     if (!spapr->htab) {
1601         /* There should always be a hash table when this is called */
1602         error_report("spapr_hpte_set_r called with no hash table !");
1603         return;
1604     }
1605
1606     /* The HW performs a non-atomic byte update */
1607     stb_p(spapr->htab + offset, ((pte1 >> 8) & 0xff) | 0x01);
1608 }
1609
1610 int spapr_hpt_shift_for_ramsize(uint64_t ramsize)
1611 {
1612     int shift;
1613
1614     /* We aim for a hash table of size 1/128 the size of RAM (rounded
1615      * up).  The PAPR recommendation is actually 1/64 of RAM size, but
1616      * that's much more than is needed for Linux guests */
1617     shift = ctz64(pow2ceil(ramsize)) - 7;
1618     shift = MAX(shift, 18); /* Minimum architected size */
1619     shift = MIN(shift, 46); /* Maximum architected size */
1620     return shift;
1621 }
1622
1623 void spapr_free_hpt(SpaprMachineState *spapr)
1624 {
1625     g_free(spapr->htab);
1626     spapr->htab = NULL;
1627     spapr->htab_shift = 0;
1628     close_htab_fd(spapr);
1629 }
1630
1631 void spapr_reallocate_hpt(SpaprMachineState *spapr, int shift,
1632                           Error **errp)
1633 {
1634     long rc;
1635
1636     /* Clean up any HPT info from a previous boot */
1637     spapr_free_hpt(spapr);
1638
1639     rc = kvmppc_reset_htab(shift);
1640     if (rc < 0) {
1641         /* kernel-side HPT needed, but couldn't allocate one */
1642         error_setg_errno(errp, errno,
1643                          "Failed to allocate KVM HPT of order %d (try smaller maxmem?)",
1644                          shift);
1645         /* This is almost certainly fatal, but if the caller really
1646          * wants to carry on with shift == 0, it's welcome to try */
1647     } else if (rc > 0) {
1648         /* kernel-side HPT allocated */
1649         if (rc != shift) {
1650             error_setg(errp,
1651                        "Requested order %d HPT, but kernel allocated order %ld (try smaller maxmem?)",
1652                        shift, rc);
1653         }
1654
1655         spapr->htab_shift = shift;
1656         spapr->htab = NULL;
1657     } else {
1658         /* kernel-side HPT not needed, allocate in userspace instead */
1659         size_t size = 1ULL << shift;
1660         int i;
1661
1662         spapr->htab = qemu_memalign(size, size);
1663         if (!spapr->htab) {
1664             error_setg_errno(errp, errno,
1665                              "Could not allocate HPT of order %d", shift);
1666             return;
1667         }
1668
1669         memset(spapr->htab, 0, size);
1670         spapr->htab_shift = shift;
1671
1672         for (i = 0; i < size / HASH_PTE_SIZE_64; i++) {
1673             DIRTY_HPTE(HPTE(spapr->htab, i));
1674         }
1675     }
1676     /* We're setting up a hash table, so that means we're not radix */
1677     spapr->patb_entry = 0;
1678     spapr_set_all_lpcrs(0, LPCR_HR | LPCR_UPRT);
1679 }
1680
1681 void spapr_setup_hpt_and_vrma(SpaprMachineState *spapr)
1682 {
1683     int hpt_shift;
1684
1685     if ((spapr->resize_hpt == SPAPR_RESIZE_HPT_DISABLED)
1686         || (spapr->cas_reboot
1687             && !spapr_ovec_test(spapr->ov5_cas, OV5_HPT_RESIZE))) {
1688         hpt_shift = spapr_hpt_shift_for_ramsize(MACHINE(spapr)->maxram_size);
1689     } else {
1690         uint64_t current_ram_size;
1691
1692         current_ram_size = MACHINE(spapr)->ram_size + get_plugged_memory_size();
1693         hpt_shift = spapr_hpt_shift_for_ramsize(current_ram_size);
1694     }
1695     spapr_reallocate_hpt(spapr, hpt_shift, &error_fatal);
1696
1697     if (spapr->vrma_adjust) {
1698         spapr->rma_size = kvmppc_rma_size(spapr_node0_size(MACHINE(spapr)),
1699                                           spapr->htab_shift);
1700     }
1701 }
1702
1703 static int spapr_reset_drcs(Object *child, void *opaque)
1704 {
1705     SpaprDrc *drc =
1706         (SpaprDrc *) object_dynamic_cast(child,
1707                                                  TYPE_SPAPR_DR_CONNECTOR);
1708
1709     if (drc) {
1710         spapr_drc_reset(drc);
1711     }
1712
1713     return 0;
1714 }
1715
1716 static void spapr_machine_reset(MachineState *machine)
1717 {
1718     SpaprMachineState *spapr = SPAPR_MACHINE(machine);
1719     PowerPCCPU *first_ppc_cpu;
1720     uint32_t rtas_limit;
1721     hwaddr rtas_addr, fdt_addr;
1722     void *fdt;
1723     int rc;
1724
1725     spapr_caps_apply(spapr);
1726
1727     first_ppc_cpu = POWERPC_CPU(first_cpu);
1728     if (kvm_enabled() && kvmppc_has_cap_mmu_radix() &&
1729         ppc_type_check_compat(machine->cpu_type, CPU_POWERPC_LOGICAL_3_00, 0,
1730                               spapr->max_compat_pvr)) {
1731         /*
1732          * If using KVM with radix mode available, VCPUs can be started
1733          * without a HPT because KVM will start them in radix mode.
1734          * Set the GR bit in PATE so that we know there is no HPT.
1735          */
1736         spapr->patb_entry = PATE1_GR;
1737         spapr_set_all_lpcrs(LPCR_HR | LPCR_UPRT, LPCR_HR | LPCR_UPRT);
1738     } else {
1739         spapr_setup_hpt_and_vrma(spapr);
1740     }
1741
1742     qemu_devices_reset();
1743
1744     /*
1745      * If this reset wasn't generated by CAS, we should reset our
1746      * negotiated options and start from scratch
1747      */
1748     if (!spapr->cas_reboot) {
1749         spapr_ovec_cleanup(spapr->ov5_cas);
1750         spapr->ov5_cas = spapr_ovec_new();
1751
1752         ppc_set_compat_all(spapr->max_compat_pvr, &error_fatal);
1753     }
1754
1755     /*
1756      * This is fixing some of the default configuration of the XIVE
1757      * devices. To be called after the reset of the machine devices.
1758      */
1759     spapr_irq_reset(spapr, &error_fatal);
1760
1761     /*
1762      * There is no CAS under qtest. Simulate one to please the code that
1763      * depends on spapr->ov5_cas. This is especially needed to test device
1764      * unplug, so we do that before resetting the DRCs.
1765      */
1766     if (qtest_enabled()) {
1767         spapr_ovec_cleanup(spapr->ov5_cas);
1768         spapr->ov5_cas = spapr_ovec_clone(spapr->ov5);
1769     }
1770
1771     /* DRC reset may cause a device to be unplugged. This will cause troubles
1772      * if this device is used by another device (eg, a running vhost backend
1773      * will crash QEMU if the DIMM holding the vring goes away). To avoid such
1774      * situations, we reset DRCs after all devices have been reset.
1775      */
1776     object_child_foreach_recursive(object_get_root(), spapr_reset_drcs, NULL);
1777
1778     spapr_clear_pending_events(spapr);
1779
1780     /*
1781      * We place the device tree and RTAS just below either the top of the RMA,
1782      * or just below 2GB, whichever is lower, so that it can be
1783      * processed with 32-bit real mode code if necessary
1784      */
1785     rtas_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR);
1786     rtas_addr = rtas_limit - RTAS_MAX_SIZE;
1787     fdt_addr = rtas_addr - FDT_MAX_SIZE;
1788
1789     fdt = spapr_build_fdt(spapr);
1790
1791     spapr_load_rtas(spapr, fdt, rtas_addr);
1792
1793     rc = fdt_pack(fdt);
1794
1795     /* Should only fail if we've built a corrupted tree */
1796     assert(rc == 0);
1797
1798     if (fdt_totalsize(fdt) > FDT_MAX_SIZE) {
1799         error_report("FDT too big ! 0x%x bytes (max is 0x%x)",
1800                      fdt_totalsize(fdt), FDT_MAX_SIZE);
1801         exit(1);
1802     }
1803
1804     /* Load the fdt */
1805     qemu_fdt_dumpdtb(fdt, fdt_totalsize(fdt));
1806     cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt));
1807     g_free(spapr->fdt_blob);
1808     spapr->fdt_size = fdt_totalsize(fdt);
1809     spapr->fdt_initial_size = spapr->fdt_size;
1810     spapr->fdt_blob = fdt;
1811
1812     /* Set up the entry state */
1813     spapr_cpu_set_entry_state(first_ppc_cpu, SPAPR_ENTRY_POINT, fdt_addr);
1814     first_ppc_cpu->env.gpr[5] = 0;
1815
1816     spapr->cas_reboot = false;
1817 }
1818
1819 static void spapr_create_nvram(SpaprMachineState *spapr)
1820 {
1821     DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram");
1822     DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0);
1823
1824     if (dinfo) {
1825         qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(dinfo),
1826                             &error_fatal);
1827     }
1828
1829     qdev_init_nofail(dev);
1830
1831     spapr->nvram = (struct SpaprNvram *)dev;
1832 }
1833
1834 static void spapr_rtc_create(SpaprMachineState *spapr)
1835 {
1836     object_initialize_child(OBJECT(spapr), "rtc",
1837                             &spapr->rtc, sizeof(spapr->rtc), TYPE_SPAPR_RTC,
1838                             &error_fatal, NULL);
1839     object_property_set_bool(OBJECT(&spapr->rtc), true, "realized",
1840                               &error_fatal);
1841     object_property_add_alias(OBJECT(spapr), "rtc-time", OBJECT(&spapr->rtc),
1842                               "date", &error_fatal);
1843 }
1844
1845 /* Returns whether we want to use VGA or not */
1846 static bool spapr_vga_init(PCIBus *pci_bus, Error **errp)
1847 {
1848     switch (vga_interface_type) {
1849     case VGA_NONE:
1850         return false;
1851     case VGA_DEVICE:
1852         return true;
1853     case VGA_STD:
1854     case VGA_VIRTIO:
1855     case VGA_CIRRUS:
1856         return pci_vga_init(pci_bus) != NULL;
1857     default:
1858         error_setg(errp,
1859                    "Unsupported VGA mode, only -vga std or -vga virtio is supported");
1860         return false;
1861     }
1862 }
1863
1864 static int spapr_pre_load(void *opaque)
1865 {
1866     int rc;
1867
1868     rc = spapr_caps_pre_load(opaque);
1869     if (rc) {
1870         return rc;
1871     }
1872
1873     return 0;
1874 }
1875
1876 static int spapr_post_load(void *opaque, int version_id)
1877 {
1878     SpaprMachineState *spapr = (SpaprMachineState *)opaque;
1879     int err = 0;
1880
1881     err = spapr_caps_post_migration(spapr);
1882     if (err) {
1883         return err;
1884     }
1885
1886     /*
1887      * In earlier versions, there was no separate qdev for the PAPR
1888      * RTC, so the RTC offset was stored directly in sPAPREnvironment.
1889      * So when migrating from those versions, poke the incoming offset
1890      * value into the RTC device
1891      */
1892     if (version_id < 3) {
1893         err = spapr_rtc_import_offset(&spapr->rtc, spapr->rtc_offset);
1894         if (err) {
1895             return err;
1896         }
1897     }
1898
1899     if (kvm_enabled() && spapr->patb_entry) {
1900         PowerPCCPU *cpu = POWERPC_CPU(first_cpu);
1901         bool radix = !!(spapr->patb_entry & PATE1_GR);
1902         bool gtse = !!(cpu->env.spr[SPR_LPCR] & LPCR_GTSE);
1903
1904         /*
1905          * Update LPCR:HR and UPRT as they may not be set properly in
1906          * the stream
1907          */
1908         spapr_set_all_lpcrs(radix ? (LPCR_HR | LPCR_UPRT) : 0,
1909                             LPCR_HR | LPCR_UPRT);
1910
1911         err = kvmppc_configure_v3_mmu(cpu, radix, gtse, spapr->patb_entry);
1912         if (err) {
1913             error_report("Process table config unsupported by the host");
1914             return -EINVAL;
1915         }
1916     }
1917
1918     err = spapr_irq_post_load(spapr, version_id);
1919     if (err) {
1920         return err;
1921     }
1922
1923     return err;
1924 }
1925
1926 static int spapr_pre_save(void *opaque)
1927 {
1928     int rc;
1929
1930     rc = spapr_caps_pre_save(opaque);
1931     if (rc) {
1932         return rc;
1933     }
1934
1935     return 0;
1936 }
1937
1938 static bool version_before_3(void *opaque, int version_id)
1939 {
1940     return version_id < 3;
1941 }
1942
1943 static bool spapr_pending_events_needed(void *opaque)
1944 {
1945     SpaprMachineState *spapr = (SpaprMachineState *)opaque;
1946     return !QTAILQ_EMPTY(&spapr->pending_events);
1947 }
1948
1949 static const VMStateDescription vmstate_spapr_event_entry = {
1950     .name = "spapr_event_log_entry",
1951     .version_id = 1,
1952     .minimum_version_id = 1,
1953     .fields = (VMStateField[]) {
1954         VMSTATE_UINT32(summary, SpaprEventLogEntry),
1955         VMSTATE_UINT32(extended_length, SpaprEventLogEntry),
1956         VMSTATE_VBUFFER_ALLOC_UINT32(extended_log, SpaprEventLogEntry, 0,
1957                                      NULL, extended_length),
1958         VMSTATE_END_OF_LIST()
1959     },
1960 };
1961
1962 static const VMStateDescription vmstate_spapr_pending_events = {
1963     .name = "spapr_pending_events",
1964     .version_id = 1,
1965     .minimum_version_id = 1,
1966     .needed = spapr_pending_events_needed,
1967     .fields = (VMStateField[]) {
1968         VMSTATE_QTAILQ_V(pending_events, SpaprMachineState, 1,
1969                          vmstate_spapr_event_entry, SpaprEventLogEntry, next),
1970         VMSTATE_END_OF_LIST()
1971     },
1972 };
1973
1974 static bool spapr_ov5_cas_needed(void *opaque)
1975 {
1976     SpaprMachineState *spapr = opaque;
1977     SpaprOptionVector *ov5_mask = spapr_ovec_new();
1978     SpaprOptionVector *ov5_legacy = spapr_ovec_new();
1979     SpaprOptionVector *ov5_removed = spapr_ovec_new();
1980     bool cas_needed;
1981
1982     /* Prior to the introduction of SpaprOptionVector, we had two option
1983      * vectors we dealt with: OV5_FORM1_AFFINITY, and OV5_DRCONF_MEMORY.
1984      * Both of these options encode machine topology into the device-tree
1985      * in such a way that the now-booted OS should still be able to interact
1986      * appropriately with QEMU regardless of what options were actually
1987      * negotiatied on the source side.
1988      *
1989      * As such, we can avoid migrating the CAS-negotiated options if these
1990      * are the only options available on the current machine/platform.
1991      * Since these are the only options available for pseries-2.7 and
1992      * earlier, this allows us to maintain old->new/new->old migration
1993      * compatibility.
1994      *
1995      * For QEMU 2.8+, there are additional CAS-negotiatable options available
1996      * via default pseries-2.8 machines and explicit command-line parameters.
1997      * Some of these options, like OV5_HP_EVT, *do* require QEMU to be aware
1998      * of the actual CAS-negotiated values to continue working properly. For
1999      * example, availability of memory unplug depends on knowing whether
2000      * OV5_HP_EVT was negotiated via CAS.
2001      *
2002      * Thus, for any cases where the set of available CAS-negotiatable
2003      * options extends beyond OV5_FORM1_AFFINITY and OV5_DRCONF_MEMORY, we
2004      * include the CAS-negotiated options in the migration stream, unless
2005      * if they affect boot time behaviour only.
2006      */
2007     spapr_ovec_set(ov5_mask, OV5_FORM1_AFFINITY);
2008     spapr_ovec_set(ov5_mask, OV5_DRCONF_MEMORY);
2009     spapr_ovec_set(ov5_mask, OV5_DRMEM_V2);
2010
2011     /* spapr_ovec_diff returns true if bits were removed. we avoid using
2012      * the mask itself since in the future it's possible "legacy" bits may be
2013      * removed via machine options, which could generate a false positive
2014      * that breaks migration.
2015      */
2016     spapr_ovec_intersect(ov5_legacy, spapr->ov5, ov5_mask);
2017     cas_needed = spapr_ovec_diff(ov5_removed, spapr->ov5, ov5_legacy);
2018
2019     spapr_ovec_cleanup(ov5_mask);
2020     spapr_ovec_cleanup(ov5_legacy);
2021     spapr_ovec_cleanup(ov5_removed);
2022
2023     return cas_needed;
2024 }
2025
2026 static const VMStateDescription vmstate_spapr_ov5_cas = {
2027     .name = "spapr_option_vector_ov5_cas",
2028     .version_id = 1,
2029     .minimum_version_id = 1,
2030     .needed = spapr_ov5_cas_needed,
2031     .fields = (VMStateField[]) {
2032         VMSTATE_STRUCT_POINTER_V(ov5_cas, SpaprMachineState, 1,
2033                                  vmstate_spapr_ovec, SpaprOptionVector),
2034         VMSTATE_END_OF_LIST()
2035     },
2036 };
2037
2038 static bool spapr_patb_entry_needed(void *opaque)
2039 {
2040     SpaprMachineState *spapr = opaque;
2041
2042     return !!spapr->patb_entry;
2043 }
2044
2045 static const VMStateDescription vmstate_spapr_patb_entry = {
2046     .name = "spapr_patb_entry",
2047     .version_id = 1,
2048     .minimum_version_id = 1,
2049     .needed = spapr_patb_entry_needed,
2050     .fields = (VMStateField[]) {
2051         VMSTATE_UINT64(patb_entry, SpaprMachineState),
2052         VMSTATE_END_OF_LIST()
2053     },
2054 };
2055
2056 static bool spapr_irq_map_needed(void *opaque)
2057 {
2058     SpaprMachineState *spapr = opaque;
2059
2060     return spapr->irq_map && !bitmap_empty(spapr->irq_map, spapr->irq_map_nr);
2061 }
2062
2063 static const VMStateDescription vmstate_spapr_irq_map = {
2064     .name = "spapr_irq_map",
2065     .version_id = 1,
2066     .minimum_version_id = 1,
2067     .needed = spapr_irq_map_needed,
2068     .fields = (VMStateField[]) {
2069         VMSTATE_BITMAP(irq_map, SpaprMachineState, 0, irq_map_nr),
2070         VMSTATE_END_OF_LIST()
2071     },
2072 };
2073
2074 static bool spapr_dtb_needed(void *opaque)
2075 {
2076     SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(opaque);
2077
2078     return smc->update_dt_enabled;
2079 }
2080
2081 static int spapr_dtb_pre_load(void *opaque)
2082 {
2083     SpaprMachineState *spapr = (SpaprMachineState *)opaque;
2084
2085     g_free(spapr->fdt_blob);
2086     spapr->fdt_blob = NULL;
2087     spapr->fdt_size = 0;
2088
2089     return 0;
2090 }
2091
2092 static const VMStateDescription vmstate_spapr_dtb = {
2093     .name = "spapr_dtb",
2094     .version_id = 1,
2095     .minimum_version_id = 1,
2096     .needed = spapr_dtb_needed,
2097     .pre_load = spapr_dtb_pre_load,
2098     .fields = (VMStateField[]) {
2099         VMSTATE_UINT32(fdt_initial_size, SpaprMachineState),
2100         VMSTATE_UINT32(fdt_size, SpaprMachineState),
2101         VMSTATE_VBUFFER_ALLOC_UINT32(fdt_blob, SpaprMachineState, 0, NULL,
2102                                      fdt_size),
2103         VMSTATE_END_OF_LIST()
2104     },
2105 };
2106
2107 static const VMStateDescription vmstate_spapr = {
2108     .name = "spapr",
2109     .version_id = 3,
2110     .minimum_version_id = 1,
2111     .pre_load = spapr_pre_load,
2112     .post_load = spapr_post_load,
2113     .pre_save = spapr_pre_save,
2114     .fields = (VMStateField[]) {
2115         /* used to be @next_irq */
2116         VMSTATE_UNUSED_BUFFER(version_before_3, 0, 4),
2117
2118         /* RTC offset */
2119         VMSTATE_UINT64_TEST(rtc_offset, SpaprMachineState, version_before_3),
2120
2121         VMSTATE_PPC_TIMEBASE_V(tb, SpaprMachineState, 2),
2122         VMSTATE_END_OF_LIST()
2123     },
2124     .subsections = (const VMStateDescription*[]) {
2125         &vmstate_spapr_ov5_cas,
2126         &vmstate_spapr_patb_entry,
2127         &vmstate_spapr_pending_events,
2128         &vmstate_spapr_cap_htm,
2129         &vmstate_spapr_cap_vsx,
2130         &vmstate_spapr_cap_dfp,
2131         &vmstate_spapr_cap_cfpc,
2132         &vmstate_spapr_cap_sbbc,
2133         &vmstate_spapr_cap_ibs,
2134         &vmstate_spapr_cap_hpt_maxpagesize,
2135         &vmstate_spapr_irq_map,
2136         &vmstate_spapr_cap_nested_kvm_hv,
2137         &vmstate_spapr_dtb,
2138         &vmstate_spapr_cap_large_decr,
2139         &vmstate_spapr_cap_ccf_assist,
2140         NULL
2141     }
2142 };
2143
2144 static int htab_save_setup(QEMUFile *f, void *opaque)
2145 {
2146     SpaprMachineState *spapr = opaque;
2147
2148     /* "Iteration" header */
2149     if (!spapr->htab_shift) {
2150         qemu_put_be32(f, -1);
2151     } else {
2152         qemu_put_be32(f, spapr->htab_shift);
2153     }
2154
2155     if (spapr->htab) {
2156         spapr->htab_save_index = 0;
2157         spapr->htab_first_pass = true;
2158     } else {
2159         if (spapr->htab_shift) {
2160             assert(kvm_enabled());
2161         }
2162     }
2163
2164
2165     return 0;
2166 }
2167
2168 static void htab_save_chunk(QEMUFile *f, SpaprMachineState *spapr,
2169                             int chunkstart, int n_valid, int n_invalid)
2170 {
2171     qemu_put_be32(f, chunkstart);
2172     qemu_put_be16(f, n_valid);
2173     qemu_put_be16(f, n_invalid);
2174     qemu_put_buffer(f, HPTE(spapr->htab, chunkstart),
2175                     HASH_PTE_SIZE_64 * n_valid);
2176 }
2177
2178 static void htab_save_end_marker(QEMUFile *f)
2179 {
2180     qemu_put_be32(f, 0);
2181     qemu_put_be16(f, 0);
2182     qemu_put_be16(f, 0);
2183 }
2184
2185 static void htab_save_first_pass(QEMUFile *f, SpaprMachineState *spapr,
2186                                  int64_t max_ns)
2187 {
2188     bool has_timeout = max_ns != -1;
2189     int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64;
2190     int index = spapr->htab_save_index;
2191     int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
2192
2193     assert(spapr->htab_first_pass);
2194
2195     do {
2196         int chunkstart;
2197
2198         /* Consume invalid HPTEs */
2199         while ((index < htabslots)
2200                && !HPTE_VALID(HPTE(spapr->htab, index))) {
2201             CLEAN_HPTE(HPTE(spapr->htab, index));
2202             index++;
2203         }
2204
2205         /* Consume valid HPTEs */
2206         chunkstart = index;
2207         while ((index < htabslots) && (index - chunkstart < USHRT_MAX)
2208                && HPTE_VALID(HPTE(spapr->htab, index))) {
2209             CLEAN_HPTE(HPTE(spapr->htab, index));
2210             index++;
2211         }
2212
2213         if (index > chunkstart) {
2214             int n_valid = index - chunkstart;
2215
2216             htab_save_chunk(f, spapr, chunkstart, n_valid, 0);
2217
2218             if (has_timeout &&
2219                 (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) {
2220                 break;
2221             }
2222         }
2223     } while ((index < htabslots) && !qemu_file_rate_limit(f));
2224
2225     if (index >= htabslots) {
2226         assert(index == htabslots);
2227         index = 0;
2228         spapr->htab_first_pass = false;
2229     }
2230     spapr->htab_save_index = index;
2231 }
2232
2233 static int htab_save_later_pass(QEMUFile *f, SpaprMachineState *spapr,
2234                                 int64_t max_ns)
2235 {
2236     bool final = max_ns < 0;
2237     int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64;
2238     int examined = 0, sent = 0;
2239     int index = spapr->htab_save_index;
2240     int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
2241
2242     assert(!spapr->htab_first_pass);
2243
2244     do {
2245         int chunkstart, invalidstart;
2246
2247         /* Consume non-dirty HPTEs */
2248         while ((index < htabslots)
2249                && !HPTE_DIRTY(HPTE(spapr->htab, index))) {
2250             index++;
2251             examined++;
2252         }
2253
2254         chunkstart = index;
2255         /* Consume valid dirty HPTEs */
2256         while ((index < htabslots) && (index - chunkstart < USHRT_MAX)
2257                && HPTE_DIRTY(HPTE(spapr->htab, index))
2258                && HPTE_VALID(HPTE(spapr->htab, index))) {
2259             CLEAN_HPTE(HPTE(spapr->htab, index));
2260             index++;
2261             examined++;
2262         }
2263
2264         invalidstart = index;
2265         /* Consume invalid dirty HPTEs */
2266         while ((index < htabslots) && (index - invalidstart < USHRT_MAX)
2267                && HPTE_DIRTY(HPTE(spapr->htab, index))
2268                && !HPTE_VALID(HPTE(spapr->htab, index))) {
2269             CLEAN_HPTE(HPTE(spapr->htab, index));
2270             index++;
2271             examined++;
2272         }
2273
2274         if (index > chunkstart) {
2275             int n_valid = invalidstart - chunkstart;
2276             int n_invalid = index - invalidstart;
2277
2278             htab_save_chunk(f, spapr, chunkstart, n_valid, n_invalid);
2279             sent += index - chunkstart;
2280
2281             if (!final && (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) {
2282                 break;
2283             }
2284         }
2285
2286         if (examined >= htabslots) {
2287             break;
2288         }
2289
2290         if (index >= htabslots) {
2291             assert(index == htabslots);
2292             index = 0;
2293         }
2294     } while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final));
2295
2296     if (index >= htabslots) {
2297         assert(index == htabslots);
2298         index = 0;
2299     }
2300
2301     spapr->htab_save_index = index;
2302
2303     return (examined >= htabslots) && (sent == 0) ? 1 : 0;
2304 }
2305
2306 #define MAX_ITERATION_NS    5000000 /* 5 ms */
2307 #define MAX_KVM_BUF_SIZE    2048
2308
2309 static int htab_save_iterate(QEMUFile *f, void *opaque)
2310 {
2311     SpaprMachineState *spapr = opaque;
2312     int fd;
2313     int rc = 0;
2314
2315     /* Iteration header */
2316     if (!spapr->htab_shift) {
2317         qemu_put_be32(f, -1);
2318         return 1;
2319     } else {
2320         qemu_put_be32(f, 0);
2321     }
2322
2323     if (!spapr->htab) {
2324         assert(kvm_enabled());
2325
2326         fd = get_htab_fd(spapr);
2327         if (fd < 0) {
2328             return fd;
2329         }
2330
2331         rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, MAX_ITERATION_NS);
2332         if (rc < 0) {
2333             return rc;
2334         }
2335     } else  if (spapr->htab_first_pass) {
2336         htab_save_first_pass(f, spapr, MAX_ITERATION_NS);
2337     } else {
2338         rc = htab_save_later_pass(f, spapr, MAX_ITERATION_NS);
2339     }
2340
2341     htab_save_end_marker(f);
2342
2343     return rc;
2344 }
2345
2346 static int htab_save_complete(QEMUFile *f, void *opaque)
2347 {
2348     SpaprMachineState *spapr = opaque;
2349     int fd;
2350
2351     /* Iteration header */
2352     if (!spapr->htab_shift) {
2353         qemu_put_be32(f, -1);
2354         return 0;
2355     } else {
2356         qemu_put_be32(f, 0);
2357     }
2358
2359     if (!spapr->htab) {
2360         int rc;
2361
2362         assert(kvm_enabled());
2363
2364         fd = get_htab_fd(spapr);
2365         if (fd < 0) {
2366             return fd;
2367         }
2368
2369         rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, -1);
2370         if (rc < 0) {
2371             return rc;
2372         }
2373     } else {
2374         if (spapr->htab_first_pass) {
2375             htab_save_first_pass(f, spapr, -1);
2376         }
2377         htab_save_later_pass(f, spapr, -1);
2378     }
2379
2380     /* End marker */
2381     htab_save_end_marker(f);
2382
2383     return 0;
2384 }
2385
2386 static int htab_load(QEMUFile *f, void *opaque, int version_id)
2387 {
2388     SpaprMachineState *spapr = opaque;
2389     uint32_t section_hdr;
2390     int fd = -1;
2391     Error *local_err = NULL;
2392
2393     if (version_id < 1 || version_id > 1) {
2394         error_report("htab_load() bad version");
2395         return -EINVAL;
2396     }
2397
2398     section_hdr = qemu_get_be32(f);
2399
2400     if (section_hdr == -1) {
2401         spapr_free_hpt(spapr);
2402         return 0;
2403     }
2404
2405     if (section_hdr) {
2406         /* First section gives the htab size */
2407         spapr_reallocate_hpt(spapr, section_hdr, &local_err);
2408         if (local_err) {
2409             error_report_err(local_err);
2410             return -EINVAL;
2411         }
2412         return 0;
2413     }
2414
2415     if (!spapr->htab) {
2416         assert(kvm_enabled());
2417
2418         fd = kvmppc_get_htab_fd(true, 0, &local_err);
2419         if (fd < 0) {
2420             error_report_err(local_err);
2421             return fd;
2422         }
2423     }
2424
2425     while (true) {
2426         uint32_t index;
2427         uint16_t n_valid, n_invalid;
2428
2429         index = qemu_get_be32(f);
2430         n_valid = qemu_get_be16(f);
2431         n_invalid = qemu_get_be16(f);
2432
2433         if ((index == 0) && (n_valid == 0) && (n_invalid == 0)) {
2434             /* End of Stream */
2435             break;
2436         }
2437
2438         if ((index + n_valid + n_invalid) >
2439             (HTAB_SIZE(spapr) / HASH_PTE_SIZE_64)) {
2440             /* Bad index in stream */
2441             error_report(
2442                 "htab_load() bad index %d (%hd+%hd entries) in htab stream (htab_shift=%d)",
2443                 index, n_valid, n_invalid, spapr->htab_shift);
2444             return -EINVAL;
2445         }
2446
2447         if (spapr->htab) {
2448             if (n_valid) {
2449                 qemu_get_buffer(f, HPTE(spapr->htab, index),
2450                                 HASH_PTE_SIZE_64 * n_valid);
2451             }
2452             if (n_invalid) {
2453                 memset(HPTE(spapr->htab, index + n_valid), 0,
2454                        HASH_PTE_SIZE_64 * n_invalid);
2455             }
2456         } else {
2457             int rc;
2458
2459             assert(fd >= 0);
2460
2461             rc = kvmppc_load_htab_chunk(f, fd, index, n_valid, n_invalid);
2462             if (rc < 0) {
2463                 return rc;
2464             }
2465         }
2466     }
2467
2468     if (!spapr->htab) {
2469         assert(fd >= 0);
2470         close(fd);
2471     }
2472
2473     return 0;
2474 }
2475
2476 static void htab_save_cleanup(void *opaque)
2477 {
2478     SpaprMachineState *spapr = opaque;
2479
2480     close_htab_fd(spapr);
2481 }
2482
2483 static SaveVMHandlers savevm_htab_handlers = {
2484     .save_setup = htab_save_setup,
2485     .save_live_iterate = htab_save_iterate,
2486     .save_live_complete_precopy = htab_save_complete,
2487     .save_cleanup = htab_save_cleanup,
2488     .load_state = htab_load,
2489 };
2490
2491 static void spapr_boot_set(void *opaque, const char *boot_device,
2492                            Error **errp)
2493 {
2494     MachineState *machine = MACHINE(opaque);
2495     machine->boot_order = g_strdup(boot_device);
2496 }
2497
2498 static void spapr_create_lmb_dr_connectors(SpaprMachineState *spapr)
2499 {
2500     MachineState *machine = MACHINE(spapr);
2501     uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE;
2502     uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size;
2503     int i;
2504
2505     for (i = 0; i < nr_lmbs; i++) {
2506         uint64_t addr;
2507
2508         addr = i * lmb_size + machine->device_memory->base;
2509         spapr_dr_connector_new(OBJECT(spapr), TYPE_SPAPR_DRC_LMB,
2510                                addr / lmb_size);
2511     }
2512 }
2513
2514 /*
2515  * If RAM size, maxmem size and individual node mem sizes aren't aligned
2516  * to SPAPR_MEMORY_BLOCK_SIZE(256MB), then refuse to start the guest
2517  * since we can't support such unaligned sizes with DRCONF_MEMORY.
2518  */
2519 static void spapr_validate_node_memory(MachineState *machine, Error **errp)
2520 {
2521     int i;
2522
2523     if (machine->ram_size % SPAPR_MEMORY_BLOCK_SIZE) {
2524         error_setg(errp, "Memory size 0x" RAM_ADDR_FMT
2525                    " is not aligned to %" PRIu64 " MiB",
2526                    machine->ram_size,
2527                    SPAPR_MEMORY_BLOCK_SIZE / MiB);
2528         return;
2529     }
2530
2531     if (machine->maxram_size % SPAPR_MEMORY_BLOCK_SIZE) {
2532         error_setg(errp, "Maximum memory size 0x" RAM_ADDR_FMT
2533                    " is not aligned to %" PRIu64 " MiB",
2534                    machine->ram_size,
2535                    SPAPR_MEMORY_BLOCK_SIZE / MiB);
2536         return;
2537     }
2538
2539     for (i = 0; i < machine->numa_state->num_nodes; i++) {
2540         if (machine->numa_state->nodes[i].node_mem % SPAPR_MEMORY_BLOCK_SIZE) {
2541             error_setg(errp,
2542                        "Node %d memory size 0x%" PRIx64
2543                        " is not aligned to %" PRIu64 " MiB",
2544                        i, machine->numa_state->nodes[i].node_mem,
2545                        SPAPR_MEMORY_BLOCK_SIZE / MiB);
2546             return;
2547         }
2548     }
2549 }
2550
2551 /* find cpu slot in machine->possible_cpus by core_id */
2552 static CPUArchId *spapr_find_cpu_slot(MachineState *ms, uint32_t id, int *idx)
2553 {
2554     int index = id / ms->smp.threads;
2555
2556     if (index >= ms->possible_cpus->len) {
2557         return NULL;
2558     }
2559     if (idx) {
2560         *idx = index;
2561     }
2562     return &ms->possible_cpus->cpus[index];
2563 }
2564
2565 static void spapr_set_vsmt_mode(SpaprMachineState *spapr, Error **errp)
2566 {
2567     MachineState *ms = MACHINE(spapr);
2568     Error *local_err = NULL;
2569     bool vsmt_user = !!spapr->vsmt;
2570     int kvm_smt = kvmppc_smt_threads();
2571     int ret;
2572     unsigned int smp_threads = ms->smp.threads;
2573
2574     if (!kvm_enabled() && (smp_threads > 1)) {
2575         error_setg(&local_err, "TCG cannot support more than 1 thread/core "
2576                      "on a pseries machine");
2577         goto out;
2578     }
2579     if (!is_power_of_2(smp_threads)) {
2580         error_setg(&local_err, "Cannot support %d threads/core on a pseries "
2581                      "machine because it must be a power of 2", smp_threads);
2582         goto out;
2583     }
2584
2585     /* Detemine the VSMT mode to use: */
2586     if (vsmt_user) {
2587         if (spapr->vsmt < smp_threads) {
2588             error_setg(&local_err, "Cannot support VSMT mode %d"
2589                          " because it must be >= threads/core (%d)",
2590                          spapr->vsmt, smp_threads);
2591             goto out;
2592         }
2593         /* In this case, spapr->vsmt has been set by the command line */
2594     } else {
2595         /*
2596          * Default VSMT value is tricky, because we need it to be as
2597          * consistent as possible (for migration), but this requires
2598          * changing it for at least some existing cases.  We pick 8 as
2599          * the value that we'd get with KVM on POWER8, the
2600          * overwhelmingly common case in production systems.
2601          */
2602         spapr->vsmt = MAX(8, smp_threads);
2603     }
2604
2605     /* KVM: If necessary, set the SMT mode: */
2606     if (kvm_enabled() && (spapr->vsmt != kvm_smt)) {
2607         ret = kvmppc_set_smt_threads(spapr->vsmt);
2608         if (ret) {
2609             /* Looks like KVM isn't able to change VSMT mode */
2610             error_setg(&local_err,
2611                        "Failed to set KVM's VSMT mode to %d (errno %d)",
2612                        spapr->vsmt, ret);
2613             /* We can live with that if the default one is big enough
2614              * for the number of threads, and a submultiple of the one
2615              * we want.  In this case we'll waste some vcpu ids, but
2616              * behaviour will be correct */
2617             if ((kvm_smt >= smp_threads) && ((spapr->vsmt % kvm_smt) == 0)) {
2618                 warn_report_err(local_err);
2619                 local_err = NULL;
2620                 goto out;
2621             } else {
2622                 if (!vsmt_user) {
2623                     error_append_hint(&local_err,
2624                                       "On PPC, a VM with %d threads/core"
2625                                       " on a host with %d threads/core"
2626                                       " requires the use of VSMT mode %d.\n",
2627                                       smp_threads, kvm_smt, spapr->vsmt);
2628                 }
2629                 kvmppc_hint_smt_possible(&local_err);
2630                 goto out;
2631             }
2632         }
2633     }
2634     /* else TCG: nothing to do currently */
2635 out:
2636     error_propagate(errp, local_err);
2637 }
2638
2639 static void spapr_init_cpus(SpaprMachineState *spapr)
2640 {
2641     MachineState *machine = MACHINE(spapr);
2642     MachineClass *mc = MACHINE_GET_CLASS(machine);
2643     SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine);
2644     const char *type = spapr_get_cpu_core_type(machine->cpu_type);
2645     const CPUArchIdList *possible_cpus;
2646     unsigned int smp_cpus = machine->smp.cpus;
2647     unsigned int smp_threads = machine->smp.threads;
2648     unsigned int max_cpus = machine->smp.max_cpus;
2649     int boot_cores_nr = smp_cpus / smp_threads;
2650     int i;
2651
2652     possible_cpus = mc->possible_cpu_arch_ids(machine);
2653     if (mc->has_hotpluggable_cpus) {
2654         if (smp_cpus % smp_threads) {
2655             error_report("smp_cpus (%u) must be multiple of threads (%u)",
2656                          smp_cpus, smp_threads);
2657             exit(1);
2658         }
2659         if (max_cpus % smp_threads) {
2660             error_report("max_cpus (%u) must be multiple of threads (%u)",
2661                          max_cpus, smp_threads);
2662             exit(1);
2663         }
2664     } else {
2665         if (max_cpus != smp_cpus) {
2666             error_report("This machine version does not support CPU hotplug");
2667             exit(1);
2668         }
2669         boot_cores_nr = possible_cpus->len;
2670     }
2671
2672     if (smc->pre_2_10_has_unused_icps) {
2673         int i;
2674
2675         for (i = 0; i < spapr_max_server_number(spapr); i++) {
2676             /* Dummy entries get deregistered when real ICPState objects
2677              * are registered during CPU core hotplug.
2678              */
2679             pre_2_10_vmstate_register_dummy_icp(i);
2680         }
2681     }
2682
2683     for (i = 0; i < possible_cpus->len; i++) {
2684         int core_id = i * smp_threads;
2685
2686         if (mc->has_hotpluggable_cpus) {
2687             spapr_dr_connector_new(OBJECT(spapr), TYPE_SPAPR_DRC_CPU,
2688                                    spapr_vcpu_id(spapr, core_id));
2689         }
2690
2691         if (i < boot_cores_nr) {
2692             Object *core  = object_new(type);
2693             int nr_threads = smp_threads;
2694
2695             /* Handle the partially filled core for older machine types */
2696             if ((i + 1) * smp_threads >= smp_cpus) {
2697                 nr_threads = smp_cpus - i * smp_threads;
2698             }
2699
2700             object_property_set_int(core, nr_threads, "nr-threads",
2701                                     &error_fatal);
2702             object_property_set_int(core, core_id, CPU_CORE_PROP_CORE_ID,
2703                                     &error_fatal);
2704             object_property_set_bool(core, true, "realized", &error_fatal);
2705
2706             object_unref(core);
2707         }
2708     }
2709 }
2710
2711 static PCIHostState *spapr_create_default_phb(void)
2712 {
2713     DeviceState *dev;
2714
2715     dev = qdev_create(NULL, TYPE_SPAPR_PCI_HOST_BRIDGE);
2716     qdev_prop_set_uint32(dev, "index", 0);
2717     qdev_init_nofail(dev);
2718
2719     return PCI_HOST_BRIDGE(dev);
2720 }
2721
2722 /* pSeries LPAR / sPAPR hardware init */
2723 static void spapr_machine_init(MachineState *machine)
2724 {
2725     SpaprMachineState *spapr = SPAPR_MACHINE(machine);
2726     SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine);
2727     const char *kernel_filename = machine->kernel_filename;
2728     const char *initrd_filename = machine->initrd_filename;
2729     PCIHostState *phb;
2730     int i;
2731     MemoryRegion *sysmem = get_system_memory();
2732     MemoryRegion *ram = g_new(MemoryRegion, 1);
2733     hwaddr node0_size = spapr_node0_size(machine);
2734     long load_limit, fw_size;
2735     char *filename;
2736     Error *resize_hpt_err = NULL;
2737
2738     msi_nonbroken = true;
2739
2740     QLIST_INIT(&spapr->phbs);
2741     QTAILQ_INIT(&spapr->pending_dimm_unplugs);
2742
2743     /* Determine capabilities to run with */
2744     spapr_caps_init(spapr);
2745
2746     kvmppc_check_papr_resize_hpt(&resize_hpt_err);
2747     if (spapr->resize_hpt == SPAPR_RESIZE_HPT_DEFAULT) {
2748         /*
2749          * If the user explicitly requested a mode we should either
2750          * supply it, or fail completely (which we do below).  But if
2751          * it's not set explicitly, we reset our mode to something
2752          * that works
2753          */
2754         if (resize_hpt_err) {
2755             spapr->resize_hpt = SPAPR_RESIZE_HPT_DISABLED;
2756             error_free(resize_hpt_err);
2757             resize_hpt_err = NULL;
2758         } else {
2759             spapr->resize_hpt = smc->resize_hpt_default;
2760         }
2761     }
2762
2763     assert(spapr->resize_hpt != SPAPR_RESIZE_HPT_DEFAULT);
2764
2765     if ((spapr->resize_hpt != SPAPR_RESIZE_HPT_DISABLED) && resize_hpt_err) {
2766         /*
2767          * User requested HPT resize, but this host can't supply it.  Bail out
2768          */
2769         error_report_err(resize_hpt_err);
2770         exit(1);
2771     }
2772
2773     spapr->rma_size = node0_size;
2774
2775     /* With KVM, we don't actually know whether KVM supports an
2776      * unbounded RMA (PR KVM) or is limited by the hash table size
2777      * (HV KVM using VRMA), so we always assume the latter
2778      *
2779      * In that case, we also limit the initial allocations for RTAS
2780      * etc... to 256M since we have no way to know what the VRMA size
2781      * is going to be as it depends on the size of the hash table
2782      * which isn't determined yet.
2783      */
2784     if (kvm_enabled()) {
2785         spapr->vrma_adjust = 1;
2786         spapr->rma_size = MIN(spapr->rma_size, 0x10000000);
2787     }
2788
2789     /* Actually we don't support unbounded RMA anymore since we added
2790      * proper emulation of HV mode. The max we can get is 16G which
2791      * also happens to be what we configure for PAPR mode so make sure
2792      * we don't do anything bigger than that
2793      */
2794     spapr->rma_size = MIN(spapr->rma_size, 0x400000000ull);
2795
2796     if (spapr->rma_size > node0_size) {
2797         error_report("Numa node 0 has to span the RMA (%#08"HWADDR_PRIx")",
2798                      spapr->rma_size);
2799         exit(1);
2800     }
2801
2802     /* Setup a load limit for the ramdisk leaving room for SLOF and FDT */
2803     load_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR) - FW_OVERHEAD;
2804
2805     /*
2806      * VSMT must be set in order to be able to compute VCPU ids, ie to
2807      * call spapr_max_server_number() or spapr_vcpu_id().
2808      */
2809     spapr_set_vsmt_mode(spapr, &error_fatal);
2810
2811     /* Set up Interrupt Controller before we create the VCPUs */
2812     spapr_irq_init(spapr, &error_fatal);
2813
2814     /* Set up containers for ibm,client-architecture-support negotiated options
2815      */
2816     spapr->ov5 = spapr_ovec_new();
2817     spapr->ov5_cas = spapr_ovec_new();
2818
2819     if (smc->dr_lmb_enabled) {
2820         spapr_ovec_set(spapr->ov5, OV5_DRCONF_MEMORY);
2821         spapr_validate_node_memory(machine, &error_fatal);
2822     }
2823
2824     spapr_ovec_set(spapr->ov5, OV5_FORM1_AFFINITY);
2825
2826     /* advertise support for dedicated HP event source to guests */
2827     if (spapr->use_hotplug_event_source) {
2828         spapr_ovec_set(spapr->ov5, OV5_HP_EVT);
2829     }
2830
2831     /* advertise support for HPT resizing */
2832     if (spapr->resize_hpt != SPAPR_RESIZE_HPT_DISABLED) {
2833         spapr_ovec_set(spapr->ov5, OV5_HPT_RESIZE);
2834     }
2835
2836     /* advertise support for ibm,dyamic-memory-v2 */
2837     spapr_ovec_set(spapr->ov5, OV5_DRMEM_V2);
2838
2839     /* advertise XIVE on POWER9 machines */
2840     if (spapr->irq->ov5 & (SPAPR_OV5_XIVE_EXPLOIT | SPAPR_OV5_XIVE_BOTH)) {
2841         spapr_ovec_set(spapr->ov5, OV5_XIVE_EXPLOIT);
2842     }
2843
2844     /* init CPUs */
2845     spapr_init_cpus(spapr);
2846
2847     /*
2848      * check we don't have a memory-less/cpu-less NUMA node
2849      * Firmware relies on the existing memory/cpu topology to provide the
2850      * NUMA topology to the kernel.
2851      * And the linux kernel needs to know the NUMA topology at start
2852      * to be able to hotplug CPUs later.
2853      */
2854     if (machine->numa_state->num_nodes) {
2855         for (i = 0; i < machine->numa_state->num_nodes; ++i) {
2856             /* check for memory-less node */
2857             if (machine->numa_state->nodes[i].node_mem == 0) {
2858                 CPUState *cs;
2859                 int found = 0;
2860                 /* check for cpu-less node */
2861                 CPU_FOREACH(cs) {
2862                     PowerPCCPU *cpu = POWERPC_CPU(cs);
2863                     if (cpu->node_id == i) {
2864                         found = 1;
2865                         break;
2866                     }
2867                 }
2868                 /* memory-less and cpu-less node */
2869                 if (!found) {
2870                     error_report(
2871                        "Memory-less/cpu-less nodes are not supported (node %d)",
2872                                  i);
2873                     exit(1);
2874                 }
2875             }
2876         }
2877
2878     }
2879
2880     /*
2881      * NVLink2-connected GPU RAM needs to be placed on a separate NUMA node.
2882      * We assign a new numa ID per GPU in spapr_pci_collect_nvgpu() which is
2883      * called from vPHB reset handler so we initialize the counter here.
2884      * If no NUMA is configured from the QEMU side, we start from 1 as GPU RAM
2885      * must be equally distant from any other node.
2886      * The final value of spapr->gpu_numa_id is going to be written to
2887      * max-associativity-domains in spapr_build_fdt().
2888      */
2889     spapr->gpu_numa_id = MAX(1, machine->numa_state->num_nodes);
2890
2891     if ((!kvm_enabled() || kvmppc_has_cap_mmu_radix()) &&
2892         ppc_type_check_compat(machine->cpu_type, CPU_POWERPC_LOGICAL_3_00, 0,
2893                               spapr->max_compat_pvr)) {
2894         /* KVM and TCG always allow GTSE with radix... */
2895         spapr_ovec_set(spapr->ov5, OV5_MMU_RADIX_GTSE);
2896     }
2897     /* ... but not with hash (currently). */
2898
2899     if (kvm_enabled()) {
2900         /* Enable H_LOGICAL_CI_* so SLOF can talk to in-kernel devices */
2901         kvmppc_enable_logical_ci_hcalls();
2902         kvmppc_enable_set_mode_hcall();
2903
2904         /* H_CLEAR_MOD/_REF are mandatory in PAPR, but off by default */
2905         kvmppc_enable_clear_ref_mod_hcalls();
2906
2907         /* Enable H_PAGE_INIT */
2908         kvmppc_enable_h_page_init();
2909     }
2910
2911     /* allocate RAM */
2912     memory_region_allocate_system_memory(ram, NULL, "ppc_spapr.ram",
2913                                          machine->ram_size);
2914     memory_region_add_subregion(sysmem, 0, ram);
2915
2916     /* always allocate the device memory information */
2917     machine->device_memory = g_malloc0(sizeof(*machine->device_memory));
2918
2919     /* initialize hotplug memory address space */
2920     if (machine->ram_size < machine->maxram_size) {
2921         ram_addr_t device_mem_size = machine->maxram_size - machine->ram_size;
2922         /*
2923          * Limit the number of hotpluggable memory slots to half the number
2924          * slots that KVM supports, leaving the other half for PCI and other
2925          * devices. However ensure that number of slots doesn't drop below 32.
2926          */
2927         int max_memslots = kvm_enabled() ? kvm_get_max_memslots() / 2 :
2928                            SPAPR_MAX_RAM_SLOTS;
2929
2930         if (max_memslots < SPAPR_MAX_RAM_SLOTS) {
2931             max_memslots = SPAPR_MAX_RAM_SLOTS;
2932         }
2933         if (machine->ram_slots > max_memslots) {
2934             error_report("Specified number of memory slots %"
2935                          PRIu64" exceeds max supported %d",
2936                          machine->ram_slots, max_memslots);
2937             exit(1);
2938         }
2939
2940         machine->device_memory->base = ROUND_UP(machine->ram_size,
2941                                                 SPAPR_DEVICE_MEM_ALIGN);
2942         memory_region_init(&machine->device_memory->mr, OBJECT(spapr),
2943                            "device-memory", device_mem_size);
2944         memory_region_add_subregion(sysmem, machine->device_memory->base,
2945                                     &machine->device_memory->mr);
2946     }
2947
2948     if (smc->dr_lmb_enabled) {
2949         spapr_create_lmb_dr_connectors(spapr);
2950     }
2951
2952     filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin");
2953     if (!filename) {
2954         error_report("Could not find LPAR rtas '%s'", "spapr-rtas.bin");
2955         exit(1);
2956     }
2957     spapr->rtas_size = get_image_size(filename);
2958     if (spapr->rtas_size < 0) {
2959         error_report("Could not get size of LPAR rtas '%s'", filename);
2960         exit(1);
2961     }
2962     spapr->rtas_blob = g_malloc(spapr->rtas_size);
2963     if (load_image_size(filename, spapr->rtas_blob, spapr->rtas_size) < 0) {
2964         error_report("Could not load LPAR rtas '%s'", filename);
2965         exit(1);
2966     }
2967     if (spapr->rtas_size > RTAS_MAX_SIZE) {
2968         error_report("RTAS too big ! 0x%zx bytes (max is 0x%x)",
2969                      (size_t)spapr->rtas_size, RTAS_MAX_SIZE);
2970         exit(1);
2971     }
2972     g_free(filename);
2973
2974     /* Set up RTAS event infrastructure */
2975     spapr_events_init(spapr);
2976
2977     /* Set up the RTC RTAS interfaces */
2978     spapr_rtc_create(spapr);
2979
2980     /* Set up VIO bus */
2981     spapr->vio_bus = spapr_vio_bus_init();
2982
2983     for (i = 0; i < serial_max_hds(); i++) {
2984         if (serial_hd(i)) {
2985             spapr_vty_create(spapr->vio_bus, serial_hd(i));
2986         }
2987     }
2988
2989     /* We always have at least the nvram device on VIO */
2990     spapr_create_nvram(spapr);
2991
2992     /*
2993      * Setup hotplug / dynamic-reconfiguration connectors. top-level
2994      * connectors (described in root DT node's "ibm,drc-types" property)
2995      * are pre-initialized here. additional child connectors (such as
2996      * connectors for a PHBs PCI slots) are added as needed during their
2997      * parent's realization.
2998      */
2999     if (smc->dr_phb_enabled) {
3000         for (i = 0; i < SPAPR_MAX_PHBS; i++) {
3001             spapr_dr_connector_new(OBJECT(machine), TYPE_SPAPR_DRC_PHB, i);
3002         }
3003     }
3004
3005     /* Set up PCI */
3006     spapr_pci_rtas_init();
3007
3008     phb = spapr_create_default_phb();
3009
3010     for (i = 0; i < nb_nics; i++) {
3011         NICInfo *nd = &nd_table[i];
3012
3013         if (!nd->model) {
3014             nd->model = g_strdup("spapr-vlan");
3015         }
3016
3017         if (g_str_equal(nd->model, "spapr-vlan") ||
3018             g_str_equal(nd->model, "ibmveth")) {
3019             spapr_vlan_create(spapr->vio_bus, nd);
3020         } else {
3021             pci_nic_init_nofail(&nd_table[i], phb->bus, nd->model, NULL);
3022         }
3023     }
3024
3025     for (i = 0; i <= drive_get_max_bus(IF_SCSI); i++) {
3026         spapr_vscsi_create(spapr->vio_bus);
3027     }
3028
3029     /* Graphics */
3030     if (spapr_vga_init(phb->bus, &error_fatal)) {
3031         spapr->has_graphics = true;
3032         machine->usb |= defaults_enabled() && !machine->usb_disabled;
3033     }
3034
3035     if (machine->usb) {
3036         if (smc->use_ohci_by_default) {
3037             pci_create_simple(phb->bus, -1, "pci-ohci");
3038         } else {
3039             pci_create_simple(phb->bus, -1, "nec-usb-xhci");
3040         }
3041
3042         if (spapr->has_graphics) {
3043             USBBus *usb_bus = usb_bus_find(-1);
3044
3045             usb_create_simple(usb_bus, "usb-kbd");
3046             usb_create_simple(usb_bus, "usb-mouse");
3047         }
3048     }
3049
3050     if (spapr->rma_size < (MIN_RMA_SLOF * MiB)) {
3051         error_report(
3052             "pSeries SLOF firmware requires >= %ldM guest RMA (Real Mode Area memory)",
3053             MIN_RMA_SLOF);
3054         exit(1);
3055     }
3056
3057     if (kernel_filename) {
3058         uint64_t lowaddr = 0;
3059
3060         spapr->kernel_size = load_elf(kernel_filename, NULL,
3061                                       translate_kernel_address, NULL,
3062                                       NULL, &lowaddr, NULL, 1,
3063                                       PPC_ELF_MACHINE, 0, 0);
3064         if (spapr->kernel_size == ELF_LOAD_WRONG_ENDIAN) {
3065             spapr->kernel_size = load_elf(kernel_filename, NULL,
3066                                           translate_kernel_address, NULL, NULL,
3067                                           &lowaddr, NULL, 0, PPC_ELF_MACHINE,
3068                                           0, 0);
3069             spapr->kernel_le = spapr->kernel_size > 0;
3070         }
3071         if (spapr->kernel_size < 0) {
3072             error_report("error loading %s: %s", kernel_filename,
3073                          load_elf_strerror(spapr->kernel_size));
3074             exit(1);
3075         }
3076
3077         /* load initrd */
3078         if (initrd_filename) {
3079             /* Try to locate the initrd in the gap between the kernel
3080              * and the firmware. Add a bit of space just in case
3081              */
3082             spapr->initrd_base = (KERNEL_LOAD_ADDR + spapr->kernel_size
3083                                   + 0x1ffff) & ~0xffff;
3084             spapr->initrd_size = load_image_targphys(initrd_filename,
3085                                                      spapr->initrd_base,
3086                                                      load_limit
3087                                                      - spapr->initrd_base);
3088             if (spapr->initrd_size < 0) {
3089                 error_report("could not load initial ram disk '%s'",
3090                              initrd_filename);
3091                 exit(1);
3092             }
3093         }
3094     }
3095
3096     if (bios_name == NULL) {
3097         bios_name = FW_FILE_NAME;
3098     }
3099     filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
3100     if (!filename) {
3101         error_report("Could not find LPAR firmware '%s'", bios_name);
3102         exit(1);
3103     }
3104     fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE);
3105     if (fw_size <= 0) {
3106         error_report("Could not load LPAR firmware '%s'", filename);
3107         exit(1);
3108     }
3109     g_free(filename);
3110
3111     /* FIXME: Should register things through the MachineState's qdev
3112      * interface, this is a legacy from the sPAPREnvironment structure
3113      * which predated MachineState but had a similar function */
3114     vmstate_register(NULL, 0, &vmstate_spapr, spapr);
3115     register_savevm_live("spapr/htab", -1, 1,
3116                          &savevm_htab_handlers, spapr);
3117
3118     qbus_set_hotplug_handler(sysbus_get_default(), OBJECT(machine),
3119                              &error_fatal);
3120
3121     qemu_register_boot_set(spapr_boot_set, spapr);
3122
3123     /*
3124      * Nothing needs to be done to resume a suspended guest because
3125      * suspending does not change the machine state, so no need for
3126      * a ->wakeup method.
3127      */
3128     qemu_register_wakeup_support();
3129
3130     if (kvm_enabled()) {
3131         /* to stop and start vmclock */
3132         qemu_add_vm_change_state_handler(cpu_ppc_clock_vm_state_change,
3133                                          &spapr->tb);
3134
3135         kvmppc_spapr_enable_inkernel_multitce();
3136     }
3137 }
3138
3139 static int spapr_kvm_type(MachineState *machine, const char *vm_type)
3140 {
3141     if (!vm_type) {
3142         return 0;
3143     }
3144
3145     if (!strcmp(vm_type, "HV")) {
3146         return 1;
3147     }
3148
3149     if (!strcmp(vm_type, "PR")) {
3150         return 2;
3151     }
3152
3153     error_report("Unknown kvm-type specified '%s'", vm_type);
3154     exit(1);
3155 }
3156
3157 /*
3158  * Implementation of an interface to adjust firmware path
3159  * for the bootindex property handling.
3160  */
3161 static char *spapr_get_fw_dev_path(FWPathProvider *p, BusState *bus,
3162                                    DeviceState *dev)
3163 {
3164 #define CAST(type, obj, name) \
3165     ((type *)object_dynamic_cast(OBJECT(obj), (name)))
3166     SCSIDevice *d = CAST(SCSIDevice,  dev, TYPE_SCSI_DEVICE);
3167     SpaprPhbState *phb = CAST(SpaprPhbState, dev, TYPE_SPAPR_PCI_HOST_BRIDGE);
3168     VHostSCSICommon *vsc = CAST(VHostSCSICommon, dev, TYPE_VHOST_SCSI_COMMON);
3169
3170     if (d) {
3171         void *spapr = CAST(void, bus->parent, "spapr-vscsi");
3172         VirtIOSCSI *virtio = CAST(VirtIOSCSI, bus->parent, TYPE_VIRTIO_SCSI);
3173         USBDevice *usb = CAST(USBDevice, bus->parent, TYPE_USB_DEVICE);
3174
3175         if (spapr) {
3176             /*
3177              * Replace "channel@0/disk@0,0" with "disk@8000000000000000":
3178              * In the top 16 bits of the 64-bit LUN, we use SRP luns of the form
3179              * 0x8000 | (target << 8) | (bus << 5) | lun
3180              * (see the "Logical unit addressing format" table in SAM5)
3181              */
3182             unsigned id = 0x8000 | (d->id << 8) | (d->channel << 5) | d->lun;
3183             return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev),
3184                                    (uint64_t)id << 48);
3185         } else if (virtio) {
3186             /*
3187              * We use SRP luns of the form 01000000 | (target << 8) | lun
3188              * in the top 32 bits of the 64-bit LUN
3189              * Note: the quote above is from SLOF and it is wrong,
3190              * the actual binding is:
3191              * swap 0100 or 10 << or 20 << ( target lun-id -- srplun )
3192              */
3193             unsigned id = 0x1000000 | (d->id << 16) | d->lun;
3194             if (d->lun >= 256) {
3195                 /* Use the LUN "flat space addressing method" */
3196                 id |= 0x4000;
3197             }
3198             return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev),
3199                                    (uint64_t)id << 32);
3200         } else if (usb) {
3201             /*
3202              * We use SRP luns of the form 01000000 | (usb-port << 16) | lun
3203              * in the top 32 bits of the 64-bit LUN
3204              */
3205             unsigned usb_port = atoi(usb->port->path);
3206             unsigned id = 0x1000000 | (usb_port << 16) | d->lun;
3207             return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev),
3208                                    (uint64_t)id << 32);
3209         }
3210     }
3211
3212     /*
3213      * SLOF probes the USB devices, and if it recognizes that the device is a
3214      * storage device, it changes its name to "storage" instead of "usb-host",
3215      * and additionally adds a child node for the SCSI LUN, so the correct
3216      * boot path in SLOF is something like .../storage@1/disk@xxx" instead.
3217      */
3218     if (strcmp("usb-host", qdev_fw_name(dev)) == 0) {
3219         USBDevice *usbdev = CAST(USBDevice, dev, TYPE_USB_DEVICE);
3220         if (usb_host_dev_is_scsi_storage(usbdev)) {
3221             return g_strdup_printf("storage@%s/disk", usbdev->port->path);
3222         }
3223     }
3224
3225     if (phb) {
3226         /* Replace "pci" with "pci@800000020000000" */
3227         return g_strdup_printf("pci@%"PRIX64, phb->buid);
3228     }
3229
3230     if (vsc) {
3231         /* Same logic as virtio above */
3232         unsigned id = 0x1000000 | (vsc->target << 16) | vsc->lun;
3233         return g_strdup_printf("disk@%"PRIX64, (uint64_t)id << 32);
3234     }
3235
3236     if (g_str_equal("pci-bridge", qdev_fw_name(dev))) {
3237         /* SLOF uses "pci" instead of "pci-bridge" for PCI bridges */
3238         PCIDevice *pcidev = CAST(PCIDevice, dev, TYPE_PCI_DEVICE);
3239         return g_strdup_printf("pci@%x", PCI_SLOT(pcidev->devfn));
3240     }
3241
3242     return NULL;
3243 }
3244
3245 static char *spapr_get_kvm_type(Object *obj, Error **errp)
3246 {
3247     SpaprMachineState *spapr = SPAPR_MACHINE(obj);
3248
3249     return g_strdup(spapr->kvm_type);
3250 }
3251
3252 static void spapr_set_kvm_type(Object *obj, const char *value, Error **errp)
3253 {
3254     SpaprMachineState *spapr = SPAPR_MACHINE(obj);
3255
3256     g_free(spapr->kvm_type);
3257     spapr->kvm_type = g_strdup(value);
3258 }
3259
3260 static bool spapr_get_modern_hotplug_events(Object *obj, Error **errp)
3261 {
3262     SpaprMachineState *spapr = SPAPR_MACHINE(obj);
3263
3264     return spapr->use_hotplug_event_source;
3265 }
3266
3267 static void spapr_set_modern_hotplug_events(Object *obj, bool value,
3268                                             Error **errp)
3269 {
3270     SpaprMachineState *spapr = SPAPR_MACHINE(obj);
3271
3272     spapr->use_hotplug_event_source = value;
3273 }
3274
3275 static bool spapr_get_msix_emulation(Object *obj, Error **errp)
3276 {
3277     return true;
3278 }
3279
3280 static char *spapr_get_resize_hpt(Object *obj, Error **errp)
3281 {
3282     SpaprMachineState *spapr = SPAPR_MACHINE(obj);
3283
3284     switch (spapr->resize_hpt) {
3285     case SPAPR_RESIZE_HPT_DEFAULT:
3286         return g_strdup("default");
3287     case SPAPR_RESIZE_HPT_DISABLED:
3288         return g_strdup("disabled");
3289     case SPAPR_RESIZE_HPT_ENABLED:
3290         return g_strdup("enabled");
3291     case SPAPR_RESIZE_HPT_REQUIRED:
3292         return g_strdup("required");
3293     }
3294     g_assert_not_reached();
3295 }
3296
3297 static void spapr_set_resize_hpt(Object *obj, const char *value, Error **errp)
3298 {
3299     SpaprMachineState *spapr = SPAPR_MACHINE(obj);
3300
3301     if (strcmp(value, "default") == 0) {
3302         spapr->resize_hpt = SPAPR_RESIZE_HPT_DEFAULT;
3303     } else if (strcmp(value, "disabled") == 0) {
3304         spapr->resize_hpt = SPAPR_RESIZE_HPT_DISABLED;
3305     } else if (strcmp(value, "enabled") == 0) {
3306         spapr->resize_hpt = SPAPR_RESIZE_HPT_ENABLED;
3307     } else if (strcmp(value, "required") == 0) {
3308         spapr->resize_hpt = SPAPR_RESIZE_HPT_REQUIRED;
3309     } else {
3310         error_setg(errp, "Bad value for \"resize-hpt\" property");
3311     }
3312 }
3313
3314 static void spapr_get_vsmt(Object *obj, Visitor *v, const char *name,
3315                                    void *opaque, Error **errp)
3316 {
3317     visit_type_uint32(v, name, (uint32_t *)opaque, errp);
3318 }
3319
3320 static void spapr_set_vsmt(Object *obj, Visitor *v, const char *name,
3321                                    void *opaque, Error **errp)
3322 {
3323     visit_type_uint32(v, name, (uint32_t *)opaque, errp);
3324 }
3325
3326 static char *spapr_get_ic_mode(Object *obj, Error **errp)
3327 {
3328     SpaprMachineState *spapr = SPAPR_MACHINE(obj);
3329
3330     if (spapr->irq == &spapr_irq_xics_legacy) {
3331         return g_strdup("legacy");
3332     } else if (spapr->irq == &spapr_irq_xics) {
3333         return g_strdup("xics");
3334     } else if (spapr->irq == &spapr_irq_xive) {
3335         return g_strdup("xive");
3336     } else if (spapr->irq == &spapr_irq_dual) {
3337         return g_strdup("dual");
3338     }
3339     g_assert_not_reached();
3340 }
3341
3342 static void spapr_set_ic_mode(Object *obj, const char *value, Error **errp)
3343 {
3344     SpaprMachineState *spapr = SPAPR_MACHINE(obj);
3345
3346     if (SPAPR_MACHINE_GET_CLASS(spapr)->legacy_irq_allocation) {
3347         error_setg(errp, "This machine only uses the legacy XICS backend, don't pass ic-mode");
3348         return;
3349     }
3350
3351     /* The legacy IRQ backend can not be set */
3352     if (strcmp(value, "xics") == 0) {
3353         spapr->irq = &spapr_irq_xics;
3354     } else if (strcmp(value, "xive") == 0) {
3355         spapr->irq = &spapr_irq_xive;
3356     } else if (strcmp(value, "dual") == 0) {
3357         spapr->irq = &spapr_irq_dual;
3358     } else {
3359         error_setg(errp, "Bad value for \"ic-mode\" property");
3360     }
3361 }
3362
3363 static char *spapr_get_host_model(Object *obj, Error **errp)
3364 {
3365     SpaprMachineState *spapr = SPAPR_MACHINE(obj);
3366
3367     return g_strdup(spapr->host_model);
3368 }
3369
3370 static void spapr_set_host_model(Object *obj, const char *value, Error **errp)
3371 {
3372     SpaprMachineState *spapr = SPAPR_MACHINE(obj);
3373
3374     g_free(spapr->host_model);
3375     spapr->host_model = g_strdup(value);
3376 }
3377
3378 static char *spapr_get_host_serial(Object *obj, Error **errp)
3379 {
3380     SpaprMachineState *spapr = SPAPR_MACHINE(obj);
3381
3382     return g_strdup(spapr->host_serial);
3383 }
3384
3385 static void spapr_set_host_serial(Object *obj, const char *value, Error **errp)
3386 {
3387     SpaprMachineState *spapr = SPAPR_MACHINE(obj);
3388
3389     g_free(spapr->host_serial);
3390     spapr->host_serial = g_strdup(value);
3391 }
3392
3393 static void spapr_instance_init(Object *obj)
3394 {
3395     SpaprMachineState *spapr = SPAPR_MACHINE(obj);
3396     SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
3397
3398     spapr->htab_fd = -1;
3399     spapr->use_hotplug_event_source = true;
3400     object_property_add_str(obj, "kvm-type",
3401                             spapr_get_kvm_type, spapr_set_kvm_type, NULL);
3402     object_property_set_description(obj, "kvm-type",
3403                                     "Specifies the KVM virtualization mode (HV, PR)",
3404                                     NULL);
3405     object_property_add_bool(obj, "modern-hotplug-events",
3406                             spapr_get_modern_hotplug_events,
3407                             spapr_set_modern_hotplug_events,
3408                             NULL);
3409     object_property_set_description(obj, "modern-hotplug-events",
3410                                     "Use dedicated hotplug event mechanism in"
3411                                     " place of standard EPOW events when possible"
3412                                     " (required for memory hot-unplug support)",
3413                                     NULL);
3414     ppc_compat_add_property(obj, "max-cpu-compat", &spapr->max_compat_pvr,
3415                             "Maximum permitted CPU compatibility mode",
3416                             &error_fatal);
3417
3418     object_property_add_str(obj, "resize-hpt",
3419                             spapr_get_resize_hpt, spapr_set_resize_hpt, NULL);
3420     object_property_set_description(obj, "resize-hpt",
3421                                     "Resizing of the Hash Page Table (enabled, disabled, required)",
3422                                     NULL);
3423     object_property_add(obj, "vsmt", "uint32", spapr_get_vsmt,
3424                         spapr_set_vsmt, NULL, &spapr->vsmt, &error_abort);
3425     object_property_set_description(obj, "vsmt",
3426                                     "Virtual SMT: KVM behaves as if this were"
3427                                     " the host's SMT mode", &error_abort);
3428     object_property_add_bool(obj, "vfio-no-msix-emulation",
3429                              spapr_get_msix_emulation, NULL, NULL);
3430
3431     /* The machine class defines the default interrupt controller mode */
3432     spapr->irq = smc->irq;
3433     object_property_add_str(obj, "ic-mode", spapr_get_ic_mode,
3434                             spapr_set_ic_mode, NULL);
3435     object_property_set_description(obj, "ic-mode",
3436                  "Specifies the interrupt controller mode (xics, xive, dual)",
3437                  NULL);
3438
3439     object_property_add_str(obj, "host-model",
3440         spapr_get_host_model, spapr_set_host_model,
3441         &error_abort);
3442     object_property_set_description(obj, "host-model",
3443         "Host model to advertise in guest device tree", &error_abort);
3444     object_property_add_str(obj, "host-serial",
3445         spapr_get_host_serial, spapr_set_host_serial,
3446         &error_abort);
3447     object_property_set_description(obj, "host-serial",
3448         "Host serial number to advertise in guest device tree", &error_abort);
3449 }
3450
3451 static void spapr_machine_finalizefn(Object *obj)
3452 {
3453     SpaprMachineState *spapr = SPAPR_MACHINE(obj);
3454
3455     g_free(spapr->kvm_type);
3456 }
3457
3458 void spapr_do_system_reset_on_cpu(CPUState *cs, run_on_cpu_data arg)
3459 {
3460     cpu_synchronize_state(cs);
3461     ppc_cpu_do_system_reset(cs);
3462 }
3463
3464 static void spapr_nmi(NMIState *n, int cpu_index, Error **errp)
3465 {
3466     CPUState *cs;
3467
3468     CPU_FOREACH(cs) {
3469         async_run_on_cpu(cs, spapr_do_system_reset_on_cpu, RUN_ON_CPU_NULL);
3470     }
3471 }
3472
3473 int spapr_lmb_dt_populate(SpaprDrc *drc, SpaprMachineState *spapr,
3474                           void *fdt, int *fdt_start_offset, Error **errp)
3475 {
3476     uint64_t addr;
3477     uint32_t node;
3478
3479     addr = spapr_drc_index(drc) * SPAPR_MEMORY_BLOCK_SIZE;
3480     node = object_property_get_uint(OBJECT(drc->dev), PC_DIMM_NODE_PROP,
3481                                     &error_abort);
3482     *fdt_start_offset = spapr_populate_memory_node(fdt, node, addr,
3483                                                    SPAPR_MEMORY_BLOCK_SIZE);
3484     return 0;
3485 }
3486
3487 static void spapr_add_lmbs(DeviceState *dev, uint64_t addr_start, uint64_t size,
3488                            bool dedicated_hp_event_source, Error **errp)
3489 {
3490     SpaprDrc *drc;
3491     uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE;
3492     int i;
3493     uint64_t addr = addr_start;
3494     bool hotplugged = spapr_drc_hotplugged(dev);
3495     Error *local_err = NULL;
3496
3497     for (i = 0; i < nr_lmbs; i++) {
3498         drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB,
3499                               addr / SPAPR_MEMORY_BLOCK_SIZE);
3500         g_assert(drc);
3501
3502         spapr_drc_attach(drc, dev, &local_err);
3503         if (local_err) {
3504             while (addr > addr_start) {
3505                 addr -= SPAPR_MEMORY_BLOCK_SIZE;
3506                 drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB,
3507                                       addr / SPAPR_MEMORY_BLOCK_SIZE);
3508                 spapr_drc_detach(drc);
3509             }
3510             error_propagate(errp, local_err);
3511             return;
3512         }
3513         if (!hotplugged) {
3514             spapr_drc_reset(drc);
3515         }
3516         addr += SPAPR_MEMORY_BLOCK_SIZE;
3517     }
3518     /* send hotplug notification to the
3519      * guest only in case of hotplugged memory
3520      */
3521     if (hotplugged) {
3522         if (dedicated_hp_event_source) {
3523             drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB,
3524                                   addr_start / SPAPR_MEMORY_BLOCK_SIZE);
3525             spapr_hotplug_req_add_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB,
3526                                                    nr_lmbs,
3527                                                    spapr_drc_index(drc));
3528         } else {
3529             spapr_hotplug_req_add_by_count(SPAPR_DR_CONNECTOR_TYPE_LMB,
3530                                            nr_lmbs);
3531         }
3532     }
3533 }
3534
3535 static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev,
3536                               Error **errp)
3537 {
3538     Error *local_err = NULL;
3539     SpaprMachineState *ms = SPAPR_MACHINE(hotplug_dev);
3540     PCDIMMDevice *dimm = PC_DIMM(dev);
3541     uint64_t size, addr;
3542
3543     size = memory_device_get_region_size(MEMORY_DEVICE(dev), &error_abort);
3544
3545     pc_dimm_plug(dimm, MACHINE(ms), &local_err);
3546     if (local_err) {
3547         goto out;
3548     }
3549
3550     addr = object_property_get_uint(OBJECT(dimm),
3551                                     PC_DIMM_ADDR_PROP, &local_err);
3552     if (local_err) {
3553         goto out_unplug;
3554     }
3555
3556     spapr_add_lmbs(dev, addr, size, spapr_ovec_test(ms->ov5_cas, OV5_HP_EVT),
3557                    &local_err);
3558     if (local_err) {
3559         goto out_unplug;
3560     }
3561
3562     return;
3563
3564 out_unplug:
3565     pc_dimm_unplug(dimm, MACHINE(ms));
3566 out:
3567     error_propagate(errp, local_err);
3568 }
3569
3570 static void spapr_memory_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev,
3571                                   Error **errp)
3572 {
3573     const SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(hotplug_dev);
3574     SpaprMachineState *spapr = SPAPR_MACHINE(hotplug_dev);
3575     PCDIMMDevice *dimm = PC_DIMM(dev);
3576     Error *local_err = NULL;
3577     uint64_t size;
3578     Object *memdev;
3579     hwaddr pagesize;
3580
3581     if (!smc->dr_lmb_enabled) {
3582         error_setg(errp, "Memory hotplug not supported for this machine");
3583         return;
3584     }
3585
3586     size = memory_device_get_region_size(MEMORY_DEVICE(dimm), &local_err);
3587     if (local_err) {
3588         error_propagate(errp, local_err);
3589         return;
3590     }
3591
3592     if (size % SPAPR_MEMORY_BLOCK_SIZE) {
3593         error_setg(errp, "Hotplugged memory size must be a multiple of "
3594                       "%" PRIu64 " MB", SPAPR_MEMORY_BLOCK_SIZE / MiB);
3595         return;
3596     }
3597
3598     memdev = object_property_get_link(OBJECT(dimm), PC_DIMM_MEMDEV_PROP,
3599                                       &error_abort);
3600     pagesize = host_memory_backend_pagesize(MEMORY_BACKEND(memdev));
3601     spapr_check_pagesize(spapr, pagesize, &local_err);
3602     if (local_err) {
3603         error_propagate(errp, local_err);
3604         return;
3605     }
3606
3607     pc_dimm_pre_plug(dimm, MACHINE(hotplug_dev), NULL, errp);
3608 }
3609
3610 struct SpaprDimmState {
3611     PCDIMMDevice *dimm;
3612     uint32_t nr_lmbs;
3613     QTAILQ_ENTRY(SpaprDimmState) next;
3614 };
3615
3616 static SpaprDimmState *spapr_pending_dimm_unplugs_find(SpaprMachineState *s,
3617                                                        PCDIMMDevice *dimm)
3618 {
3619     SpaprDimmState *dimm_state = NULL;
3620
3621     QTAILQ_FOREACH(dimm_state, &s->pending_dimm_unplugs, next) {
3622         if (dimm_state->dimm == dimm) {
3623             break;
3624         }
3625     }
3626     return dimm_state;
3627 }
3628
3629 static SpaprDimmState *spapr_pending_dimm_unplugs_add(SpaprMachineState *spapr,
3630                                                       uint32_t nr_lmbs,
3631                                                       PCDIMMDevice *dimm)
3632 {
3633     SpaprDimmState *ds = NULL;
3634
3635     /*
3636      * If this request is for a DIMM whose removal had failed earlier
3637      * (due to guest's refusal to remove the LMBs), we would have this
3638      * dimm already in the pending_dimm_unplugs list. In that
3639      * case don't add again.
3640      */
3641     ds = spapr_pending_dimm_unplugs_find(spapr, dimm);
3642     if (!ds) {
3643         ds = g_malloc0(sizeof(SpaprDimmState));
3644         ds->nr_lmbs = nr_lmbs;
3645         ds->dimm = dimm;
3646         QTAILQ_INSERT_HEAD(&spapr->pending_dimm_unplugs, ds, next);
3647     }
3648     return ds;
3649 }
3650
3651 static void spapr_pending_dimm_unplugs_remove(SpaprMachineState *spapr,
3652                                               SpaprDimmState *dimm_state)
3653 {
3654     QTAILQ_REMOVE(&spapr->pending_dimm_unplugs, dimm_state, next);
3655     g_free(dimm_state);
3656 }
3657
3658 static SpaprDimmState *spapr_recover_pending_dimm_state(SpaprMachineState *ms,
3659                                                         PCDIMMDevice *dimm)
3660 {
3661     SpaprDrc *drc;
3662     uint64_t size = memory_device_get_region_size(MEMORY_DEVICE(dimm),
3663                                                   &error_abort);
3664     uint32_t nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE;
3665     uint32_t avail_lmbs = 0;
3666     uint64_t addr_start, addr;
3667     int i;
3668
3669     addr_start = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP,
3670                                          &error_abort);
3671
3672     addr = addr_start;
3673     for (i = 0; i < nr_lmbs; i++) {
3674         drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB,
3675                               addr / SPAPR_MEMORY_BLOCK_SIZE);
3676         g_assert(drc);
3677         if (drc->dev) {
3678             avail_lmbs++;
3679         }
3680         addr += SPAPR_MEMORY_BLOCK_SIZE;
3681     }
3682
3683     return spapr_pending_dimm_unplugs_add(ms, avail_lmbs, dimm);
3684 }
3685
3686 /* Callback to be called during DRC release. */
3687 void spapr_lmb_release(DeviceState *dev)
3688 {
3689     HotplugHandler *hotplug_ctrl = qdev_get_hotplug_handler(dev);
3690     SpaprMachineState *spapr = SPAPR_MACHINE(hotplug_ctrl);
3691     SpaprDimmState *ds = spapr_pending_dimm_unplugs_find(spapr, PC_DIMM(dev));
3692
3693     /* This information will get lost if a migration occurs
3694      * during the unplug process. In this case recover it. */
3695     if (ds == NULL) {
3696         ds = spapr_recover_pending_dimm_state(spapr, PC_DIMM(dev));
3697         g_assert(ds);
3698         /* The DRC being examined by the caller at least must be counted */
3699         g_assert(ds->nr_lmbs);
3700     }
3701
3702     if (--ds->nr_lmbs) {
3703         return;
3704     }
3705
3706     /*
3707      * Now that all the LMBs have been removed by the guest, call the
3708      * unplug handler chain. This can never fail.
3709      */
3710     hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort);
3711     object_unparent(OBJECT(dev));
3712 }
3713
3714 static void spapr_memory_unplug(HotplugHandler *hotplug_dev, DeviceState *dev)
3715 {
3716     SpaprMachineState *spapr = SPAPR_MACHINE(hotplug_dev);
3717     SpaprDimmState *ds = spapr_pending_dimm_unplugs_find(spapr, PC_DIMM(dev));
3718
3719     pc_dimm_unplug(PC_DIMM(dev), MACHINE(hotplug_dev));
3720     object_property_set_bool(OBJECT(dev), false, "realized", NULL);
3721     spapr_pending_dimm_unplugs_remove(spapr, ds);
3722 }
3723
3724 static void spapr_memory_unplug_request(HotplugHandler *hotplug_dev,
3725                                         DeviceState *dev, Error **errp)
3726 {
3727     SpaprMachineState *spapr = SPAPR_MACHINE(hotplug_dev);
3728     Error *local_err = NULL;
3729     PCDIMMDevice *dimm = PC_DIMM(dev);
3730     uint32_t nr_lmbs;
3731     uint64_t size, addr_start, addr;
3732     int i;
3733     SpaprDrc *drc;
3734
3735     size = memory_device_get_region_size(MEMORY_DEVICE(dimm), &error_abort);
3736     nr_lmbs = size / SPAPR_MEMORY_BLOCK_SIZE;
3737
3738     addr_start = object_property_get_uint(OBJECT(dimm), PC_DIMM_ADDR_PROP,
3739                                          &local_err);
3740     if (local_err) {
3741         goto out;
3742     }
3743
3744     /*
3745      * An existing pending dimm state for this DIMM means that there is an
3746      * unplug operation in progress, waiting for the spapr_lmb_release
3747      * callback to complete the job (BQL can't cover that far). In this case,
3748      * bail out to avoid detaching DRCs that were already released.
3749      */
3750     if (spapr_pending_dimm_unplugs_find(spapr, dimm)) {
3751         error_setg(&local_err,
3752                    "Memory unplug already in progress for device %s",
3753                    dev->id);
3754         goto out;
3755     }
3756
3757     spapr_pending_dimm_unplugs_add(spapr, nr_lmbs, dimm);
3758
3759     addr = addr_start;
3760     for (i = 0; i < nr_lmbs; i++) {
3761         drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB,
3762                               addr / SPAPR_MEMORY_BLOCK_SIZE);
3763         g_assert(drc);
3764
3765         spapr_drc_detach(drc);
3766         addr += SPAPR_MEMORY_BLOCK_SIZE;
3767     }
3768
3769     drc = spapr_drc_by_id(TYPE_SPAPR_DRC_LMB,
3770                           addr_start / SPAPR_MEMORY_BLOCK_SIZE);
3771     spapr_hotplug_req_remove_by_count_indexed(SPAPR_DR_CONNECTOR_TYPE_LMB,
3772                                               nr_lmbs, spapr_drc_index(drc));
3773 out:
3774     error_propagate(errp, local_err);
3775 }
3776
3777 /* Callback to be called during DRC release. */
3778 void spapr_core_release(DeviceState *dev)
3779 {
3780     HotplugHandler *hotplug_ctrl = qdev_get_hotplug_handler(dev);
3781
3782     /* Call the unplug handler chain. This can never fail. */
3783     hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort);
3784     object_unparent(OBJECT(dev));
3785 }
3786
3787 static void spapr_core_unplug(HotplugHandler *hotplug_dev, DeviceState *dev)
3788 {
3789     MachineState *ms = MACHINE(hotplug_dev);
3790     SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(ms);
3791     CPUCore *cc = CPU_CORE(dev);
3792     CPUArchId *core_slot = spapr_find_cpu_slot(ms, cc->core_id, NULL);
3793
3794     if (smc->pre_2_10_has_unused_icps) {
3795         SpaprCpuCore *sc = SPAPR_CPU_CORE(OBJECT(dev));
3796         int i;
3797
3798         for (i = 0; i < cc->nr_threads; i++) {
3799             CPUState *cs = CPU(sc->threads[i]);
3800
3801             pre_2_10_vmstate_register_dummy_icp(cs->cpu_index);
3802         }
3803     }
3804
3805     assert(core_slot);
3806     core_slot->cpu = NULL;
3807     object_property_set_bool(OBJECT(dev), false, "realized", NULL);
3808 }
3809
3810 static
3811 void spapr_core_unplug_request(HotplugHandler *hotplug_dev, DeviceState *dev,
3812                                Error **errp)
3813 {
3814     SpaprMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev));
3815     int index;
3816     SpaprDrc *drc;
3817     CPUCore *cc = CPU_CORE(dev);
3818
3819     if (!spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index)) {
3820         error_setg(errp, "Unable to find CPU core with core-id: %d",
3821                    cc->core_id);
3822         return;
3823     }
3824     if (index == 0) {
3825         error_setg(errp, "Boot CPU core may not be unplugged");
3826         return;
3827     }
3828
3829     drc = spapr_drc_by_id(TYPE_SPAPR_DRC_CPU,
3830                           spapr_vcpu_id(spapr, cc->core_id));
3831     g_assert(drc);
3832
3833     spapr_drc_detach(drc);
3834
3835     spapr_hotplug_req_remove_by_index(drc);
3836 }
3837
3838 int spapr_core_dt_populate(SpaprDrc *drc, SpaprMachineState *spapr,
3839                            void *fdt, int *fdt_start_offset, Error **errp)
3840 {
3841     SpaprCpuCore *core = SPAPR_CPU_CORE(drc->dev);
3842     CPUState *cs = CPU(core->threads[0]);
3843     PowerPCCPU *cpu = POWERPC_CPU(cs);
3844     DeviceClass *dc = DEVICE_GET_CLASS(cs);
3845     int id = spapr_get_vcpu_id(cpu);
3846     char *nodename;
3847     int offset;
3848
3849     nodename = g_strdup_printf("%s@%x", dc->fw_name, id);
3850     offset = fdt_add_subnode(fdt, 0, nodename);
3851     g_free(nodename);
3852
3853     spapr_populate_cpu_dt(cs, fdt, offset, spapr);
3854
3855     *fdt_start_offset = offset;
3856     return 0;
3857 }
3858
3859 static void spapr_core_plug(HotplugHandler *hotplug_dev, DeviceState *dev,
3860                             Error **errp)
3861 {
3862     SpaprMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev));
3863     MachineClass *mc = MACHINE_GET_CLASS(spapr);
3864     SpaprMachineClass *smc = SPAPR_MACHINE_CLASS(mc);
3865     SpaprCpuCore *core = SPAPR_CPU_CORE(OBJECT(dev));
3866     CPUCore *cc = CPU_CORE(dev);
3867     CPUState *cs;
3868     SpaprDrc *drc;
3869     Error *local_err = NULL;
3870     CPUArchId *core_slot;
3871     int index;
3872     bool hotplugged = spapr_drc_hotplugged(dev);
3873     int i;
3874
3875     core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index);
3876     if (!core_slot) {
3877         error_setg(errp, "Unable to find CPU core with core-id: %d",
3878                    cc->core_id);
3879         return;
3880     }
3881     drc = spapr_drc_by_id(TYPE_SPAPR_DRC_CPU,
3882                           spapr_vcpu_id(spapr, cc->core_id));
3883
3884     g_assert(drc || !mc->has_hotpluggable_cpus);
3885
3886     if (drc) {
3887         spapr_drc_attach(drc, dev, &local_err);
3888         if (local_err) {
3889             error_propagate(errp, local_err);
3890             return;
3891         }
3892
3893         if (hotplugged) {
3894             /*
3895              * Send hotplug notification interrupt to the guest only
3896              * in case of hotplugged CPUs.
3897              */
3898             spapr_hotplug_req_add_by_index(drc);
3899         } else {
3900             spapr_drc_reset(drc);
3901         }
3902     }
3903
3904     core_slot->cpu = OBJECT(dev);
3905
3906     if (smc->pre_2_10_has_unused_icps) {
3907         for (i = 0; i < cc->nr_threads; i++) {
3908             cs = CPU(core->threads[i]);
3909             pre_2_10_vmstate_unregister_dummy_icp(cs->cpu_index);
3910         }
3911     }
3912
3913     /*
3914      * Set compatibility mode to match the boot CPU, which was either set
3915      * by the machine reset code or by CAS.
3916      */
3917     if (hotplugged) {
3918         for (i = 0; i < cc->nr_threads; i++) {
3919             ppc_set_compat(core->threads[i], POWERPC_CPU(first_cpu)->compat_pvr,
3920                            &local_err);
3921             if (local_err) {
3922                 error_propagate(errp, local_err);
3923                 return;
3924             }
3925         }
3926     }
3927 }
3928
3929 static void spapr_core_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev,
3930                                 Error **errp)
3931 {
3932     MachineState *machine = MACHINE(OBJECT(hotplug_dev));
3933     MachineClass *mc = MACHINE_GET_CLASS(hotplug_dev);
3934     Error *local_err = NULL;
3935     CPUCore *cc = CPU_CORE(dev);
3936     const char *base_core_type = spapr_get_cpu_core_type(machine->cpu_type);
3937     const char *type = object_get_typename(OBJECT(dev));
3938     CPUArchId *core_slot;
3939     int index;
3940     unsigned int smp_threads = machine->smp.threads;
3941
3942     if (dev->hotplugged && !mc->has_hotpluggable_cpus) {
3943         error_setg(&local_err, "CPU hotplug not supported for this machine");
3944         goto out;
3945     }
3946
3947     if (strcmp(base_core_type, type)) {
3948         error_setg(&local_err, "CPU core type should be %s", base_core_type);
3949         goto out;
3950     }
3951
3952     if (cc->core_id % smp_threads) {
3953         error_setg(&local_err, "invalid core id %d", cc->core_id);
3954         goto out;
3955     }
3956
3957     /*
3958      * In general we should have homogeneous threads-per-core, but old
3959      * (pre hotplug support) machine types allow the last core to have
3960      * reduced threads as a compatibility hack for when we allowed
3961      * total vcpus not a multiple of threads-per-core.
3962      */
3963     if (mc->has_hotpluggable_cpus && (cc->nr_threads != smp_threads)) {
3964         error_setg(&local_err, "invalid nr-threads %d, must be %d",
3965                    cc->nr_threads, smp_threads);
3966         goto out;
3967     }
3968
3969     core_slot = spapr_find_cpu_slot(MACHINE(hotplug_dev), cc->core_id, &index);
3970     if (!core_slot) {
3971         error_setg(&local_err, "core id %d out of range", cc->core_id);
3972         goto out;
3973     }
3974
3975     if (core_slot->cpu) {
3976         error_setg(&local_err, "core %d already populated", cc->core_id);
3977         goto out;
3978     }
3979
3980     numa_cpu_pre_plug(core_slot, dev, &local_err);
3981
3982 out:
3983     error_propagate(errp, local_err);
3984 }
3985
3986 int spapr_phb_dt_populate(SpaprDrc *drc, SpaprMachineState *spapr,
3987                           void *fdt, int *fdt_start_offset, Error **errp)
3988 {
3989     SpaprPhbState *sphb = SPAPR_PCI_HOST_BRIDGE(drc->dev);
3990     int intc_phandle;
3991
3992     intc_phandle = spapr_irq_get_phandle(spapr, spapr->fdt_blob, errp);
3993     if (intc_phandle <= 0) {
3994         return -1;
3995     }
3996
3997     if (spapr_dt_phb(sphb, intc_phandle, fdt, spapr->irq->nr_msis,
3998                      fdt_start_offset)) {
3999         error_setg(errp, "unable to create FDT node for PHB %d", sphb->index);
4000         return -1;
4001     }
4002
4003     /* generally SLOF creates these, for hotplug it's up to QEMU */
4004     _FDT(fdt_setprop_string(fdt, *fdt_start_offset, "name", "pci"));
4005
4006     return 0;
4007 }
4008
4009 static void spapr_phb_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev,
4010                                Error **errp)
4011 {
4012     SpaprMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev));
4013     SpaprPhbState *sphb = SPAPR_PCI_HOST_BRIDGE(dev);
4014     SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
4015     const unsigned windows_supported = spapr_phb_windows_supported(sphb);
4016
4017     if (dev->hotplugged && !smc->dr_phb_enabled) {
4018         error_setg(errp, "PHB hotplug not supported for this machine");
4019         return;
4020     }
4021
4022     if (sphb->index == (uint32_t)-1) {
4023         error_setg(errp, "\"index\" for PAPR PHB is mandatory");
4024         return;
4025     }
4026
4027     /*
4028      * This will check that sphb->index doesn't exceed the maximum number of
4029      * PHBs for the current machine type.
4030      */
4031     smc->phb_placement(spapr, sphb->index,
4032                        &sphb->buid, &sphb->io_win_addr,
4033                        &sphb->mem_win_addr, &sphb->mem64_win_addr,
4034                        windows_supported, sphb->dma_liobn,
4035                        &sphb->nv2_gpa_win_addr, &sphb->nv2_atsd_win_addr,
4036                        errp);
4037 }
4038
4039 static void spapr_phb_plug(HotplugHandler *hotplug_dev, DeviceState *dev,
4040                            Error **errp)
4041 {
4042     SpaprMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev));
4043     SpaprMachineClass *smc = SPAPR_MACHINE_GET_CLASS(spapr);
4044     SpaprPhbState *sphb = SPAPR_PCI_HOST_BRIDGE(dev);
4045     SpaprDrc *drc;
4046     bool hotplugged = spapr_drc_hotplugged(dev);
4047     Error *local_err = NULL;
4048
4049     if (!smc->dr_phb_enabled) {
4050         return;
4051     }
4052
4053     drc = spapr_drc_by_id(TYPE_SPAPR_DRC_PHB, sphb->index);
4054     /* hotplug hooks should check it's enabled before getting this far */
4055     assert(drc);
4056
4057     spapr_drc_attach(drc, DEVICE(dev), &local_err);
4058     if (local_err) {
4059         error_propagate(errp, local_err);
4060         return;
4061     }
4062
4063     if (hotplugged) {
4064         spapr_hotplug_req_add_by_index(drc);
4065     } else {
4066         spapr_drc_reset(drc);
4067     }
4068 }
4069
4070 void spapr_phb_release(DeviceState *dev)
4071 {
4072     HotplugHandler *hotplug_ctrl = qdev_get_hotplug_handler(dev);
4073
4074     hotplug_handler_unplug(hotplug_ctrl, dev, &error_abort);
4075     object_unparent(OBJECT(dev));
4076 }
4077
4078 static void spapr_phb_unplug(HotplugHandler *hotplug_dev, DeviceState *dev)
4079 {
4080     object_property_set_bool(OBJECT(dev), false, "realized", NULL);
4081 }
4082
4083 static void spapr_phb_unplug_request(HotplugHandler *hotplug_dev,
4084                                      DeviceState *dev, Error **errp)
4085 {
4086     SpaprPhbState *sphb = SPAPR_PCI_HOST_BRIDGE(dev);
4087     SpaprDrc *drc;
4088
4089     drc = spapr_drc_by_id(TYPE_SPAPR_DRC_PHB, sphb->index);
4090     assert(drc);
4091
4092     if (!spapr_drc_unplug_requested(drc)) {
4093         spapr_drc_detach(drc);
4094         spapr_hotplug_req_remove_by_index(drc);
4095     }
4096 }
4097
4098 static void spapr_tpm_proxy_plug(HotplugHandler *hotplug_dev, DeviceState *dev,
4099                                  Error **errp)
4100 {
4101     SpaprMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev));
4102     SpaprTpmProxy *tpm_proxy = SPAPR_TPM_PROXY(dev);
4103
4104     if (spapr->tpm_proxy != NULL) {
4105         error_setg(errp, "Only one TPM proxy can be specified for this machine");
4106         return;
4107     }
4108
4109     spapr->tpm_proxy = tpm_proxy;
4110 }
4111
4112 static void spapr_tpm_proxy_unplug(HotplugHandler *hotplug_dev, DeviceState *dev)
4113 {
4114     SpaprMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev));
4115
4116     object_property_set_bool(OBJECT(dev), false, "realized", NULL);
4117     object_unparent(OBJECT(dev));
4118     spapr->tpm_proxy = NULL;
4119 }
4120
4121 static void spapr_machine_device_plug(HotplugHandler *hotplug_dev,
4122                                       DeviceState *dev, Error **errp)
4123 {
4124     if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) {
4125         spapr_memory_plug(hotplug_dev, dev, errp);
4126     } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) {
4127         spapr_core_plug(hotplug_dev, dev, errp);
4128     } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_PCI_HOST_BRIDGE)) {
4129         spapr_phb_plug(hotplug_dev, dev, errp);
4130     } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_TPM_PROXY)) {
4131         spapr_tpm_proxy_plug(hotplug_dev, dev, errp);
4132     }
4133 }
4134
4135 static void spapr_machine_device_unplug(HotplugHandler *hotplug_dev,
4136                                         DeviceState *dev, Error **errp)
4137 {
4138     if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) {
4139         spapr_memory_unplug(hotplug_dev, dev);
4140     } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) {
4141         spapr_core_unplug(hotplug_dev, dev);
4142     } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_PCI_HOST_BRIDGE)) {
4143         spapr_phb_unplug(hotplug_dev, dev);
4144     } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_TPM_PROXY)) {
4145         spapr_tpm_proxy_unplug(hotplug_dev, dev);
4146     }
4147 }
4148
4149 static void spapr_machine_device_unplug_request(HotplugHandler *hotplug_dev,
4150                                                 DeviceState *dev, Error **errp)
4151 {
4152     SpaprMachineState *sms = SPAPR_MACHINE(OBJECT(hotplug_dev));
4153     MachineClass *mc = MACHINE_GET_CLASS(sms);
4154     SpaprMachineClass *smc = SPAPR_MACHINE_CLASS(mc);
4155
4156     if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) {
4157         if (spapr_ovec_test(sms->ov5_cas, OV5_HP_EVT)) {
4158             spapr_memory_unplug_request(hotplug_dev, dev, errp);
4159         } else {
4160             /* NOTE: this means there is a window after guest reset, prior to
4161              * CAS negotiation, where unplug requests will fail due to the
4162              * capability not being detected yet. This is a bit different than
4163              * the case with PCI unplug, where the events will be queued and
4164              * eventually handled by the guest after boot
4165              */
4166             error_setg(errp, "Memory hot unplug not supported for this guest");
4167         }
4168     } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) {
4169         if (!mc->has_hotpluggable_cpus) {
4170             error_setg(errp, "CPU hot unplug not supported on this machine");
4171             return;
4172         }
4173         spapr_core_unplug_request(hotplug_dev, dev, errp);
4174     } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_PCI_HOST_BRIDGE)) {
4175         if (!smc->dr_phb_enabled) {
4176             error_setg(errp, "PHB hot unplug not supported on this machine");
4177             return;
4178         }
4179         spapr_phb_unplug_request(hotplug_dev, dev, errp);
4180     } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_TPM_PROXY)) {
4181         spapr_tpm_proxy_unplug(hotplug_dev, dev);
4182     }
4183 }
4184
4185 static void spapr_machine_device_pre_plug(HotplugHandler *hotplug_dev,
4186                                           DeviceState *dev, Error **errp)
4187 {
4188     if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) {
4189         spapr_memory_pre_plug(hotplug_dev, dev, errp);
4190     } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) {
4191         spapr_core_pre_plug(hotplug_dev, dev, errp);
4192     } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_PCI_HOST_BRIDGE)) {
4193         spapr_phb_pre_plug(hotplug_dev, dev, errp);
4194     }
4195 }
4196
4197 static HotplugHandler *spapr_get_hotplug_handler(MachineState *machine,
4198                                                  DeviceState *dev)
4199 {
4200     if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) ||
4201         object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE) ||
4202         object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_PCI_HOST_BRIDGE) ||
4203         object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_TPM_PROXY)) {
4204         return HOTPLUG_HANDLER(machine);
4205     }
4206     if (object_dynamic_cast(OBJECT(dev), TYPE_PCI_DEVICE)) {
4207         PCIDevice *pcidev = PCI_DEVICE(dev);
4208         PCIBus *root = pci_device_root_bus(pcidev);
4209         SpaprPhbState *phb =
4210             (SpaprPhbState *)object_dynamic_cast(OBJECT(BUS(root)->parent),
4211                                                  TYPE_SPAPR_PCI_HOST_BRIDGE);
4212
4213         if (phb) {
4214             return HOTPLUG_HANDLER(phb);
4215         }
4216     }
4217     return NULL;
4218 }
4219
4220 static CpuInstanceProperties
4221 spapr_cpu_index_to_props(MachineState *machine, unsigned cpu_index)
4222 {
4223     CPUArchId *core_slot;
4224     MachineClass *mc = MACHINE_GET_CLASS(machine);
4225
4226     /* make sure possible_cpu are intialized */
4227     mc->possible_cpu_arch_ids(machine);
4228     /* get CPU core slot containing thread that matches cpu_index */
4229     core_slot = spapr_find_cpu_slot(machine, cpu_index, NULL);
4230     assert(core_slot);
4231     return core_slot->props;
4232 }
4233
4234 static int64_t spapr_get_default_cpu_node_id(const MachineState *ms, int idx)
4235 {
4236     return idx / ms->smp.cores % ms->numa_state->num_nodes;
4237 }
4238
4239 static const CPUArchIdList *spapr_possible_cpu_arch_ids(MachineState *machine)
4240 {
4241     int i;
4242     unsigned int smp_threads = machine->smp.threads;
4243     unsigned int smp_cpus = machine->smp.cpus;
4244     const char *core_type;
4245     int spapr_max_cores = machine->smp.max_cpus / smp_threads;
4246     MachineClass *mc = MACHINE_GET_CLASS(machine);
4247
4248     if (!mc->has_hotpluggable_cpus) {
4249         spapr_max_cores = QEMU_ALIGN_UP(smp_cpus, smp_threads) / smp_threads;
4250     }
4251     if (machine->possible_cpus) {
4252         assert(machine->possible_cpus->len == spapr_max_cores);
4253         return machine->possible_cpus;
4254     }
4255
4256     core_type = spapr_get_cpu_core_type(machine->cpu_type);
4257     if (!core_type) {
4258         error_report("Unable to find sPAPR CPU Core definition");
4259         exit(1);
4260     }
4261
4262     machine->possible_cpus = g_malloc0(sizeof(CPUArchIdList) +
4263                              sizeof(CPUArchId) * spapr_max_cores);
4264     machine->possible_cpus->len = spapr_max_cores;
4265     for (i = 0; i < machine->possible_cpus->len; i++) {
4266         int core_id = i * smp_threads;
4267
4268         machine->possible_cpus->cpus[i].type = core_type;
4269         machine->possible_cpus->cpus[i].vcpus_count = smp_threads;
4270         machine->possible_cpus->cpus[i].arch_id = core_id;
4271         machine->possible_cpus->cpus[i].props.has_core_id = true;
4272         machine->possible_cpus->cpus[i].props.core_id = core_id;
4273     }
4274     return machine->possible_cpus;
4275 }
4276
4277 static void spapr_phb_placement(SpaprMachineState *spapr, uint32_t index,
4278                                 uint64_t *buid, hwaddr *pio,
4279                                 hwaddr *mmio32, hwaddr *mmio64,
4280                                 unsigned n_dma, uint32_t *liobns,
4281                                 hwaddr *nv2gpa, hwaddr *nv2atsd, Error **errp)
4282 {
4283     /*
4284      * New-style PHB window placement.
4285      *
4286      * Goals: Gives large (1TiB), naturally aligned 64-bit MMIO window
4287      * for each PHB, in addition to 2GiB 32-bit MMIO and 64kiB PIO
4288      * windows.
4289      *
4290      * Some guest kernels can't work with MMIO windows above 1<<46
4291      * (64TiB), so we place up to 31 PHBs in the area 32TiB..64TiB
4292      *
4293      * 32TiB..(33TiB+1984kiB) contains the 64kiB PIO windows for each
4294      * PHB stacked together.  (32TiB+2GiB)..(32TiB+64GiB) contains the
4295      * 2GiB 32-bit MMIO windows for each PHB.  Then 33..64TiB has the
4296      * 1TiB 64-bit MMIO windows for each PHB.
4297      */
4298     const uint64_t base_buid = 0x800000020000000ULL;
4299     int i;
4300
4301     /* Sanity check natural alignments */
4302     QEMU_BUILD_BUG_ON((SPAPR_PCI_BASE % SPAPR_PCI_MEM64_WIN_SIZE) != 0);
4303     QEMU_BUILD_BUG_ON((SPAPR_PCI_LIMIT % SPAPR_PCI_MEM64_WIN_SIZE) != 0);
4304     QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM64_WIN_SIZE % SPAPR_PCI_MEM32_WIN_SIZE) != 0);
4305     QEMU_BUILD_BUG_ON((SPAPR_PCI_MEM32_WIN_SIZE % SPAPR_PCI_IO_WIN_SIZE) != 0);
4306     /* Sanity check bounds */
4307     QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_IO_WIN_SIZE) >
4308                       SPAPR_PCI_MEM32_WIN_SIZE);
4309     QEMU_BUILD_BUG_ON((SPAPR_MAX_PHBS * SPAPR_PCI_MEM32_WIN_SIZE) >
4310                       SPAPR_PCI_MEM64_WIN_SIZE);
4311
4312     if (index >= SPAPR_MAX_PHBS) {
4313         error_setg(errp, "\"index\" for PAPR PHB is too large (max %llu)",
4314                    SPAPR_MAX_PHBS - 1);
4315         return;
4316     }
4317
4318     *buid = base_buid + index;
4319     for (i = 0; i < n_dma; ++i) {
4320         liobns[i] = SPAPR_PCI_LIOBN(index, i);
4321     }
4322
4323     *pio = SPAPR_PCI_BASE + index * SPAPR_PCI_IO_WIN_SIZE;
4324     *mmio32 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM32_WIN_SIZE;
4325     *mmio64 = SPAPR_PCI_BASE + (index + 1) * SPAPR_PCI_MEM64_WIN_SIZE;
4326
4327     *nv2gpa = SPAPR_PCI_NV2RAM64_WIN_BASE + index * SPAPR_PCI_NV2RAM64_WIN_SIZE;
4328     *nv2atsd = SPAPR_PCI_NV2ATSD_WIN_BASE + index * SPAPR_PCI_NV2ATSD_WIN_SIZE;
4329 }
4330
4331 static ICSState *spapr_ics_get(XICSFabric *dev, int irq)
4332 {
4333     SpaprMachineState *spapr = SPAPR_MACHINE(dev);
4334
4335     return ics_valid_irq(spapr->ics, irq) ? spapr->ics : NULL;
4336 }
4337
4338 static void spapr_ics_resend(XICSFabric *dev)
4339 {
4340     SpaprMachineState *spapr = SPAPR_MACHINE(dev);
4341
4342     ics_resend(spapr->ics);
4343 }
4344
4345 static ICPState *spapr_icp_get(XICSFabric *xi, int vcpu_id)
4346 {
4347     PowerPCCPU *cpu = spapr_find_cpu(vcpu_id);
4348
4349     return cpu ? spapr_cpu_state(cpu)->icp : NULL;
4350 }
4351
4352 static void spapr_pic_print_info(InterruptStatsProvider *obj,
4353                                  Monitor *mon)
4354 {
4355     SpaprMachineState *spapr = SPAPR_MACHINE(obj);
4356
4357     spapr->irq->print_info(spapr, mon);
4358     monitor_printf(mon, "irqchip: %s\n",
4359                    kvm_irqchip_in_kernel() ? "in-kernel" : "emulated");
4360 }
4361
4362 int spapr_get_vcpu_id(PowerPCCPU *cpu)
4363 {
4364     return cpu->vcpu_id;
4365 }
4366
4367 void spapr_set_vcpu_id(PowerPCCPU *cpu, int cpu_index, Error **errp)
4368 {
4369     SpaprMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
4370     MachineState *ms = MACHINE(spapr);
4371     int vcpu_id;
4372
4373     vcpu_id = spapr_vcpu_id(spapr, cpu_index);
4374
4375     if (kvm_enabled() && !kvm_vcpu_id_is_valid(vcpu_id)) {
4376         error_setg(errp, "Can't create CPU with id %d in KVM", vcpu_id);
4377         error_append_hint(errp, "Adjust the number of cpus to %d "
4378                           "or try to raise the number of threads per core\n",
4379                           vcpu_id * ms->smp.threads / spapr->vsmt);
4380         return;
4381     }
4382
4383     cpu->vcpu_id = vcpu_id;
4384 }
4385
4386 PowerPCCPU *spapr_find_cpu(int vcpu_id)
4387 {
4388     CPUState *cs;
4389
4390     CPU_FOREACH(cs) {
4391         PowerPCCPU *cpu = POWERPC_CPU(cs);
4392
4393         if (spapr_get_vcpu_id(cpu) == vcpu_id) {
4394             return cpu;
4395         }
4396     }
4397
4398     return NULL;
4399 }
4400
4401 static void spapr_cpu_exec_enter(PPCVirtualHypervisor *vhyp, PowerPCCPU *cpu)
4402 {
4403     SpaprCpuState *spapr_cpu = spapr_cpu_state(cpu);
4404
4405     /* These are only called by TCG, KVM maintains dispatch state */
4406
4407     spapr_cpu->prod = false;
4408     if (spapr_cpu->vpa_addr) {
4409         CPUState *cs = CPU(cpu);
4410         uint32_t dispatch;
4411
4412         dispatch = ldl_be_phys(cs->as,
4413                                spapr_cpu->vpa_addr + VPA_DISPATCH_COUNTER);
4414         dispatch++;
4415         if ((dispatch & 1) != 0) {
4416             qemu_log_mask(LOG_GUEST_ERROR,
4417                           "VPA: incorrect dispatch counter value for "
4418                           "dispatched partition %u, correcting.\n", dispatch);
4419             dispatch++;
4420         }
4421         stl_be_phys(cs->as,
4422                     spapr_cpu->vpa_addr + VPA_DISPATCH_COUNTER, dispatch);
4423     }
4424 }
4425
4426 static void spapr_cpu_exec_exit(PPCVirtualHypervisor *vhyp, PowerPCCPU *cpu)
4427 {
4428     SpaprCpuState *spapr_cpu = spapr_cpu_state(cpu);
4429
4430     if (spapr_cpu->vpa_addr) {
4431         CPUState *cs = CPU(cpu);
4432         uint32_t dispatch;
4433
4434         dispatch = ldl_be_phys(cs->as,
4435                                spapr_cpu->vpa_addr + VPA_DISPATCH_COUNTER);
4436         dispatch++;
4437         if ((dispatch & 1) != 1) {
4438             qemu_log_mask(LOG_GUEST_ERROR,
4439                           "VPA: incorrect dispatch counter value for "
4440                           "preempted partition %u, correcting.\n", dispatch);
4441             dispatch++;
4442         }
4443         stl_be_phys(cs->as,
4444                     spapr_cpu->vpa_addr + VPA_DISPATCH_COUNTER, dispatch);
4445     }
4446 }
4447
4448 static void spapr_machine_class_init(ObjectClass *oc, void *data)
4449 {
4450     MachineClass *mc = MACHINE_CLASS(oc);
4451     SpaprMachineClass *smc = SPAPR_MACHINE_CLASS(oc);
4452     FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc);
4453     NMIClass *nc = NMI_CLASS(oc);
4454     HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc);
4455     PPCVirtualHypervisorClass *vhc = PPC_VIRTUAL_HYPERVISOR_CLASS(oc);
4456     XICSFabricClass *xic = XICS_FABRIC_CLASS(oc);
4457     InterruptStatsProviderClass *ispc = INTERRUPT_STATS_PROVIDER_CLASS(oc);
4458
4459     mc->desc = "pSeries Logical Partition (PAPR compliant)";
4460     mc->ignore_boot_device_suffixes = true;
4461
4462     /*
4463      * We set up the default / latest behaviour here.  The class_init
4464      * functions for the specific versioned machine types can override
4465      * these details for backwards compatibility
4466      */
4467     mc->init = spapr_machine_init;
4468     mc->reset = spapr_machine_reset;
4469     mc->block_default_type = IF_SCSI;
4470     mc->max_cpus = 1024;
4471     mc->no_parallel = 1;
4472     mc->default_boot_order = "";
4473     mc->default_ram_size = 512 * MiB;
4474     mc->default_display = "std";
4475     mc->kvm_type = spapr_kvm_type;
4476     machine_class_allow_dynamic_sysbus_dev(mc, TYPE_SPAPR_PCI_HOST_BRIDGE);
4477     mc->pci_allow_0_address = true;
4478     assert(!mc->get_hotplug_handler);
4479     mc->get_hotplug_handler = spapr_get_hotplug_handler;
4480     hc->pre_plug = spapr_machine_device_pre_plug;
4481     hc->plug = spapr_machine_device_plug;
4482     mc->cpu_index_to_instance_props = spapr_cpu_index_to_props;
4483     mc->get_default_cpu_node_id = spapr_get_default_cpu_node_id;
4484     mc->possible_cpu_arch_ids = spapr_possible_cpu_arch_ids;
4485     hc->unplug_request = spapr_machine_device_unplug_request;
4486     hc->unplug = spapr_machine_device_unplug;
4487
4488     smc->dr_lmb_enabled = true;
4489     smc->update_dt_enabled = true;
4490     mc->default_cpu_type = POWERPC_CPU_TYPE_NAME("power9_v2.0");
4491     mc->has_hotpluggable_cpus = true;
4492     smc->resize_hpt_default = SPAPR_RESIZE_HPT_ENABLED;
4493     fwc->get_dev_path = spapr_get_fw_dev_path;
4494     nc->nmi_monitor_handler = spapr_nmi;
4495     smc->phb_placement = spapr_phb_placement;
4496     vhc->hypercall = emulate_spapr_hypercall;
4497     vhc->hpt_mask = spapr_hpt_mask;
4498     vhc->map_hptes = spapr_map_hptes;
4499     vhc->unmap_hptes = spapr_unmap_hptes;
4500     vhc->hpte_set_c = spapr_hpte_set_c;
4501     vhc->hpte_set_r = spapr_hpte_set_r;
4502     vhc->get_pate = spapr_get_pate;
4503     vhc->encode_hpt_for_kvm_pr = spapr_encode_hpt_for_kvm_pr;
4504     vhc->cpu_exec_enter = spapr_cpu_exec_enter;
4505     vhc->cpu_exec_exit = spapr_cpu_exec_exit;
4506     xic->ics_get = spapr_ics_get;
4507     xic->ics_resend = spapr_ics_resend;
4508     xic->icp_get = spapr_icp_get;
4509     ispc->print_info = spapr_pic_print_info;
4510     /* Force NUMA node memory size to be a multiple of
4511      * SPAPR_MEMORY_BLOCK_SIZE (256M) since that's the granularity
4512      * in which LMBs are represented and hot-added
4513      */
4514     mc->numa_mem_align_shift = 28;
4515     mc->numa_mem_supported = true;
4516
4517     smc->default_caps.caps[SPAPR_CAP_HTM] = SPAPR_CAP_OFF;
4518     smc->default_caps.caps[SPAPR_CAP_VSX] = SPAPR_CAP_ON;
4519     smc->default_caps.caps[SPAPR_CAP_DFP] = SPAPR_CAP_ON;
4520     smc->default_caps.caps[SPAPR_CAP_CFPC] = SPAPR_CAP_WORKAROUND;
4521     smc->default_caps.caps[SPAPR_CAP_SBBC] = SPAPR_CAP_WORKAROUND;
4522     smc->default_caps.caps[SPAPR_CAP_IBS] = SPAPR_CAP_WORKAROUND;
4523     smc->default_caps.caps[SPAPR_CAP_HPT_MAXPAGESIZE] = 16; /* 64kiB */
4524     smc->default_caps.caps[SPAPR_CAP_NESTED_KVM_HV] = SPAPR_CAP_OFF;
4525     smc->default_caps.caps[SPAPR_CAP_LARGE_DECREMENTER] = SPAPR_CAP_ON;
4526     smc->default_caps.caps[SPAPR_CAP_CCF_ASSIST] = SPAPR_CAP_OFF;
4527     spapr_caps_add_properties(smc, &error_abort);
4528     smc->irq = &spapr_irq_dual;
4529     smc->dr_phb_enabled = true;
4530     smc->linux_pci_probe = true;
4531 }
4532
4533 static const TypeInfo spapr_machine_info = {
4534     .name          = TYPE_SPAPR_MACHINE,
4535     .parent        = TYPE_MACHINE,
4536     .abstract      = true,
4537     .instance_size = sizeof(SpaprMachineState),
4538     .instance_init = spapr_instance_init,
4539     .instance_finalize = spapr_machine_finalizefn,
4540     .class_size    = sizeof(SpaprMachineClass),
4541     .class_init    = spapr_machine_class_init,
4542     .interfaces = (InterfaceInfo[]) {
4543         { TYPE_FW_PATH_PROVIDER },
4544         { TYPE_NMI },
4545         { TYPE_HOTPLUG_HANDLER },
4546         { TYPE_PPC_VIRTUAL_HYPERVISOR },
4547         { TYPE_XICS_FABRIC },
4548         { TYPE_INTERRUPT_STATS_PROVIDER },
4549         { }
4550     },
4551 };
4552
4553 #define DEFINE_SPAPR_MACHINE(suffix, verstr, latest)                 \
4554     static void spapr_machine_##suffix##_class_init(ObjectClass *oc, \
4555                                                     void *data)      \
4556     {                                                                \
4557         MachineClass *mc = MACHINE_CLASS(oc);                        \
4558         spapr_machine_##suffix##_class_options(mc);                  \
4559         if (latest) {                                                \
4560             mc->alias = "pseries";                                   \
4561             mc->is_default = 1;                                      \
4562         }                                                            \
4563     }                                                                \
4564     static const TypeInfo spapr_machine_##suffix##_info = {          \
4565         .name = MACHINE_TYPE_NAME("pseries-" verstr),                \
4566         .parent = TYPE_SPAPR_MACHINE,                                \
4567         .class_init = spapr_machine_##suffix##_class_init,           \
4568     };                                                               \
4569     static void spapr_machine_register_##suffix(void)                \
4570     {                                                                \
4571         type_register(&spapr_machine_##suffix##_info);               \
4572     }                                                                \
4573     type_init(spapr_machine_register_##suffix)
4574
4575 /*
4576  * pseries-4.2
4577  */
4578 static void spapr_machine_4_2_class_options(MachineClass *mc)
4579 {
4580     /* Defaults for the latest behaviour inherited from the base class */
4581 }
4582
4583 DEFINE_SPAPR_MACHINE(4_2, "4.2", true);
4584
4585 /*
4586  * pseries-4.1
4587  */
4588 static void spapr_machine_4_1_class_options(MachineClass *mc)
4589 {
4590     SpaprMachineClass *smc = SPAPR_MACHINE_CLASS(mc);
4591     static GlobalProperty compat[] = {
4592         /* Only allow 4kiB and 64kiB IOMMU pagesizes */
4593         { TYPE_SPAPR_PCI_HOST_BRIDGE, "pgsz", "0x11000" },
4594     };
4595
4596     spapr_machine_4_2_class_options(mc);
4597     smc->linux_pci_probe = false;
4598     compat_props_add(mc->compat_props, hw_compat_4_1, hw_compat_4_1_len);
4599     compat_props_add(mc->compat_props, compat, G_N_ELEMENTS(compat));
4600 }
4601
4602 DEFINE_SPAPR_MACHINE(4_1, "4.1", false);
4603
4604 /*
4605  * pseries-4.0
4606  */
4607 static void phb_placement_4_0(SpaprMachineState *spapr, uint32_t index,
4608                               uint64_t *buid, hwaddr *pio,
4609                               hwaddr *mmio32, hwaddr *mmio64,
4610                               unsigned n_dma, uint32_t *liobns,
4611                               hwaddr *nv2gpa, hwaddr *nv2atsd, Error **errp)
4612 {
4613     spapr_phb_placement(spapr, index, buid, pio, mmio32, mmio64, n_dma, liobns,
4614                         nv2gpa, nv2atsd, errp);
4615     *nv2gpa = 0;
4616     *nv2atsd = 0;
4617 }
4618
4619 static void spapr_machine_4_0_class_options(MachineClass *mc)
4620 {
4621     SpaprMachineClass *smc = SPAPR_MACHINE_CLASS(mc);
4622
4623     spapr_machine_4_1_class_options(mc);
4624     compat_props_add(mc->compat_props, hw_compat_4_0, hw_compat_4_0_len);
4625     smc->phb_placement = phb_placement_4_0;
4626     smc->irq = &spapr_irq_xics;
4627     smc->pre_4_1_migration = true;
4628 }
4629
4630 DEFINE_SPAPR_MACHINE(4_0, "4.0", false);
4631
4632 /*
4633  * pseries-3.1
4634  */
4635 static void spapr_machine_3_1_class_options(MachineClass *mc)
4636 {
4637     SpaprMachineClass *smc = SPAPR_MACHINE_CLASS(mc);
4638
4639     spapr_machine_4_0_class_options(mc);
4640     compat_props_add(mc->compat_props, hw_compat_3_1, hw_compat_3_1_len);
4641
4642     mc->default_cpu_type = POWERPC_CPU_TYPE_NAME("power8_v2.0");
4643     smc->update_dt_enabled = false;
4644     smc->dr_phb_enabled = false;
4645     smc->broken_host_serial_model = true;
4646     smc->default_caps.caps[SPAPR_CAP_CFPC] = SPAPR_CAP_BROKEN;
4647     smc->default_caps.caps[SPAPR_CAP_SBBC] = SPAPR_CAP_BROKEN;
4648     smc->default_caps.caps[SPAPR_CAP_IBS] = SPAPR_CAP_BROKEN;
4649     smc->default_caps.caps[SPAPR_CAP_LARGE_DECREMENTER] = SPAPR_CAP_OFF;
4650 }
4651
4652 DEFINE_SPAPR_MACHINE(3_1, "3.1", false);
4653
4654 /*
4655  * pseries-3.0
4656  */
4657
4658 static void spapr_machine_3_0_class_options(MachineClass *mc)
4659 {
4660     SpaprMachineClass *smc = SPAPR_MACHINE_CLASS(mc);
4661
4662     spapr_machine_3_1_class_options(mc);
4663     compat_props_add(mc->compat_props, hw_compat_3_0, hw_compat_3_0_len);
4664
4665     smc->legacy_irq_allocation = true;
4666     smc->irq = &spapr_irq_xics_legacy;
4667 }
4668
4669 DEFINE_SPAPR_MACHINE(3_0, "3.0", false);
4670
4671 /*
4672  * pseries-2.12
4673  */
4674 static void spapr_machine_2_12_class_options(MachineClass *mc)
4675 {
4676     SpaprMachineClass *smc = SPAPR_MACHINE_CLASS(mc);
4677     static GlobalProperty compat[] = {
4678         { TYPE_POWERPC_CPU, "pre-3.0-migration", "on" },
4679         { TYPE_SPAPR_CPU_CORE, "pre-3.0-migration", "on" },
4680     };
4681
4682     spapr_machine_3_0_class_options(mc);
4683     compat_props_add(mc->compat_props, hw_compat_2_12, hw_compat_2_12_len);
4684     compat_props_add(mc->compat_props, compat, G_N_ELEMENTS(compat));
4685
4686     /* We depend on kvm_enabled() to choose a default value for the
4687      * hpt-max-page-size capability. Of course we can't do it here
4688      * because this is too early and the HW accelerator isn't initialzed
4689      * yet. Postpone this to machine init (see default_caps_with_cpu()).
4690      */
4691     smc->default_caps.caps[SPAPR_CAP_HPT_MAXPAGESIZE] = 0;
4692 }
4693
4694 DEFINE_SPAPR_MACHINE(2_12, "2.12", false);
4695
4696 static void spapr_machine_2_12_sxxm_class_options(MachineClass *mc)
4697 {
4698     SpaprMachineClass *smc = SPAPR_MACHINE_CLASS(mc);
4699
4700     spapr_machine_2_12_class_options(mc);
4701     smc->default_caps.caps[SPAPR_CAP_CFPC] = SPAPR_CAP_WORKAROUND;
4702     smc->default_caps.caps[SPAPR_CAP_SBBC] = SPAPR_CAP_WORKAROUND;
4703     smc->default_caps.caps[SPAPR_CAP_IBS] = SPAPR_CAP_FIXED_CCD;
4704 }
4705
4706 DEFINE_SPAPR_MACHINE(2_12_sxxm, "2.12-sxxm", false);
4707
4708 /*
4709  * pseries-2.11
4710  */
4711
4712 static void spapr_machine_2_11_class_options(MachineClass *mc)
4713 {
4714     SpaprMachineClass *smc = SPAPR_MACHINE_CLASS(mc);
4715
4716     spapr_machine_2_12_class_options(mc);
4717     smc->default_caps.caps[SPAPR_CAP_HTM] = SPAPR_CAP_ON;
4718     compat_props_add(mc->compat_props, hw_compat_2_11, hw_compat_2_11_len);
4719 }
4720
4721 DEFINE_SPAPR_MACHINE(2_11, "2.11", false);
4722
4723 /*
4724  * pseries-2.10
4725  */
4726
4727 static void spapr_machine_2_10_class_options(MachineClass *mc)
4728 {
4729     spapr_machine_2_11_class_options(mc);
4730     compat_props_add(mc->compat_props, hw_compat_2_10, hw_compat_2_10_len);
4731 }
4732
4733 DEFINE_SPAPR_MACHINE(2_10, "2.10", false);
4734
4735 /*
4736  * pseries-2.9
4737  */
4738
4739 static void spapr_machine_2_9_class_options(MachineClass *mc)
4740 {
4741     SpaprMachineClass *smc = SPAPR_MACHINE_CLASS(mc);
4742     static GlobalProperty compat[] = {
4743         { TYPE_POWERPC_CPU, "pre-2.10-migration", "on" },
4744     };
4745
4746     spapr_machine_2_10_class_options(mc);
4747     compat_props_add(mc->compat_props, hw_compat_2_9, hw_compat_2_9_len);
4748     compat_props_add(mc->compat_props, compat, G_N_ELEMENTS(compat));
4749     mc->numa_auto_assign_ram = numa_legacy_auto_assign_ram;
4750     smc->pre_2_10_has_unused_icps = true;
4751     smc->resize_hpt_default = SPAPR_RESIZE_HPT_DISABLED;
4752 }
4753
4754 DEFINE_SPAPR_MACHINE(2_9, "2.9", false);
4755
4756 /*
4757  * pseries-2.8
4758  */
4759
4760 static void spapr_machine_2_8_class_options(MachineClass *mc)
4761 {
4762     static GlobalProperty compat[] = {
4763         { TYPE_SPAPR_PCI_HOST_BRIDGE, "pcie-extended-configuration-space", "off" },
4764     };
4765
4766     spapr_machine_2_9_class_options(mc);
4767     compat_props_add(mc->compat_props, hw_compat_2_8, hw_compat_2_8_len);
4768     compat_props_add(mc->compat_props, compat, G_N_ELEMENTS(compat));
4769     mc->numa_mem_align_shift = 23;
4770 }
4771
4772 DEFINE_SPAPR_MACHINE(2_8, "2.8", false);
4773
4774 /*
4775  * pseries-2.7
4776  */
4777
4778 static void phb_placement_2_7(SpaprMachineState *spapr, uint32_t index,
4779                               uint64_t *buid, hwaddr *pio,
4780                               hwaddr *mmio32, hwaddr *mmio64,
4781                               unsigned n_dma, uint32_t *liobns,
4782                               hwaddr *nv2gpa, hwaddr *nv2atsd, Error **errp)
4783 {
4784     /* Legacy PHB placement for pseries-2.7 and earlier machine types */
4785     const uint64_t base_buid = 0x800000020000000ULL;
4786     const hwaddr phb_spacing = 0x1000000000ULL; /* 64 GiB */
4787     const hwaddr mmio_offset = 0xa0000000; /* 2 GiB + 512 MiB */
4788     const hwaddr pio_offset = 0x80000000; /* 2 GiB */
4789     const uint32_t max_index = 255;
4790     const hwaddr phb0_alignment = 0x10000000000ULL; /* 1 TiB */
4791
4792     uint64_t ram_top = MACHINE(spapr)->ram_size;
4793     hwaddr phb0_base, phb_base;
4794     int i;
4795
4796     /* Do we have device memory? */
4797     if (MACHINE(spapr)->maxram_size > ram_top) {
4798         /* Can't just use maxram_size, because there may be an
4799          * alignment gap between normal and device memory regions
4800          */
4801         ram_top = MACHINE(spapr)->device_memory->base +
4802             memory_region_size(&MACHINE(spapr)->device_memory->mr);
4803     }
4804
4805     phb0_base = QEMU_ALIGN_UP(ram_top, phb0_alignment);
4806
4807     if (index > max_index) {
4808         error_setg(errp, "\"index\" for PAPR PHB is too large (max %u)",
4809                    max_index);
4810         return;
4811     }
4812
4813     *buid = base_buid + index;
4814     for (i = 0; i < n_dma; ++i) {
4815         liobns[i] = SPAPR_PCI_LIOBN(index, i);
4816     }
4817
4818     phb_base = phb0_base + index * phb_spacing;
4819     *pio = phb_base + pio_offset;
4820     *mmio32 = phb_base + mmio_offset;
4821     /*
4822      * We don't set the 64-bit MMIO window, relying on the PHB's
4823      * fallback behaviour of automatically splitting a large "32-bit"
4824      * window into contiguous 32-bit and 64-bit windows
4825      */
4826
4827     *nv2gpa = 0;
4828     *nv2atsd = 0;
4829 }
4830
4831 static void spapr_machine_2_7_class_options(MachineClass *mc)
4832 {
4833     SpaprMachineClass *smc = SPAPR_MACHINE_CLASS(mc);
4834     static GlobalProperty compat[] = {
4835         { TYPE_SPAPR_PCI_HOST_BRIDGE, "mem_win_size", "0xf80000000", },
4836         { TYPE_SPAPR_PCI_HOST_BRIDGE, "mem64_win_size", "0", },
4837         { TYPE_POWERPC_CPU, "pre-2.8-migration", "on", },
4838         { TYPE_SPAPR_PCI_HOST_BRIDGE, "pre-2.8-migration", "on", },
4839     };
4840
4841     spapr_machine_2_8_class_options(mc);
4842     mc->default_cpu_type = POWERPC_CPU_TYPE_NAME("power7_v2.3");
4843     mc->default_machine_opts = "modern-hotplug-events=off";
4844     compat_props_add(mc->compat_props, hw_compat_2_7, hw_compat_2_7_len);
4845     compat_props_add(mc->compat_props, compat, G_N_ELEMENTS(compat));
4846     smc->phb_placement = phb_placement_2_7;
4847 }
4848
4849 DEFINE_SPAPR_MACHINE(2_7, "2.7", false);
4850
4851 /*
4852  * pseries-2.6
4853  */
4854
4855 static void spapr_machine_2_6_class_options(MachineClass *mc)
4856 {
4857     static GlobalProperty compat[] = {
4858         { TYPE_SPAPR_PCI_HOST_BRIDGE, "ddw", "off" },
4859     };
4860
4861     spapr_machine_2_7_class_options(mc);
4862     mc->has_hotpluggable_cpus = false;
4863     compat_props_add(mc->compat_props, hw_compat_2_6, hw_compat_2_6_len);
4864     compat_props_add(mc->compat_props, compat, G_N_ELEMENTS(compat));
4865 }
4866
4867 DEFINE_SPAPR_MACHINE(2_6, "2.6", false);
4868
4869 /*
4870  * pseries-2.5
4871  */
4872
4873 static void spapr_machine_2_5_class_options(MachineClass *mc)
4874 {
4875     SpaprMachineClass *smc = SPAPR_MACHINE_CLASS(mc);
4876     static GlobalProperty compat[] = {
4877         { "spapr-vlan", "use-rx-buffer-pools", "off" },
4878     };
4879
4880     spapr_machine_2_6_class_options(mc);
4881     smc->use_ohci_by_default = true;
4882     compat_props_add(mc->compat_props, hw_compat_2_5, hw_compat_2_5_len);
4883     compat_props_add(mc->compat_props, compat, G_N_ELEMENTS(compat));
4884 }
4885
4886 DEFINE_SPAPR_MACHINE(2_5, "2.5", false);
4887
4888 /*
4889  * pseries-2.4
4890  */
4891
4892 static void spapr_machine_2_4_class_options(MachineClass *mc)
4893 {
4894     SpaprMachineClass *smc = SPAPR_MACHINE_CLASS(mc);
4895
4896     spapr_machine_2_5_class_options(mc);
4897     smc->dr_lmb_enabled = false;
4898     compat_props_add(mc->compat_props, hw_compat_2_4, hw_compat_2_4_len);
4899 }
4900
4901 DEFINE_SPAPR_MACHINE(2_4, "2.4", false);
4902
4903 /*
4904  * pseries-2.3
4905  */
4906
4907 static void spapr_machine_2_3_class_options(MachineClass *mc)
4908 {
4909     static GlobalProperty compat[] = {
4910         { "spapr-pci-host-bridge", "dynamic-reconfiguration", "off" },
4911     };
4912     spapr_machine_2_4_class_options(mc);
4913     compat_props_add(mc->compat_props, hw_compat_2_3, hw_compat_2_3_len);
4914     compat_props_add(mc->compat_props, compat, G_N_ELEMENTS(compat));
4915 }
4916 DEFINE_SPAPR_MACHINE(2_3, "2.3", false);
4917
4918 /*
4919  * pseries-2.2
4920  */
4921
4922 static void spapr_machine_2_2_class_options(MachineClass *mc)
4923 {
4924     static GlobalProperty compat[] = {
4925         { TYPE_SPAPR_PCI_HOST_BRIDGE, "mem_win_size", "0x20000000" },
4926     };
4927
4928     spapr_machine_2_3_class_options(mc);
4929     compat_props_add(mc->compat_props, hw_compat_2_2, hw_compat_2_2_len);
4930     compat_props_add(mc->compat_props, compat, G_N_ELEMENTS(compat));
4931     mc->default_machine_opts = "modern-hotplug-events=off,suppress-vmdesc=on";
4932 }
4933 DEFINE_SPAPR_MACHINE(2_2, "2.2", false);
4934
4935 /*
4936  * pseries-2.1
4937  */
4938
4939 static void spapr_machine_2_1_class_options(MachineClass *mc)
4940 {
4941     spapr_machine_2_2_class_options(mc);
4942     compat_props_add(mc->compat_props, hw_compat_2_1, hw_compat_2_1_len);
4943 }
4944 DEFINE_SPAPR_MACHINE(2_1, "2.1", false);
4945
4946 static void spapr_machine_register_types(void)
4947 {
4948     type_register_static(&spapr_machine_info);
4949 }
4950
4951 type_init(spapr_machine_register_types)