spapr.c 81.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
/*
 * QEMU PowerPC pSeries Logical Partition (aka sPAPR) hardware System Emulator
 *
 * Copyright (c) 2004-2007 Fabrice Bellard
 * Copyright (c) 2007 Jocelyn Mayer
 * Copyright (c) 2010 David Gibson, IBM Corporation.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 */
P
Peter Maydell 已提交
27
#include "qemu/osdep.h"
28
#include "qapi/error.h"
29
#include "sysemu/sysemu.h"
30
#include "sysemu/numa.h"
31
#include "hw/hw.h"
32
#include "qemu/log.h"
33
#include "hw/fw-path-provider.h"
34
#include "elf.h"
P
Paolo Bonzini 已提交
35
#include "net/net.h"
A
Andrew Jones 已提交
36
#include "sysemu/device_tree.h"
37
#include "sysemu/block-backend.h"
38 39
#include "sysemu/cpus.h"
#include "sysemu/kvm.h"
B
Bharata B Rao 已提交
40
#include "sysemu/device_tree.h"
41
#include "kvm_ppc.h"
42
#include "migration/migration.h"
43
#include "mmu-hash64.h"
44
#include "qom/cpu.h"
45 46

#include "hw/boards.h"
P
Paolo Bonzini 已提交
47
#include "hw/ppc/ppc.h"
48 49
#include "hw/loader.h"

50
#include "hw/ppc/fdt.h"
P
Paolo Bonzini 已提交
51 52 53 54
#include "hw/ppc/spapr.h"
#include "hw/ppc/spapr_vio.h"
#include "hw/pci-host/spapr.h"
#include "hw/ppc/xics.h"
55
#include "hw/pci/msi.h"
56

57
#include "hw/pci/pci.h"
58 59
#include "hw/scsi/scsi.h"
#include "hw/virtio/virtio-scsi.h"
60

61
#include "exec/address-spaces.h"
62
#include "hw/usb.h"
63
#include "qemu/config-file.h"
64
#include "qemu/error-report.h"
65
#include "trace.h"
66
#include "hw/nmi.h"
A
Avi Kivity 已提交
67

68
#include "hw/compat.h"
69
#include "qemu/cutils.h"
70
#include "hw/ppc/spapr_cpu_core.h"
71
#include "qmp-commands.h"
72

73 74
#include <libfdt.h>

75 76 77 78 79 80 81 82 83 84
/* SLOF memory layout:
 *
 * SLOF raw image loaded at 0, copies its romfs right below the flat
 * device-tree, then position SLOF itself 31M below that
 *
 * So we set FW_OVERHEAD to 40MB which should account for all of that
 * and more
 *
 * We load our kernel at 4M, leaving space for SLOF initial image
 */
85
#define FDT_MAX_SIZE            0x100000
86
#define RTAS_MAX_SIZE           0x10000
87
#define RTAS_MAX_ADDR           0x80000000 /* RTAS must stay below that */
88 89
#define FW_MAX_SIZE             0x400000
#define FW_FILE_NAME            "slof.bin"
90 91
#define FW_OVERHEAD             0x2800000
#define KERNEL_LOAD_ADDR        FW_MAX_SIZE
92

93
#define MIN_RMA_SLOF            128UL
94

95 96
#define PHANDLE_XICP            0x00001111

97 98
#define HTAB_SIZE(spapr)        (1ULL << ((spapr)->htab_shift))

99
static XICSState *try_create_xics(const char *type, int nr_servers,
100
                                  int nr_irqs, Error **errp)
101
{
102
    Error *err = NULL;
103 104 105 106 107
    DeviceState *dev;

    dev = qdev_create(NULL, type);
    qdev_prop_set_uint32(dev, "nr_servers", nr_servers);
    qdev_prop_set_uint32(dev, "nr_irqs", nr_irqs);
108 109 110 111
    object_property_set_bool(OBJECT(dev), true, "realized", &err);
    if (err) {
        error_propagate(errp, err);
        object_unparent(OBJECT(dev));
112 113
        return NULL;
    }
114
    return XICS_COMMON(dev);
115 116
}

117
static XICSState *xics_system_init(MachineState *machine,
118
                                   int nr_servers, int nr_irqs, Error **errp)
119
{
120
    XICSState *xics = NULL;
121

122
    if (kvm_enabled()) {
123 124
        Error *err = NULL;

125
        if (machine_kernel_irqchip_allowed(machine)) {
126 127
            xics = try_create_xics(TYPE_XICS_SPAPR_KVM, nr_servers, nr_irqs,
                                   &err);
128
        }
129
        if (machine_kernel_irqchip_required(machine) && !xics) {
130 131 132 133
            error_reportf_err(err,
                              "kernel_irqchip requested but unavailable: ");
        } else {
            error_free(err);
134 135 136
        }
    }

137 138
    if (!xics) {
        xics = try_create_xics(TYPE_XICS_SPAPR, nr_servers, nr_irqs, errp);
139 140
    }

141
    return xics;
142 143
}

144 145 146 147 148 149 150 151
static int spapr_fixup_cpu_smt_dt(void *fdt, int offset, PowerPCCPU *cpu,
                                  int smt_threads)
{
    int i, ret = 0;
    uint32_t servers_prop[smt_threads];
    uint32_t gservers_prop[smt_threads * 2];
    int index = ppc_get_vcpu_dt_id(cpu);

152
    if (cpu->cpu_version) {
153
        ret = fdt_setprop_cell(fdt, offset, "cpu-version", cpu->cpu_version);
154 155 156 157 158
        if (ret < 0) {
            return ret;
        }
    }

159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
    /* Build interrupt servers and gservers properties */
    for (i = 0; i < smt_threads; i++) {
        servers_prop[i] = cpu_to_be32(index + i);
        /* Hack, direct the group queues back to cpu 0 */
        gservers_prop[i*2] = cpu_to_be32(index + i);
        gservers_prop[i*2 + 1] = 0;
    }
    ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-server#s",
                      servers_prop, sizeof(servers_prop));
    if (ret < 0) {
        return ret;
    }
    ret = fdt_setprop(fdt, offset, "ibm,ppc-interrupt-gserver#s",
                      gservers_prop, sizeof(gservers_prop));

    return ret;
}

177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197
static int spapr_fixup_cpu_numa_dt(void *fdt, int offset, CPUState *cs)
{
    int ret = 0;
    PowerPCCPU *cpu = POWERPC_CPU(cs);
    int index = ppc_get_vcpu_dt_id(cpu);
    uint32_t associativity[] = {cpu_to_be32(0x5),
                                cpu_to_be32(0x0),
                                cpu_to_be32(0x0),
                                cpu_to_be32(0x0),
                                cpu_to_be32(cs->numa_node),
                                cpu_to_be32(index)};

    /* Advertise NUMA via ibm,associativity */
    if (nb_numa_nodes > 1) {
        ret = fdt_setprop(fdt, offset, "ibm,associativity", associativity,
                          sizeof(associativity));
    }

    return ret;
}

198
static int spapr_fixup_cpu_dt(void *fdt, sPAPRMachineState *spapr)
199
{
200 201
    int ret = 0, offset, cpus_offset;
    CPUState *cs;
202 203
    char cpu_model[32];
    int smt = kvmppc_smt_threads();
204
    uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)};
205

206 207 208 209
    CPU_FOREACH(cs) {
        PowerPCCPU *cpu = POWERPC_CPU(cs);
        DeviceClass *dc = DEVICE_GET_CLASS(cs);
        int index = ppc_get_vcpu_dt_id(cpu);
210

211
        if ((index % smt) != 0) {
212 213 214
            continue;
        }

215
        snprintf(cpu_model, 32, "%s@%x", dc->fw_name, index);
216

217 218 219 220 221 222 223 224 225
        cpus_offset = fdt_path_offset(fdt, "/cpus");
        if (cpus_offset < 0) {
            cpus_offset = fdt_add_subnode(fdt, fdt_path_offset(fdt, "/"),
                                          "cpus");
            if (cpus_offset < 0) {
                return cpus_offset;
            }
        }
        offset = fdt_subnode_offset(fdt, cpus_offset, cpu_model);
226
        if (offset < 0) {
227 228 229 230
            offset = fdt_add_subnode(fdt, cpus_offset, cpu_model);
            if (offset < 0) {
                return offset;
            }
231 232
        }

233 234
        ret = fdt_setprop(fdt, offset, "ibm,pft-size",
                          pft_size_prop, sizeof(pft_size_prop));
235 236 237
        if (ret < 0) {
            return ret;
        }
238

239 240 241 242 243
        ret = spapr_fixup_cpu_numa_dt(fdt, offset, cs);
        if (ret < 0) {
            return ret;
        }

244
        ret = spapr_fixup_cpu_smt_dt(fdt, offset, cpu,
245
                                     ppc_get_compat_smt_threads(cpu));
246 247 248
        if (ret < 0) {
            return ret;
        }
249 250 251 252
    }
    return ret;
}

253 254
static hwaddr spapr_node0_size(void)
{
255 256
    MachineState *machine = MACHINE(qdev_get_machine());

257 258 259 260
    if (nb_numa_nodes) {
        int i;
        for (i = 0; i < nb_numa_nodes; ++i) {
            if (numa_info[i].node_mem) {
261 262
                return MIN(pow2floor(numa_info[i].node_mem),
                           machine->ram_size);
263 264 265
            }
        }
    }
266
    return machine->ram_size;
267 268
}

269 270 271 272
static void add_str(GString *s, const gchar *s1)
{
    g_string_append_len(s, s1, strlen(s1) + 1);
}
273

274
static void *spapr_create_fdt_skel(hwaddr initrd_base,
A
Avi Kivity 已提交
275 276
                                   hwaddr initrd_size,
                                   hwaddr kernel_size,
277
                                   bool little_endian,
278 279
                                   const char *kernel_cmdline,
                                   uint32_t epow_irq)
280 281 282 283
{
    void *fdt;
    uint32_t start_prop = cpu_to_be32(initrd_base);
    uint32_t end_prop = cpu_to_be32(initrd_base + initrd_size);
284 285
    GString *hypertas = g_string_sized_new(256);
    GString *qemu_hypertas = g_string_sized_new(256);
286
    uint32_t refpoints[] = {cpu_to_be32(0x4), cpu_to_be32(0x4)};
287
    uint32_t interrupt_server_ranges_prop[] = {0, cpu_to_be32(max_cpus)};
288
    unsigned char vec5[] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x80};
289
    char *buf;
290

291 292 293 294 295 296 297 298 299
    add_str(hypertas, "hcall-pft");
    add_str(hypertas, "hcall-term");
    add_str(hypertas, "hcall-dabr");
    add_str(hypertas, "hcall-interrupt");
    add_str(hypertas, "hcall-tce");
    add_str(hypertas, "hcall-vio");
    add_str(hypertas, "hcall-splpar");
    add_str(hypertas, "hcall-bulk");
    add_str(hypertas, "hcall-set-mode");
300 301 302
    add_str(hypertas, "hcall-sprg0");
    add_str(hypertas, "hcall-copy");
    add_str(hypertas, "hcall-debug");
303 304
    add_str(qemu_hypertas, "hcall-memop1");

305
    fdt = g_malloc0(FDT_MAX_SIZE);
306 307
    _FDT((fdt_create(fdt, FDT_MAX_SIZE)));

308 309 310 311 312 313
    if (kernel_size) {
        _FDT((fdt_add_reservemap_entry(fdt, KERNEL_LOAD_ADDR, kernel_size)));
    }
    if (initrd_size) {
        _FDT((fdt_add_reservemap_entry(fdt, initrd_base, initrd_size)));
    }
314 315 316 317 318
    _FDT((fdt_finish_reservemap(fdt)));

    /* Root node */
    _FDT((fdt_begin_node(fdt, "")));
    _FDT((fdt_property_string(fdt, "device_type", "chrp")));
319
    _FDT((fdt_property_string(fdt, "model", "IBM pSeries (emulated by qemu)")));
320
    _FDT((fdt_property_string(fdt, "compatible", "qemu,pseries")));
321

322 323 324 325 326 327 328 329 330 331 332 333 334
    /*
     * Add info to guest to indentify which host is it being run on
     * and what is the uuid of the guest
     */
    if (kvmppc_get_host_model(&buf)) {
        _FDT((fdt_property_string(fdt, "host-model", buf)));
        g_free(buf);
    }
    if (kvmppc_get_host_serial(&buf)) {
        _FDT((fdt_property_string(fdt, "host-serial", buf)));
        g_free(buf);
    }

F
Fam Zheng 已提交
335
    buf = qemu_uuid_unparse_strdup(&qemu_uuid);
336 337

    _FDT((fdt_property_string(fdt, "vm,uuid", buf)));
A
Alexey Kardashevskiy 已提交
338 339 340
    if (qemu_uuid_set) {
        _FDT((fdt_property_string(fdt, "system-id", buf)));
    }
341 342
    g_free(buf);

S
Sam Bobroff 已提交
343 344 345 346 347
    if (qemu_get_vm_name()) {
        _FDT((fdt_property_string(fdt, "ibm,partition-name",
                                  qemu_get_vm_name())));
    }

348 349 350 351 352 353
    _FDT((fdt_property_cell(fdt, "#address-cells", 0x2)));
    _FDT((fdt_property_cell(fdt, "#size-cells", 0x2)));

    /* /chosen */
    _FDT((fdt_begin_node(fdt, "chosen")));

354 355 356
    /* Set Form1_affinity */
    _FDT((fdt_property(fdt, "ibm,architecture-vec-5", vec5, sizeof(vec5))));

357 358 359 360 361
    _FDT((fdt_property_string(fdt, "bootargs", kernel_cmdline)));
    _FDT((fdt_property(fdt, "linux,initrd-start",
                       &start_prop, sizeof(start_prop))));
    _FDT((fdt_property(fdt, "linux,initrd-end",
                       &end_prop, sizeof(end_prop))));
362 363 364
    if (kernel_size) {
        uint64_t kprop[2] = { cpu_to_be64(KERNEL_LOAD_ADDR),
                              cpu_to_be64(kernel_size) };
365

366
        _FDT((fdt_property(fdt, "qemu,boot-kernel", &kprop, sizeof(kprop))));
367 368 369
        if (little_endian) {
            _FDT((fdt_property(fdt, "qemu,boot-kernel-le", NULL, 0)));
        }
370
    }
371 372 373
    if (boot_menu) {
        _FDT((fdt_property_cell(fdt, "qemu,boot-menu", boot_menu)));
    }
374 375 376
    _FDT((fdt_property_cell(fdt, "qemu,graphic-width", graphic_width)));
    _FDT((fdt_property_cell(fdt, "qemu,graphic-height", graphic_height)));
    _FDT((fdt_property_cell(fdt, "qemu,graphic-depth", graphic_depth)));
377

378 379
    _FDT((fdt_end_node(fdt)));

380 381 382
    /* RTAS */
    _FDT((fdt_begin_node(fdt, "rtas")));

383 384 385
    if (!kvm_enabled() || kvmppc_spapr_use_multitce()) {
        add_str(hypertas, "hcall-multi-tce");
    }
386 387 388 389 390 391
    _FDT((fdt_property(fdt, "ibm,hypertas-functions", hypertas->str,
                       hypertas->len)));
    g_string_free(hypertas, TRUE);
    _FDT((fdt_property(fdt, "qemu,hypertas-functions", qemu_hypertas->str,
                       qemu_hypertas->len)));
    g_string_free(qemu_hypertas, TRUE);
392

393 394 395
    _FDT((fdt_property(fdt, "ibm,associativity-reference-points",
        refpoints, sizeof(refpoints))));

396
    _FDT((fdt_property_cell(fdt, "rtas-error-log-max", RTAS_ERROR_LOG_MAX)));
397 398
    _FDT((fdt_property_cell(fdt, "rtas-event-scan-rate",
                            RTAS_EVENT_SCAN_RATE)));
399

400
    if (msi_nonbroken) {
401 402 403
        _FDT((fdt_property(fdt, "ibm,change-msix-capable", NULL, 0)));
    }

404
    /*
405
     * According to PAPR, rtas ibm,os-term does not guarantee a return
406 407 408 409 410 411 412
     * back to the guest cpu.
     *
     * While an additional ibm,extended-os-term property indicates that
     * rtas call return will always occur. Set this property.
     */
    _FDT((fdt_property(fdt, "ibm,extended-os-term", NULL, 0)));

413 414
    _FDT((fdt_end_node(fdt)));

415
    /* interrupt controller */
416
    _FDT((fdt_begin_node(fdt, "interrupt-controller")));
417 418 419 420 421 422 423 424

    _FDT((fdt_property_string(fdt, "device_type",
                              "PowerPC-External-Interrupt-Presentation")));
    _FDT((fdt_property_string(fdt, "compatible", "IBM,ppc-xicp")));
    _FDT((fdt_property(fdt, "interrupt-controller", NULL, 0)));
    _FDT((fdt_property(fdt, "ibm,interrupt-server-ranges",
                       interrupt_server_ranges_prop,
                       sizeof(interrupt_server_ranges_prop))));
425 426 427
    _FDT((fdt_property_cell(fdt, "#interrupt-cells", 2)));
    _FDT((fdt_property_cell(fdt, "linux,phandle", PHANDLE_XICP)));
    _FDT((fdt_property_cell(fdt, "phandle", PHANDLE_XICP)));
428 429 430

    _FDT((fdt_end_node(fdt)));

431 432 433 434 435 436 437
    /* vdevice */
    _FDT((fdt_begin_node(fdt, "vdevice")));

    _FDT((fdt_property_string(fdt, "device_type", "vdevice")));
    _FDT((fdt_property_string(fdt, "compatible", "IBM,vdevice")));
    _FDT((fdt_property_cell(fdt, "#address-cells", 0x1)));
    _FDT((fdt_property_cell(fdt, "#size-cells", 0x0)));
438 439
    _FDT((fdt_property_cell(fdt, "#interrupt-cells", 0x2)));
    _FDT((fdt_property(fdt, "interrupt-controller", NULL, 0)));
440 441 442

    _FDT((fdt_end_node(fdt)));

443 444 445
    /* event-sources */
    spapr_events_fdt_skel(fdt, epow_irq);

446 447 448 449 450 451 452 453 454 455 456 457
    /* /hypervisor node */
    if (kvm_enabled()) {
        uint8_t hypercall[16];

        /* indicate KVM hypercall interface */
        _FDT((fdt_begin_node(fdt, "hypervisor")));
        _FDT((fdt_property_string(fdt, "compatible", "linux,kvm")));
        if (kvmppc_has_cap_fixup_hcalls()) {
            /*
             * Older KVM versions with older guest kernels were broken with the
             * magic page, don't allow the guest to map it.
             */
458 459 460 461 462
            if (!kvmppc_get_hypercall(first_cpu->env_ptr, hypercall,
                                      sizeof(hypercall))) {
                _FDT((fdt_property(fdt, "hcall-instructions", hypercall,
                                   sizeof(hypercall))));
            }
463 464 465 466
        }
        _FDT((fdt_end_node(fdt)));
    }

467 468 469
    _FDT((fdt_end_node(fdt))); /* close root node */
    _FDT((fdt_finish(fdt)));

470 471 472
    return fdt;
}

473
static int spapr_populate_memory_node(void *fdt, int nodeid, hwaddr start,
474 475 476 477 478
                                       hwaddr size)
{
    uint32_t associativity[] = {
        cpu_to_be32(0x4), /* length */
        cpu_to_be32(0x0), cpu_to_be32(0x0),
479
        cpu_to_be32(0x0), cpu_to_be32(nodeid)
480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495
    };
    char mem_name[32];
    uint64_t mem_reg_property[2];
    int off;

    mem_reg_property[0] = cpu_to_be64(start);
    mem_reg_property[1] = cpu_to_be64(size);

    sprintf(mem_name, "memory@" TARGET_FMT_lx, start);
    off = fdt_add_subnode(fdt, 0, mem_name);
    _FDT(off);
    _FDT((fdt_setprop_string(fdt, off, "device_type", "memory")));
    _FDT((fdt_setprop(fdt, off, "reg", mem_reg_property,
                      sizeof(mem_reg_property))));
    _FDT((fdt_setprop(fdt, off, "ibm,associativity", associativity,
                      sizeof(associativity))));
496
    return off;
497 498
}

499
static int spapr_populate_memory(sPAPRMachineState *spapr, void *fdt)
500
{
501
    MachineState *machine = MACHINE(spapr);
502 503 504 505 506 507 508 509
    hwaddr mem_start, node_size;
    int i, nb_nodes = nb_numa_nodes;
    NodeInfo *nodes = numa_info;
    NodeInfo ramnode;

    /* No NUMA nodes, assume there is just one node with whole RAM */
    if (!nb_numa_nodes) {
        nb_nodes = 1;
510
        ramnode.node_mem = machine->ram_size;
511
        nodes = &ramnode;
512
    }
513

514 515 516 517
    for (i = 0, mem_start = 0; i < nb_nodes; ++i) {
        if (!nodes[i].node_mem) {
            continue;
        }
518
        if (mem_start >= machine->ram_size) {
519 520
            node_size = 0;
        } else {
521
            node_size = nodes[i].node_mem;
522 523
            if (node_size > machine->ram_size - mem_start) {
                node_size = machine->ram_size - mem_start;
524 525
            }
        }
526 527
        if (!mem_start) {
            /* ppc_spapr_init() checks for rma_size <= node0_size already */
528
            spapr_populate_memory_node(fdt, i, 0, spapr->rma_size);
529 530 531
            mem_start += spapr->rma_size;
            node_size -= spapr->rma_size;
        }
532 533 534 535 536 537 538 539 540 541 542 543
        for ( ; node_size; ) {
            hwaddr sizetmp = pow2floor(node_size);

            /* mem_start != 0 here */
            if (ctzl(mem_start) < ctzl(sizetmp)) {
                sizetmp = 1ULL << ctzl(mem_start);
            }

            spapr_populate_memory_node(fdt, i, mem_start, sizetmp);
            node_size -= sizetmp;
            mem_start += sizetmp;
        }
544 545 546 547 548
    }

    return 0;
}

549 550 551 552 553 554 555 556 557 558 559 560 561
/* Populate the "ibm,pa-features" property */
static void spapr_populate_pa_features(CPUPPCState *env, void *fdt, int offset)
{
    uint8_t pa_features_206[] = { 6, 0,
        0xf6, 0x1f, 0xc7, 0x00, 0x80, 0xc0 };
    uint8_t pa_features_207[] = { 24, 0,
        0xf6, 0x1f, 0xc7, 0xc0, 0x80, 0xf0,
        0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x00, 0x00, 0x00, 0x00, 0x80, 0x00,
        0x80, 0x00, 0x80, 0x00, 0x80, 0x00 };
    uint8_t *pa_features;
    size_t pa_size;

562 563 564
    switch (env->mmu_model) {
    case POWERPC_MMU_2_06:
    case POWERPC_MMU_2_06a:
565 566
        pa_features = pa_features_206;
        pa_size = sizeof(pa_features_206);
567 568 569
        break;
    case POWERPC_MMU_2_07:
    case POWERPC_MMU_2_07a:
570 571
        pa_features = pa_features_207;
        pa_size = sizeof(pa_features_207);
572 573 574
        break;
    default:
        return;
575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
    }

    if (env->ci_large_pages) {
        /*
         * Note: we keep CI large pages off by default because a 64K capable
         * guest provisioned with large pages might otherwise try to map a qemu
         * framebuffer (or other kind of memory mapped PCI BAR) using 64K pages
         * even if that qemu runs on a 4k host.
         * We dd this bit back here if we are confident this is not an issue
         */
        pa_features[3] |= 0x20;
    }

    _FDT((fdt_setprop(fdt, offset, "ibm,pa-features", pa_features, pa_size)));
}

591 592 593 594 595 596 597 598 599
static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset,
                                  sPAPRMachineState *spapr)
{
    PowerPCCPU *cpu = POWERPC_CPU(cs);
    CPUPPCState *env = &cpu->env;
    PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cs);
    int index = ppc_get_vcpu_dt_id(cpu);
    uint32_t segs[] = {cpu_to_be32(28), cpu_to_be32(40),
                       0xffffffff, 0xffffffff};
600 601
    uint32_t tbfreq = kvm_enabled() ? kvmppc_get_tbfreq()
        : SPAPR_TIMEBASE_FREQ;
602 603 604
    uint32_t cpufreq = kvm_enabled() ? kvmppc_get_clockfreq() : 1000000000;
    uint32_t page_sizes_prop[64];
    size_t page_sizes_prop_size;
605
    uint32_t vcpus_per_socket = smp_threads * smp_cores;
606
    uint32_t pft_size_prop[] = {0, cpu_to_be32(spapr->htab_shift)};
B
Bharata B Rao 已提交
607 608 609 610 611 612 613 614 615 616
    sPAPRDRConnector *drc;
    sPAPRDRConnectorClass *drck;
    int drc_index;

    drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_CPU, index);
    if (drc) {
        drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
        drc_index = drck->get_index(drc);
        _FDT((fdt_setprop_cell(fdt, offset, "ibm,my-drc-index", drc_index)));
    }
617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634

    _FDT((fdt_setprop_cell(fdt, offset, "reg", index)));
    _FDT((fdt_setprop_string(fdt, offset, "device_type", "cpu")));

    _FDT((fdt_setprop_cell(fdt, offset, "cpu-version", env->spr[SPR_PVR])));
    _FDT((fdt_setprop_cell(fdt, offset, "d-cache-block-size",
                           env->dcache_line_size)));
    _FDT((fdt_setprop_cell(fdt, offset, "d-cache-line-size",
                           env->dcache_line_size)));
    _FDT((fdt_setprop_cell(fdt, offset, "i-cache-block-size",
                           env->icache_line_size)));
    _FDT((fdt_setprop_cell(fdt, offset, "i-cache-line-size",
                           env->icache_line_size)));

    if (pcc->l1_dcache_size) {
        _FDT((fdt_setprop_cell(fdt, offset, "d-cache-size",
                               pcc->l1_dcache_size)));
    } else {
635
        error_report("Warning: Unknown L1 dcache size for cpu");
636 637 638 639 640
    }
    if (pcc->l1_icache_size) {
        _FDT((fdt_setprop_cell(fdt, offset, "i-cache-size",
                               pcc->l1_icache_size)));
    } else {
641
        error_report("Warning: Unknown L1 icache size for cpu");
642 643 644 645
    }

    _FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq)));
    _FDT((fdt_setprop_cell(fdt, offset, "clock-frequency", cpufreq)));
646
    _FDT((fdt_setprop_cell(fdt, offset, "slb-size", env->slb_nr)));
647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676
    _FDT((fdt_setprop_cell(fdt, offset, "ibm,slb-size", env->slb_nr)));
    _FDT((fdt_setprop_string(fdt, offset, "status", "okay")));
    _FDT((fdt_setprop(fdt, offset, "64-bit", NULL, 0)));

    if (env->spr_cb[SPR_PURR].oea_read) {
        _FDT((fdt_setprop(fdt, offset, "ibm,purr", NULL, 0)));
    }

    if (env->mmu_model & POWERPC_MMU_1TSEG) {
        _FDT((fdt_setprop(fdt, offset, "ibm,processor-segment-sizes",
                          segs, sizeof(segs))));
    }

    /* Advertise VMX/VSX (vector extensions) if available
     *   0 / no property == no vector extensions
     *   1               == VMX / Altivec available
     *   2               == VSX available */
    if (env->insns_flags & PPC_ALTIVEC) {
        uint32_t vmx = (env->insns_flags2 & PPC2_VSX) ? 2 : 1;

        _FDT((fdt_setprop_cell(fdt, offset, "ibm,vmx", vmx)));
    }

    /* Advertise DFP (Decimal Floating Point) if available
     *   0 / no property == no DFP
     *   1               == DFP available */
    if (env->insns_flags2 & PPC2_DFP) {
        _FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1)));
    }

677
    page_sizes_prop_size = ppc_create_page_sizes_prop(env, page_sizes_prop,
678 679 680 681 682 683
                                                  sizeof(page_sizes_prop));
    if (page_sizes_prop_size) {
        _FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes",
                          page_sizes_prop, page_sizes_prop_size)));
    }

684
    spapr_populate_pa_features(env, fdt, offset);
685

686
    _FDT((fdt_setprop_cell(fdt, offset, "ibm,chip-id",
687
                           cs->cpu_index / vcpus_per_socket)));
688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733

    _FDT((fdt_setprop(fdt, offset, "ibm,pft-size",
                      pft_size_prop, sizeof(pft_size_prop))));

    _FDT(spapr_fixup_cpu_numa_dt(fdt, offset, cs));

    _FDT(spapr_fixup_cpu_smt_dt(fdt, offset, cpu,
                                ppc_get_compat_smt_threads(cpu)));
}

static void spapr_populate_cpus_dt_node(void *fdt, sPAPRMachineState *spapr)
{
    CPUState *cs;
    int cpus_offset;
    char *nodename;
    int smt = kvmppc_smt_threads();

    cpus_offset = fdt_add_subnode(fdt, 0, "cpus");
    _FDT(cpus_offset);
    _FDT((fdt_setprop_cell(fdt, cpus_offset, "#address-cells", 0x1)));
    _FDT((fdt_setprop_cell(fdt, cpus_offset, "#size-cells", 0x0)));

    /*
     * We walk the CPUs in reverse order to ensure that CPU DT nodes
     * created by fdt_add_subnode() end up in the right order in FDT
     * for the guest kernel the enumerate the CPUs correctly.
     */
    CPU_FOREACH_REVERSE(cs) {
        PowerPCCPU *cpu = POWERPC_CPU(cs);
        int index = ppc_get_vcpu_dt_id(cpu);
        DeviceClass *dc = DEVICE_GET_CLASS(cs);
        int offset;

        if ((index % smt) != 0) {
            continue;
        }

        nodename = g_strdup_printf("%s@%x", dc->fw_name, index);
        offset = fdt_add_subnode(fdt, cpus_offset, nodename);
        g_free(nodename);
        _FDT(offset);
        spapr_populate_cpu_dt(cs, fdt, offset, spapr);
    }

}

734 735 736 737 738 739 740 741 742 743 744
/*
 * Adds ibm,dynamic-reconfiguration-memory node.
 * Refer to docs/specs/ppc-spapr-hotplug.txt for the documentation
 * of this device tree node.
 */
static int spapr_populate_drconf_memory(sPAPRMachineState *spapr, void *fdt)
{
    MachineState *machine = MACHINE(spapr);
    int ret, i, offset;
    uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE;
    uint32_t prop_lmb_size[] = {0, cpu_to_be32(lmb_size)};
745 746 747 748
    uint32_t hotplug_lmb_start = spapr->hotplug_memory.base / lmb_size;
    uint32_t nr_lmbs = (spapr->hotplug_memory.base +
                       memory_region_size(&spapr->hotplug_memory.mr)) /
                       lmb_size;
749
    uint32_t *int_buf, *cur_index, buf_len;
750
    int nr_nodes = nb_numa_nodes ? nb_numa_nodes : 1;
751

752
    /*
753
     * Don't create the node if there is no hotpluggable memory
754
     */
755
    if (machine->ram_size == machine->maxram_size) {
756 757 758
        return 0;
    }

759 760 761 762 763 764
    /*
     * Allocate enough buffer size to fit in ibm,dynamic-memory
     * or ibm,associativity-lookup-arrays
     */
    buf_len = MAX(nr_lmbs * SPAPR_DR_LMB_LIST_ENTRY_SIZE + 1, nr_nodes * 4 + 2)
              * sizeof(uint32_t);
765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788
    cur_index = int_buf = g_malloc0(buf_len);

    offset = fdt_add_subnode(fdt, 0, "ibm,dynamic-reconfiguration-memory");

    ret = fdt_setprop(fdt, offset, "ibm,lmb-size", prop_lmb_size,
                    sizeof(prop_lmb_size));
    if (ret < 0) {
        goto out;
    }

    ret = fdt_setprop_cell(fdt, offset, "ibm,memory-flags-mask", 0xff);
    if (ret < 0) {
        goto out;
    }

    ret = fdt_setprop_cell(fdt, offset, "ibm,memory-preservation-time", 0x0);
    if (ret < 0) {
        goto out;
    }

    /* ibm,dynamic-memory */
    int_buf[0] = cpu_to_be32(nr_lmbs);
    cur_index++;
    for (i = 0; i < nr_lmbs; i++) {
789
        uint64_t addr = i * lmb_size;
790 791
        uint32_t *dynamic_memory = cur_index;

792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809
        if (i >= hotplug_lmb_start) {
            sPAPRDRConnector *drc;
            sPAPRDRConnectorClass *drck;

            drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB, i);
            g_assert(drc);
            drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);

            dynamic_memory[0] = cpu_to_be32(addr >> 32);
            dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff);
            dynamic_memory[2] = cpu_to_be32(drck->get_index(drc));
            dynamic_memory[3] = cpu_to_be32(0); /* reserved */
            dynamic_memory[4] = cpu_to_be32(numa_get_node(addr, NULL));
            if (memory_region_present(get_system_memory(), addr)) {
                dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_ASSIGNED);
            } else {
                dynamic_memory[5] = cpu_to_be32(0);
            }
810
        } else {
811 812 813 814 815 816 817 818 819 820 821 822
            /*
             * LMB information for RMA, boot time RAM and gap b/n RAM and
             * hotplug memory region -- all these are marked as reserved
             * and as having no valid DRC.
             */
            dynamic_memory[0] = cpu_to_be32(addr >> 32);
            dynamic_memory[1] = cpu_to_be32(addr & 0xffffffff);
            dynamic_memory[2] = cpu_to_be32(0);
            dynamic_memory[3] = cpu_to_be32(0); /* reserved */
            dynamic_memory[4] = cpu_to_be32(-1);
            dynamic_memory[5] = cpu_to_be32(SPAPR_LMB_FLAGS_RESERVED |
                                            SPAPR_LMB_FLAGS_DRC_INVALID);
823 824 825 826 827 828 829 830 831 832 833
        }

        cur_index += SPAPR_DR_LMB_LIST_ENTRY_SIZE;
    }
    ret = fdt_setprop(fdt, offset, "ibm,dynamic-memory", int_buf, buf_len);
    if (ret < 0) {
        goto out;
    }

    /* ibm,associativity-lookup-arrays */
    cur_index = int_buf;
834
    int_buf[0] = cpu_to_be32(nr_nodes);
835 836
    int_buf[1] = cpu_to_be32(4); /* Number of entries per associativity list */
    cur_index += 2;
837
    for (i = 0; i < nr_nodes; i++) {
838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878
        uint32_t associativity[] = {
            cpu_to_be32(0x0),
            cpu_to_be32(0x0),
            cpu_to_be32(0x0),
            cpu_to_be32(i)
        };
        memcpy(cur_index, associativity, sizeof(associativity));
        cur_index += 4;
    }
    ret = fdt_setprop(fdt, offset, "ibm,associativity-lookup-arrays", int_buf,
            (cur_index - int_buf) * sizeof(uint32_t));
out:
    g_free(int_buf);
    return ret;
}

int spapr_h_cas_compose_response(sPAPRMachineState *spapr,
                                 target_ulong addr, target_ulong size,
                                 bool cpu_update, bool memory_update)
{
    void *fdt, *fdt_skel;
    sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 };
    sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine());

    size -= sizeof(hdr);

    /* Create sceleton */
    fdt_skel = g_malloc0(size);
    _FDT((fdt_create(fdt_skel, size)));
    _FDT((fdt_begin_node(fdt_skel, "")));
    _FDT((fdt_end_node(fdt_skel)));
    _FDT((fdt_finish(fdt_skel)));
    fdt = g_malloc0(size);
    _FDT((fdt_open_into(fdt_skel, fdt, size)));
    g_free(fdt_skel);

    /* Fixup cpu nodes */
    if (cpu_update) {
        _FDT((spapr_fixup_cpu_dt(fdt, spapr)));
    }

879
    /* Generate ibm,dynamic-reconfiguration-memory node if required */
880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899
    if (memory_update && smc->dr_lmb_enabled) {
        _FDT((spapr_populate_drconf_memory(spapr, fdt)));
    }

    /* Pack resulting tree */
    _FDT((fdt_pack(fdt)));

    if (fdt_totalsize(fdt) + sizeof(hdr) > size) {
        trace_spapr_cas_failed(size);
        return -1;
    }

    cpu_physical_memory_write(addr, &hdr, sizeof(hdr));
    cpu_physical_memory_write(addr + sizeof(hdr), fdt, fdt_totalsize(fdt));
    trace_spapr_cas_continue(fdt_totalsize(fdt) + sizeof(hdr));
    g_free(fdt);

    return 0;
}

900
static void spapr_finalize_fdt(sPAPRMachineState *spapr,
A
Avi Kivity 已提交
901 902 903
                               hwaddr fdt_addr,
                               hwaddr rtas_addr,
                               hwaddr rtas_size)
904
{
905
    MachineState *machine = MACHINE(qdev_get_machine());
906
    MachineClass *mc = MACHINE_GET_CLASS(machine);
B
Bharata B Rao 已提交
907
    sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine);
908
    const char *boot_device = machine->boot_order;
909 910 911
    int ret, i;
    size_t cb = 0;
    char *bootlist;
912
    void *fdt;
913
    sPAPRPHBState *phb;
914

915
    fdt = g_malloc(FDT_MAX_SIZE);
916 917 918

    /* open out the base tree into a temp buffer for the final tweaks */
    _FDT((fdt_open_into(spapr->fdt_skel, fdt, FDT_MAX_SIZE)));
919

920 921
    ret = spapr_populate_memory(spapr, fdt);
    if (ret < 0) {
922
        error_report("couldn't setup memory nodes in fdt");
923
        exit(1);
924 925
    }

926 927
    ret = spapr_populate_vdevice(spapr->vio_bus, fdt);
    if (ret < 0) {
928
        error_report("couldn't setup vio devices in fdt");
929 930 931
        exit(1);
    }

932 933 934
    if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)) {
        ret = spapr_rng_populate_dt(fdt);
        if (ret < 0) {
935
            error_report("could not set up rng device in the fdt");
936 937 938 939
            exit(1);
        }
    }

940
    QLIST_FOREACH(phb, &spapr->phbs, list) {
941
        ret = spapr_populate_pci_dt(phb, PHANDLE_XICP, fdt);
942 943 944 945
        if (ret < 0) {
            error_report("couldn't setup PCI devices in fdt");
            exit(1);
        }
946 947
    }

948 949 950
    /* RTAS */
    ret = spapr_rtas_device_tree_setup(fdt, rtas_addr, rtas_size);
    if (ret < 0) {
951
        error_report("Couldn't set up RTAS device tree properties");
952 953
    }

954 955
    /* cpus */
    spapr_populate_cpus_dt_node(fdt, spapr);
956

957 958 959 960 961 962 963 964 965 966 967 968 969 970 971
    bootlist = get_boot_devices_list(&cb, true);
    if (cb && bootlist) {
        int offset = fdt_path_offset(fdt, "/chosen");
        if (offset < 0) {
            exit(1);
        }
        for (i = 0; i < cb; i++) {
            if (bootlist[i] == '\n') {
                bootlist[i] = ' ';
            }

        }
        ret = fdt_setprop_string(fdt, offset, "qemu,boot-list", bootlist);
    }

972 973 974 975 976 977 978 979 980
    if (boot_device && strlen(boot_device)) {
        int offset = fdt_path_offset(fdt, "/chosen");

        if (offset < 0) {
            exit(1);
        }
        fdt_setprop_string(fdt, offset, "qemu,boot-device", boot_device);
    }

981
    if (!spapr->has_graphics) {
982 983
        spapr_populate_chosen_stdout(fdt, spapr->vio_bus);
    }
984

B
Bharata B Rao 已提交
985 986 987 988
    if (smc->dr_lmb_enabled) {
        _FDT(spapr_drc_populate_dt(fdt, 0, NULL, SPAPR_DR_CONNECTOR_TYPE_LMB));
    }

989
    if (mc->query_hotpluggable_cpus) {
B
Bharata B Rao 已提交
990 991 992 993 994 995 996 997 998
        int offset = fdt_path_offset(fdt, "/cpus");
        ret = spapr_drc_populate_dt(fdt, offset, NULL,
                                    SPAPR_DR_CONNECTOR_TYPE_CPU);
        if (ret < 0) {
            error_report("Couldn't set up CPU DR device tree properties");
            exit(1);
        }
    }

999 1000
    _FDT((fdt_pack(fdt)));

1001
    if (fdt_totalsize(fdt) > FDT_MAX_SIZE) {
1002 1003
        error_report("FDT too big ! 0x%x bytes (max is 0x%x)",
                     fdt_totalsize(fdt), FDT_MAX_SIZE);
1004 1005 1006
        exit(1);
    }

A
Andrew Jones 已提交
1007
    qemu_fdt_dumpdtb(fdt, fdt_totalsize(fdt));
1008
    cpu_physical_memory_write(fdt_addr, fdt, fdt_totalsize(fdt));
1009

G
Gonglei 已提交
1010
    g_free(bootlist);
1011
    g_free(fdt);
1012 1013 1014 1015 1016 1017 1018
}

static uint64_t translate_kernel_address(void *opaque, uint64_t addr)
{
    return (addr & 0x0fffffff) + KERNEL_LOAD_ADDR;
}

1019
static void emulate_spapr_hypercall(PowerPCCPU *cpu)
1020
{
1021 1022
    CPUPPCState *env = &cpu->env;

1023 1024 1025 1026
    if (msr_pr) {
        hcall_dprintf("Hypercall made with MSR[PR]=1\n");
        env->gpr[3] = H_PRIVILEGE;
    } else {
1027
        env->gpr[3] = spapr_hypercall(cpu, env->gpr[3], &env->gpr[4]);
1028
    }
1029 1030
}

1031 1032 1033 1034 1035 1036
#define HPTE(_table, _i)   (void *)(((uint64_t *)(_table)) + ((_i) * 2))
#define HPTE_VALID(_hpte)  (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_VALID)
#define HPTE_DIRTY(_hpte)  (tswap64(*((uint64_t *)(_hpte))) & HPTE64_V_HPTE_DIRTY)
#define CLEAN_HPTE(_hpte)  ((*(uint64_t *)(_hpte)) &= tswap64(~HPTE64_V_HPTE_DIRTY))
#define DIRTY_HPTE(_hpte)  ((*(uint64_t *)(_hpte)) |= tswap64(HPTE64_V_HPTE_DIRTY))

1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
/*
 * Get the fd to access the kernel htab, re-opening it if necessary
 */
static int get_htab_fd(sPAPRMachineState *spapr)
{
    if (spapr->htab_fd >= 0) {
        return spapr->htab_fd;
    }

    spapr->htab_fd = kvmppc_get_htab_fd(false);
    if (spapr->htab_fd < 0) {
        error_report("Unable to open fd for reading hash table from KVM: %s",
                     strerror(errno));
    }

    return spapr->htab_fd;
}

static void close_htab_fd(sPAPRMachineState *spapr)
{
    if (spapr->htab_fd >= 0) {
        close(spapr->htab_fd);
    }
    spapr->htab_fd = -1;
}

1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
static int spapr_hpt_shift_for_ramsize(uint64_t ramsize)
{
    int shift;

    /* We aim for a hash table of size 1/128 the size of RAM (rounded
     * up).  The PAPR recommendation is actually 1/64 of RAM size, but
     * that's much more than is needed for Linux guests */
    shift = ctz64(pow2ceil(ramsize)) - 7;
    shift = MAX(shift, 18); /* Minimum architected size */
    shift = MIN(shift, 46); /* Maximum architected size */
    return shift;
}

1076 1077
static void spapr_reallocate_hpt(sPAPRMachineState *spapr, int shift,
                                 Error **errp)
1078
{
1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100
    long rc;

    /* Clean up any HPT info from a previous boot */
    g_free(spapr->htab);
    spapr->htab = NULL;
    spapr->htab_shift = 0;
    close_htab_fd(spapr);

    rc = kvmppc_reset_htab(shift);
    if (rc < 0) {
        /* kernel-side HPT needed, but couldn't allocate one */
        error_setg_errno(errp, errno,
                         "Failed to allocate KVM HPT of order %d (try smaller maxmem?)",
                         shift);
        /* This is almost certainly fatal, but if the caller really
         * wants to carry on with shift == 0, it's welcome to try */
    } else if (rc > 0) {
        /* kernel-side HPT allocated */
        if (rc != shift) {
            error_setg(errp,
                       "Requested order %d HPT, but kernel allocated order %ld (try smaller maxmem?)",
                       shift, rc);
1101 1102
        }

1103
        spapr->htab_shift = shift;
1104
        spapr->htab = NULL;
1105
    } else {
1106 1107 1108
        /* kernel-side HPT not needed, allocate in userspace instead */
        size_t size = 1ULL << shift;
        int i;
1109

1110 1111 1112 1113 1114
        spapr->htab = qemu_memalign(size, size);
        if (!spapr->htab) {
            error_setg_errno(errp, errno,
                             "Could not allocate HPT of order %d", shift);
            return;
1115 1116
        }

1117 1118
        memset(spapr->htab, 0, size);
        spapr->htab_shift = shift;
1119

1120 1121
        for (i = 0; i < size / HASH_PTE_SIZE_64; i++) {
            DIRTY_HPTE(HPTE(spapr->htab, i));
1122
        }
1123
    }
1124 1125
}

1126
static void find_unknown_sysbus_device(SysBusDevice *sbdev, void *opaque)
1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140
{
    bool matched = false;

    if (object_dynamic_cast(OBJECT(sbdev), TYPE_SPAPR_PCI_HOST_BRIDGE)) {
        matched = true;
    }

    if (!matched) {
        error_report("Device %s is not supported by this machine yet.",
                     qdev_fw_name(DEVICE(sbdev)));
        exit(1);
    }
}

1141
static void ppc_spapr_reset(void)
1142
{
1143 1144
    MachineState *machine = MACHINE(qdev_get_machine());
    sPAPRMachineState *spapr = SPAPR_MACHINE(machine);
1145
    PowerPCCPU *first_ppc_cpu;
1146
    uint32_t rtas_limit;
1147

1148 1149 1150
    /* Check for unknown sysbus devices */
    foreach_dynamic_sysbus_device(find_unknown_sysbus_device, NULL);

1151 1152 1153 1154 1155 1156 1157 1158 1159 1160
    /* Allocate and/or reset the hash page table */
    spapr_reallocate_hpt(spapr,
                         spapr_hpt_shift_for_ramsize(machine->maxram_size),
                         &error_fatal);

    /* Update the RMA size if necessary */
    if (spapr->vrma_adjust) {
        spapr->rma_size = kvmppc_rma_size(spapr_node0_size(),
                                          spapr->htab_shift);
    }
1161

1162
    qemu_devices_reset();
1163

1164 1165 1166 1167 1168 1169 1170 1171 1172
    /*
     * We place the device tree and RTAS just below either the top of the RMA,
     * or just below 2GB, whichever is lowere, so that it can be
     * processed with 32-bit real mode code if necessary
     */
    rtas_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR);
    spapr->rtas_addr = rtas_limit - RTAS_MAX_SIZE;
    spapr->fdt_addr = spapr->rtas_addr - FDT_MAX_SIZE;

1173 1174 1175 1176
    /* Load the fdt */
    spapr_finalize_fdt(spapr, spapr->fdt_addr, spapr->rtas_addr,
                       spapr->rtas_size);

1177 1178 1179 1180
    /* Copy RTAS over */
    cpu_physical_memory_write(spapr->rtas_addr, spapr->rtas_blob,
                              spapr->rtas_size);

1181
    /* Set up the entry state */
1182 1183 1184 1185
    first_ppc_cpu = POWERPC_CPU(first_cpu);
    first_ppc_cpu->env.gpr[3] = spapr->fdt_addr;
    first_ppc_cpu->env.gpr[5] = 0;
    first_cpu->halted = 0;
1186
    first_ppc_cpu->env.nip = SPAPR_ENTRY_POINT;
1187 1188 1189

}

1190
static void spapr_create_nvram(sPAPRMachineState *spapr)
D
David Gibson 已提交
1191
{
1192
    DeviceState *dev = qdev_create(&spapr->vio_bus->bus, "spapr-nvram");
P
Paolo Bonzini 已提交
1193
    DriveInfo *dinfo = drive_get(IF_PFLASH, 0, 0);
D
David Gibson 已提交
1194

P
Paolo Bonzini 已提交
1195
    if (dinfo) {
1196 1197
        qdev_prop_set_drive(dev, "drive", blk_by_legacy_dinfo(dinfo),
                            &error_fatal);
D
David Gibson 已提交
1198 1199 1200 1201 1202 1203 1204
    }

    qdev_init_nofail(dev);

    spapr->nvram = (struct sPAPRNVRAM *)dev;
}

1205
static void spapr_rtc_create(sPAPRMachineState *spapr)
1206 1207 1208 1209 1210
{
    DeviceState *dev = qdev_create(NULL, TYPE_SPAPR_RTC);

    qdev_init_nofail(dev);
    spapr->rtc = dev;
D
David Gibson 已提交
1211 1212 1213

    object_property_add_alias(qdev_get_machine(), "rtc-time",
                              OBJECT(spapr->rtc), "date", NULL);
1214 1215
}

1216
/* Returns whether we want to use VGA or not */
1217
static bool spapr_vga_init(PCIBus *pci_bus, Error **errp)
1218
{
1219 1220
    switch (vga_interface_type) {
    case VGA_NONE:
1221 1222 1223
        return false;
    case VGA_DEVICE:
        return true;
1224
    case VGA_STD:
1225
    case VGA_VIRTIO:
1226
        return pci_vga_init(pci_bus) != NULL;
1227
    default:
1228 1229 1230
        error_setg(errp,
                   "Unsupported VGA mode, only -vga std or -vga virtio is supported");
        return false;
1231 1232 1233
    }
}

1234 1235
static int spapr_post_load(void *opaque, int version_id)
{
1236
    sPAPRMachineState *spapr = (sPAPRMachineState *)opaque;
1237 1238
    int err = 0;

S
Stefan Weil 已提交
1239
    /* In earlier versions, there was no separate qdev for the PAPR
1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254
     * RTC, so the RTC offset was stored directly in sPAPREnvironment.
     * So when migrating from those versions, poke the incoming offset
     * value into the RTC device */
    if (version_id < 3) {
        err = spapr_rtc_import_offset(spapr->rtc, spapr->rtc_offset);
    }

    return err;
}

static bool version_before_3(void *opaque, int version_id)
{
    return version_id < 3;
}

1255 1256
static const VMStateDescription vmstate_spapr = {
    .name = "spapr",
1257
    .version_id = 3,
1258
    .minimum_version_id = 1,
1259
    .post_load = spapr_post_load,
1260
    .fields = (VMStateField[]) {
1261 1262
        /* used to be @next_irq */
        VMSTATE_UNUSED_BUFFER(version_before_3, 0, 4),
1263 1264

        /* RTC offset */
1265
        VMSTATE_UINT64_TEST(rtc_offset, sPAPRMachineState, version_before_3),
1266

1267
        VMSTATE_PPC_TIMEBASE_V(tb, sPAPRMachineState, 2),
1268 1269 1270 1271 1272 1273
        VMSTATE_END_OF_LIST()
    },
};

static int htab_save_setup(QEMUFile *f, void *opaque)
{
1274
    sPAPRMachineState *spapr = opaque;
1275 1276 1277 1278

    /* "Iteration" header */
    qemu_put_be32(f, spapr->htab_shift);

1279 1280 1281 1282 1283 1284 1285 1286
    if (spapr->htab) {
        spapr->htab_save_index = 0;
        spapr->htab_first_pass = true;
    } else {
        assert(kvm_enabled());
    }


1287 1288 1289
    return 0;
}

1290
static void htab_save_first_pass(QEMUFile *f, sPAPRMachineState *spapr,
1291 1292
                                 int64_t max_ns)
{
1293
    bool has_timeout = max_ns != -1;
1294 1295
    int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64;
    int index = spapr->htab_save_index;
1296
    int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311

    assert(spapr->htab_first_pass);

    do {
        int chunkstart;

        /* Consume invalid HPTEs */
        while ((index < htabslots)
               && !HPTE_VALID(HPTE(spapr->htab, index))) {
            index++;
            CLEAN_HPTE(HPTE(spapr->htab, index));
        }

        /* Consume valid HPTEs */
        chunkstart = index;
1312
        while ((index < htabslots) && (index - chunkstart < USHRT_MAX)
1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
               && HPTE_VALID(HPTE(spapr->htab, index))) {
            index++;
            CLEAN_HPTE(HPTE(spapr->htab, index));
        }

        if (index > chunkstart) {
            int n_valid = index - chunkstart;

            qemu_put_be32(f, chunkstart);
            qemu_put_be16(f, n_valid);
            qemu_put_be16(f, 0);
            qemu_put_buffer(f, HPTE(spapr->htab, chunkstart),
                            HASH_PTE_SIZE_64 * n_valid);

1327 1328
            if (has_timeout &&
                (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) {
1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341
                break;
            }
        }
    } while ((index < htabslots) && !qemu_file_rate_limit(f));

    if (index >= htabslots) {
        assert(index == htabslots);
        index = 0;
        spapr->htab_first_pass = false;
    }
    spapr->htab_save_index = index;
}

1342
static int htab_save_later_pass(QEMUFile *f, sPAPRMachineState *spapr,
1343
                                int64_t max_ns)
1344 1345 1346 1347 1348
{
    bool final = max_ns < 0;
    int htabslots = HTAB_SIZE(spapr) / HASH_PTE_SIZE_64;
    int examined = 0, sent = 0;
    int index = spapr->htab_save_index;
1349
    int64_t starttime = qemu_clock_get_ns(QEMU_CLOCK_REALTIME);
1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364

    assert(!spapr->htab_first_pass);

    do {
        int chunkstart, invalidstart;

        /* Consume non-dirty HPTEs */
        while ((index < htabslots)
               && !HPTE_DIRTY(HPTE(spapr->htab, index))) {
            index++;
            examined++;
        }

        chunkstart = index;
        /* Consume valid dirty HPTEs */
1365
        while ((index < htabslots) && (index - chunkstart < USHRT_MAX)
1366 1367 1368 1369 1370 1371 1372 1373 1374
               && HPTE_DIRTY(HPTE(spapr->htab, index))
               && HPTE_VALID(HPTE(spapr->htab, index))) {
            CLEAN_HPTE(HPTE(spapr->htab, index));
            index++;
            examined++;
        }

        invalidstart = index;
        /* Consume invalid dirty HPTEs */
1375
        while ((index < htabslots) && (index - invalidstart < USHRT_MAX)
1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393
               && HPTE_DIRTY(HPTE(spapr->htab, index))
               && !HPTE_VALID(HPTE(spapr->htab, index))) {
            CLEAN_HPTE(HPTE(spapr->htab, index));
            index++;
            examined++;
        }

        if (index > chunkstart) {
            int n_valid = invalidstart - chunkstart;
            int n_invalid = index - invalidstart;

            qemu_put_be32(f, chunkstart);
            qemu_put_be16(f, n_valid);
            qemu_put_be16(f, n_invalid);
            qemu_put_buffer(f, HPTE(spapr->htab, chunkstart),
                            HASH_PTE_SIZE_64 * n_valid);
            sent += index - chunkstart;

1394
            if (!final && (qemu_clock_get_ns(QEMU_CLOCK_REALTIME) - starttime) > max_ns) {
1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415
                break;
            }
        }

        if (examined >= htabslots) {
            break;
        }

        if (index >= htabslots) {
            assert(index == htabslots);
            index = 0;
        }
    } while ((examined < htabslots) && (!qemu_file_rate_limit(f) || final));

    if (index >= htabslots) {
        assert(index == htabslots);
        index = 0;
    }

    spapr->htab_save_index = index;

1416
    return (examined >= htabslots) && (sent == 0) ? 1 : 0;
1417 1418
}

1419 1420 1421
#define MAX_ITERATION_NS    5000000 /* 5 ms */
#define MAX_KVM_BUF_SIZE    2048

1422 1423
static int htab_save_iterate(QEMUFile *f, void *opaque)
{
1424
    sPAPRMachineState *spapr = opaque;
1425
    int fd;
1426
    int rc = 0;
1427 1428 1429 1430

    /* Iteration header */
    qemu_put_be32(f, 0);

1431 1432 1433
    if (!spapr->htab) {
        assert(kvm_enabled());

1434 1435 1436
        fd = get_htab_fd(spapr);
        if (fd < 0) {
            return fd;
1437 1438
        }

1439
        rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, MAX_ITERATION_NS);
1440 1441 1442 1443
        if (rc < 0) {
            return rc;
        }
    } else  if (spapr->htab_first_pass) {
1444 1445
        htab_save_first_pass(f, spapr, MAX_ITERATION_NS);
    } else {
1446
        rc = htab_save_later_pass(f, spapr, MAX_ITERATION_NS);
1447 1448 1449 1450 1451 1452 1453
    }

    /* End marker */
    qemu_put_be32(f, 0);
    qemu_put_be16(f, 0);
    qemu_put_be16(f, 0);

1454
    return rc;
1455 1456 1457 1458
}

static int htab_save_complete(QEMUFile *f, void *opaque)
{
1459
    sPAPRMachineState *spapr = opaque;
1460
    int fd;
1461 1462 1463 1464

    /* Iteration header */
    qemu_put_be32(f, 0);

1465 1466 1467 1468 1469
    if (!spapr->htab) {
        int rc;

        assert(kvm_enabled());

1470 1471 1472
        fd = get_htab_fd(spapr);
        if (fd < 0) {
            return fd;
1473 1474
        }

1475
        rc = kvmppc_save_htab(f, fd, MAX_KVM_BUF_SIZE, -1);
1476 1477 1478 1479
        if (rc < 0) {
            return rc;
        }
    } else {
1480 1481 1482
        if (spapr->htab_first_pass) {
            htab_save_first_pass(f, spapr, -1);
        }
1483 1484
        htab_save_later_pass(f, spapr, -1);
    }
1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495

    /* End marker */
    qemu_put_be32(f, 0);
    qemu_put_be16(f, 0);
    qemu_put_be16(f, 0);

    return 0;
}

static int htab_load(QEMUFile *f, void *opaque, int version_id)
{
1496
    sPAPRMachineState *spapr = opaque;
1497
    uint32_t section_hdr;
1498
    int fd = -1;
1499 1500

    if (version_id < 1 || version_id > 1) {
1501
        error_report("htab_load() bad version");
1502 1503 1504 1505 1506 1507
        return -EINVAL;
    }

    section_hdr = qemu_get_be32(f);

    if (section_hdr) {
1508
        Error *local_err = NULL;
1509 1510 1511 1512 1513

        /* First section gives the htab size */
        spapr_reallocate_hpt(spapr, section_hdr, &local_err);
        if (local_err) {
            error_report_err(local_err);
1514 1515 1516 1517 1518
            return -EINVAL;
        }
        return 0;
    }

1519 1520 1521 1522 1523
    if (!spapr->htab) {
        assert(kvm_enabled());

        fd = kvmppc_get_htab_fd(true);
        if (fd < 0) {
1524 1525
            error_report("Unable to open fd to restore KVM hash table: %s",
                         strerror(errno));
1526 1527 1528
        }
    }

1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541
    while (true) {
        uint32_t index;
        uint16_t n_valid, n_invalid;

        index = qemu_get_be32(f);
        n_valid = qemu_get_be16(f);
        n_invalid = qemu_get_be16(f);

        if ((index == 0) && (n_valid == 0) && (n_invalid == 0)) {
            /* End of Stream */
            break;
        }

1542
        if ((index + n_valid + n_invalid) >
1543 1544
            (HTAB_SIZE(spapr) / HASH_PTE_SIZE_64)) {
            /* Bad index in stream */
1545 1546 1547
            error_report(
                "htab_load() bad index %d (%hd+%hd entries) in htab stream (htab_shift=%d)",
                index, n_valid, n_invalid, spapr->htab_shift);
1548 1549 1550
            return -EINVAL;
        }

1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568
        if (spapr->htab) {
            if (n_valid) {
                qemu_get_buffer(f, HPTE(spapr->htab, index),
                                HASH_PTE_SIZE_64 * n_valid);
            }
            if (n_invalid) {
                memset(HPTE(spapr->htab, index + n_valid), 0,
                       HASH_PTE_SIZE_64 * n_invalid);
            }
        } else {
            int rc;

            assert(fd >= 0);

            rc = kvmppc_load_htab_chunk(f, fd, index, n_valid, n_invalid);
            if (rc < 0) {
                return rc;
            }
1569 1570 1571
        }
    }

1572 1573 1574 1575 1576
    if (!spapr->htab) {
        assert(fd >= 0);
        close(fd);
    }

1577 1578 1579
    return 0;
}

1580 1581 1582 1583 1584 1585 1586
static void htab_cleanup(void *opaque)
{
    sPAPRMachineState *spapr = opaque;

    close_htab_fd(spapr);
}

1587 1588 1589
static SaveVMHandlers savevm_htab_handlers = {
    .save_live_setup = htab_save_setup,
    .save_live_iterate = htab_save_iterate,
1590
    .save_live_complete_precopy = htab_save_complete,
1591
    .cleanup = htab_cleanup,
1592 1593 1594
    .load_state = htab_load,
};

1595 1596 1597 1598 1599 1600 1601
static void spapr_boot_set(void *opaque, const char *boot_device,
                           Error **errp)
{
    MachineState *machine = MACHINE(qdev_get_machine());
    machine->boot_order = g_strdup(boot_device);
}

D
David Gibson 已提交
1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623
/*
 * Reset routine for LMB DR devices.
 *
 * Unlike PCI DR devices, LMB DR devices explicitly register this reset
 * routine. Reset for PCI DR devices will be handled by PHB reset routine
 * when it walks all its children devices. LMB devices reset occurs
 * as part of spapr_ppc_reset().
 */
static void spapr_drc_reset(void *opaque)
{
    sPAPRDRConnector *drc = opaque;
    DeviceState *d = DEVICE(drc);

    if (d) {
        device_reset(d);
    }
}

static void spapr_create_lmb_dr_connectors(sPAPRMachineState *spapr)
{
    MachineState *machine = MACHINE(spapr);
    uint64_t lmb_size = SPAPR_MEMORY_BLOCK_SIZE;
1624
    uint32_t nr_lmbs = (machine->maxram_size - machine->ram_size)/lmb_size;
D
David Gibson 已提交
1625 1626 1627 1628 1629 1630
    int i;

    for (i = 0; i < nr_lmbs; i++) {
        sPAPRDRConnector *drc;
        uint64_t addr;

1631
        addr = i * lmb_size + spapr->hotplug_memory.base;
D
David Gibson 已提交
1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642
        drc = spapr_dr_connector_new(OBJECT(spapr), SPAPR_DR_CONNECTOR_TYPE_LMB,
                                     addr/lmb_size);
        qemu_register_reset(spapr_drc_reset, drc);
    }
}

/*
 * If RAM size, maxmem size and individual node mem sizes aren't aligned
 * to SPAPR_MEMORY_BLOCK_SIZE(256MB), then refuse to start the guest
 * since we can't support such unaligned sizes with DRCONF_MEMORY.
 */
1643
static void spapr_validate_node_memory(MachineState *machine, Error **errp)
D
David Gibson 已提交
1644 1645 1646
{
    int i;

1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660
    if (machine->ram_size % SPAPR_MEMORY_BLOCK_SIZE) {
        error_setg(errp, "Memory size 0x" RAM_ADDR_FMT
                   " is not aligned to %llu MiB",
                   machine->ram_size,
                   SPAPR_MEMORY_BLOCK_SIZE / M_BYTE);
        return;
    }

    if (machine->maxram_size % SPAPR_MEMORY_BLOCK_SIZE) {
        error_setg(errp, "Maximum memory size 0x" RAM_ADDR_FMT
                   " is not aligned to %llu MiB",
                   machine->ram_size,
                   SPAPR_MEMORY_BLOCK_SIZE / M_BYTE);
        return;
D
David Gibson 已提交
1661 1662 1663 1664
    }

    for (i = 0; i < nb_numa_nodes; i++) {
        if (numa_info[i].node_mem % SPAPR_MEMORY_BLOCK_SIZE) {
1665 1666 1667 1668 1669 1670
            error_setg(errp,
                       "Node %d memory size 0x%" PRIx64
                       " is not aligned to %llu MiB",
                       i, numa_info[i].node_mem,
                       SPAPR_MEMORY_BLOCK_SIZE / M_BYTE);
            return;
D
David Gibson 已提交
1671 1672 1673 1674
        }
    }
}

1675
/* pSeries LPAR / sPAPR hardware init */
1676
static void ppc_spapr_init(MachineState *machine)
1677
{
1678
    sPAPRMachineState *spapr = SPAPR_MACHINE(machine);
1679
    MachineClass *mc = MACHINE_GET_CLASS(machine);
D
David Gibson 已提交
1680
    sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(machine);
1681 1682 1683
    const char *kernel_filename = machine->kernel_filename;
    const char *kernel_cmdline = machine->kernel_cmdline;
    const char *initrd_filename = machine->initrd_filename;
1684
    PCIHostState *phb;
1685
    int i;
A
Avi Kivity 已提交
1686 1687
    MemoryRegion *sysmem = get_system_memory();
    MemoryRegion *ram = g_new(MemoryRegion, 1);
1688 1689
    MemoryRegion *rma_region;
    void *rma = NULL;
A
Avi Kivity 已提交
1690
    hwaddr rma_alloc_size;
1691
    hwaddr node0_size = spapr_node0_size();
1692 1693
    uint32_t initrd_base = 0;
    long kernel_size = 0, initrd_size = 0;
1694
    long load_limit, fw_size;
1695
    bool kernel_le = false;
1696
    char *filename;
1697 1698 1699 1700
    int smt = kvmppc_smt_threads();
    int spapr_cores = smp_cpus / smp_threads;
    int spapr_max_cores = max_cpus / smp_threads;

1701
    if (mc->query_hotpluggable_cpus) {
1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712
        if (smp_cpus % smp_threads) {
            error_report("smp_cpus (%u) must be multiple of threads (%u)",
                         smp_cpus, smp_threads);
            exit(1);
        }
        if (max_cpus % smp_threads) {
            error_report("max_cpus (%u) must be multiple of threads (%u)",
                         max_cpus, smp_threads);
            exit(1);
        }
    }
1713

1714
    msi_nonbroken = true;
1715

1716 1717
    QLIST_INIT(&spapr->phbs);

1718 1719
    cpu_ppc_hypercall = emulate_spapr_hypercall;

1720
    /* Allocate RMA if necessary */
1721
    rma_alloc_size = kvmppc_alloc_rma(&rma);
1722 1723

    if (rma_alloc_size == -1) {
1724
        error_report("Unable to create RMA");
1725 1726
        exit(1);
    }
1727

1728
    if (rma_alloc_size && (rma_alloc_size < node0_size)) {
1729
        spapr->rma_size = rma_alloc_size;
1730
    } else {
1731
        spapr->rma_size = node0_size;
1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745

        /* With KVM, we don't actually know whether KVM supports an
         * unbounded RMA (PR KVM) or is limited by the hash table size
         * (HV KVM using VRMA), so we always assume the latter
         *
         * In that case, we also limit the initial allocations for RTAS
         * etc... to 256M since we have no way to know what the VRMA size
         * is going to be as it depends on the size of the hash table
         * isn't determined yet.
         */
        if (kvm_enabled()) {
            spapr->vrma_adjust = 1;
            spapr->rma_size = MIN(spapr->rma_size, 0x10000000);
        }
1746 1747 1748 1749 1750 1751 1752

        /* Actually we don't support unbounded RMA anymore since we
         * added proper emulation of HV mode. The max we can get is
         * 16G which also happens to be what we configure for PAPR
         * mode so make sure we don't do anything bigger than that
         */
        spapr->rma_size = MIN(spapr->rma_size, 0x400000000ull);
1753 1754
    }

1755
    if (spapr->rma_size > node0_size) {
1756 1757
        error_report("Numa node 0 has to span the RMA (%#08"HWADDR_PRIx")",
                     spapr->rma_size);
1758 1759 1760
        exit(1);
    }

1761 1762
    /* Setup a load limit for the ramdisk leaving room for SLOF and FDT */
    load_limit = MIN(spapr->rma_size, RTAS_MAX_ADDR) - FW_OVERHEAD;
1763

1764
    /* Set up Interrupt Controller before we create the VCPUs */
1765 1766 1767
    spapr->xics = xics_system_init(machine,
                                   DIV_ROUND_UP(max_cpus * smt, smp_threads),
                                   XICS_IRQS_SPAPR, &error_fatal);
1768

D
David Gibson 已提交
1769
    if (smc->dr_lmb_enabled) {
1770
        spapr_validate_node_memory(machine, &error_fatal);
D
David Gibson 已提交
1771 1772
    }

1773
    /* init CPUs */
1774 1775
    if (machine->cpu_model == NULL) {
        machine->cpu_model = kvm_enabled() ? "host" : "POWER7";
1776
    }
1777

G
Greg Kurz 已提交
1778 1779
    ppc_cpu_parse_features(machine->cpu_model);

1780
    if (mc->query_hotpluggable_cpus) {
1781 1782
        char *type = spapr_get_cpu_core_type(machine->cpu_model);

1783
        if (type == NULL) {
1784 1785 1786 1787
            error_report("Unable to find sPAPR CPU Core definition");
            exit(1);
        }

1788
        spapr->cores = g_new0(Object *, spapr_max_cores);
B
Bharata B Rao 已提交
1789
        for (i = 0; i < spapr_max_cores; i++) {
1790
            int core_id = i * smp_threads;
B
Bharata B Rao 已提交
1791 1792
            sPAPRDRConnector *drc =
                spapr_dr_connector_new(OBJECT(spapr),
1793 1794
                                       SPAPR_DR_CONNECTOR_TYPE_CPU,
                                       (core_id / smp_threads) * smt);
B
Bharata B Rao 已提交
1795 1796 1797 1798

            qemu_register_reset(spapr_drc_reset, drc);

            if (i < spapr_cores) {
1799
                Object *core  = object_new(type);
B
Bharata B Rao 已提交
1800 1801
                object_property_set_int(core, smp_threads, "nr-threads",
                                        &error_fatal);
1802
                object_property_set_int(core, core_id, CPU_CORE_PROP_CORE_ID,
B
Bharata B Rao 已提交
1803 1804
                                        &error_fatal);
                object_property_set_bool(core, true, "realized", &error_fatal);
1805
            }
1806
        }
1807 1808 1809 1810 1811 1812 1813 1814 1815 1816
        g_free(type);
    } else {
        for (i = 0; i < smp_cpus; i++) {
            PowerPCCPU *cpu = cpu_ppc_init(machine->cpu_model);
            if (cpu == NULL) {
                error_report("Unable to find PowerPC CPU definition");
                exit(1);
            }
            spapr_cpu_init(spapr, cpu, &error_fatal);
       }
1817 1818
    }

1819 1820 1821
    if (kvm_enabled()) {
        /* Enable H_LOGICAL_CI_* so SLOF can talk to in-kernel devices */
        kvmppc_enable_logical_ci_hcalls();
1822
        kvmppc_enable_set_mode_hcall();
1823 1824 1825

        /* H_CLEAR_MOD/_REF are mandatory in PAPR, but off by default */
        kvmppc_enable_clear_ref_mod_hcalls();
1826 1827
    }

1828
    /* allocate RAM */
1829
    memory_region_allocate_system_memory(ram, NULL, "ppc_spapr.ram",
1830
                                         machine->ram_size);
1831
    memory_region_add_subregion(sysmem, 0, ram);
1832

1833 1834 1835 1836 1837 1838 1839 1840
    if (rma_alloc_size && rma) {
        rma_region = g_new(MemoryRegion, 1);
        memory_region_init_ram_ptr(rma_region, NULL, "ppc_spapr.rma",
                                   rma_alloc_size, rma);
        vmstate_register_ram_global(rma_region);
        memory_region_add_subregion(sysmem, 0, rma_region);
    }

1841 1842 1843
    /* initialize hotplug memory address space */
    if (machine->ram_size < machine->maxram_size) {
        ram_addr_t hotplug_mem_size = machine->maxram_size - machine->ram_size;
1844 1845 1846 1847 1848 1849 1850
        /*
         * Limit the number of hotpluggable memory slots to half the number
         * slots that KVM supports, leaving the other half for PCI and other
         * devices. However ensure that number of slots doesn't drop below 32.
         */
        int max_memslots = kvm_enabled() ? kvm_get_max_memslots() / 2 :
                           SPAPR_MAX_RAM_SLOTS;
1851

1852 1853 1854 1855
        if (max_memslots < SPAPR_MAX_RAM_SLOTS) {
            max_memslots = SPAPR_MAX_RAM_SLOTS;
        }
        if (machine->ram_slots > max_memslots) {
1856 1857
            error_report("Specified number of memory slots %"
                         PRIu64" exceeds max supported %d",
1858
                         machine->ram_slots, max_memslots);
1859
            exit(1);
1860 1861 1862 1863 1864 1865 1866 1867 1868 1869
        }

        spapr->hotplug_memory.base = ROUND_UP(machine->ram_size,
                                              SPAPR_HOTPLUG_MEM_ALIGN);
        memory_region_init(&spapr->hotplug_memory.mr, OBJECT(spapr),
                           "hotplug-memory", hotplug_mem_size);
        memory_region_add_subregion(sysmem, spapr->hotplug_memory.base,
                                    &spapr->hotplug_memory.mr);
    }

D
David Gibson 已提交
1870 1871 1872 1873
    if (smc->dr_lmb_enabled) {
        spapr_create_lmb_dr_connectors(spapr);
    }

1874
    filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, "spapr-rtas.bin");
1875
    if (!filename) {
1876
        error_report("Could not find LPAR rtas '%s'", "spapr-rtas.bin");
1877 1878
        exit(1);
    }
1879
    spapr->rtas_size = get_image_size(filename);
1880 1881 1882 1883
    if (spapr->rtas_size < 0) {
        error_report("Could not get size of LPAR rtas '%s'", filename);
        exit(1);
    }
1884 1885
    spapr->rtas_blob = g_malloc(spapr->rtas_size);
    if (load_image_size(filename, spapr->rtas_blob, spapr->rtas_size) < 0) {
1886
        error_report("Could not load LPAR rtas '%s'", filename);
1887 1888
        exit(1);
    }
1889
    if (spapr->rtas_size > RTAS_MAX_SIZE) {
1890 1891
        error_report("RTAS too big ! 0x%zx bytes (max is 0x%x)",
                     (size_t)spapr->rtas_size, RTAS_MAX_SIZE);
1892 1893
        exit(1);
    }
1894
    g_free(filename);
1895

1896 1897 1898
    /* Set up EPOW events infrastructure */
    spapr_events_init(spapr);

1899
    /* Set up the RTC RTAS interfaces */
1900
    spapr_rtc_create(spapr);
1901

1902
    /* Set up VIO bus */
1903 1904
    spapr->vio_bus = spapr_vio_bus_init();

P
Paolo Bonzini 已提交
1905
    for (i = 0; i < MAX_SERIAL_PORTS; i++) {
1906
        if (serial_hds[i]) {
1907
            spapr_vty_create(spapr->vio_bus, serial_hds[i]);
1908 1909
        }
    }
1910

D
David Gibson 已提交
1911 1912 1913
    /* We always have at least the nvram device on VIO */
    spapr_create_nvram(spapr);

1914
    /* Set up PCI */
1915 1916
    spapr_pci_rtas_init();

1917
    phb = spapr_create_phb(spapr, 0);
1918

P
Paolo Bonzini 已提交
1919
    for (i = 0; i < nb_nics; i++) {
1920 1921 1922
        NICInfo *nd = &nd_table[i];

        if (!nd->model) {
1923
            nd->model = g_strdup("ibmveth");
1924 1925 1926
        }

        if (strcmp(nd->model, "ibmveth") == 0) {
1927
            spapr_vlan_create(spapr->vio_bus, nd);
1928
        } else {
1929
            pci_nic_init_nofail(&nd_table[i], phb->bus, nd->model, NULL);
1930 1931 1932
        }
    }

1933
    for (i = 0; i <= drive_get_max_bus(IF_SCSI); i++) {
1934
        spapr_vscsi_create(spapr->vio_bus);
1935 1936
    }

1937
    /* Graphics */
1938
    if (spapr_vga_init(phb->bus, &error_fatal)) {
1939
        spapr->has_graphics = true;
1940
        machine->usb |= defaults_enabled() && !machine->usb_disabled;
1941 1942
    }

1943
    if (machine->usb) {
1944 1945 1946 1947 1948
        if (smc->use_ohci_by_default) {
            pci_create_simple(phb->bus, -1, "pci-ohci");
        } else {
            pci_create_simple(phb->bus, -1, "nec-usb-xhci");
        }
1949

1950
        if (spapr->has_graphics) {
1951 1952 1953 1954
            USBBus *usb_bus = usb_bus_find(-1);

            usb_create_simple(usb_bus, "usb-kbd");
            usb_create_simple(usb_bus, "usb-mouse");
1955 1956 1957
        }
    }

1958
    if (spapr->rma_size < (MIN_RMA_SLOF << 20)) {
1959 1960 1961
        error_report(
            "pSeries SLOF firmware requires >= %ldM guest RMA (Real Mode Area memory)",
            MIN_RMA_SLOF);
1962 1963 1964
        exit(1);
    }

1965 1966 1967 1968
    if (kernel_filename) {
        uint64_t lowaddr = 0;

        kernel_size = load_elf(kernel_filename, translate_kernel_address, NULL,
1969 1970
                               NULL, &lowaddr, NULL, 1, PPC_ELF_MACHINE,
                               0, 0);
1971
        if (kernel_size == ELF_LOAD_WRONG_ENDIAN) {
1972 1973
            kernel_size = load_elf(kernel_filename,
                                   translate_kernel_address, NULL,
1974 1975
                                   NULL, &lowaddr, NULL, 0, PPC_ELF_MACHINE,
                                   0, 0);
1976 1977
            kernel_le = kernel_size > 0;
        }
1978
        if (kernel_size < 0) {
1979 1980
            error_report("error loading %s: %s",
                         kernel_filename, load_elf_strerror(kernel_size));
1981 1982 1983 1984 1985
            exit(1);
        }

        /* load initrd */
        if (initrd_filename) {
1986 1987 1988 1989
            /* Try to locate the initrd in the gap between the kernel
             * and the firmware. Add a bit of space just in case
             */
            initrd_base = (KERNEL_LOAD_ADDR + kernel_size + 0x1ffff) & ~0xffff;
1990
            initrd_size = load_image_targphys(initrd_filename, initrd_base,
1991
                                              load_limit - initrd_base);
1992
            if (initrd_size < 0) {
1993 1994
                error_report("could not load initial ram disk '%s'",
                             initrd_filename);
1995 1996 1997 1998 1999 2000
                exit(1);
            }
        } else {
            initrd_base = 0;
            initrd_size = 0;
        }
2001
    }
2002

2003 2004 2005 2006
    if (bios_name == NULL) {
        bios_name = FW_FILE_NAME;
    }
    filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
2007
    if (!filename) {
2008
        error_report("Could not find LPAR firmware '%s'", bios_name);
2009 2010
        exit(1);
    }
2011
    fw_size = load_image_targphys(filename, 0, FW_MAX_SIZE);
2012 2013
    if (fw_size <= 0) {
        error_report("Could not load LPAR firmware '%s'", filename);
2014 2015 2016 2017
        exit(1);
    }
    g_free(filename);

2018 2019 2020
    /* FIXME: Should register things through the MachineState's qdev
     * interface, this is a legacy from the sPAPREnvironment structure
     * which predated MachineState but had a similar function */
2021 2022 2023 2024
    vmstate_register(NULL, 0, &vmstate_spapr, spapr);
    register_savevm_live(NULL, "spapr/htab", -1, 1,
                         &savevm_htab_handlers, spapr);

2025
    /* Prepare the device tree */
2026
    spapr->fdt_skel = spapr_create_fdt_skel(initrd_base, initrd_size,
2027
                                            kernel_size, kernel_le,
2028 2029
                                            kernel_cmdline,
                                            spapr->check_exception_irq);
2030
    assert(spapr->fdt_skel != NULL);
2031

2032 2033 2034 2035
    /* used by RTAS */
    QTAILQ_INIT(&spapr->ccs_list);
    qemu_register_reset(spapr_ccs_reset_hook, spapr);

2036
    qemu_register_boot_set(spapr_boot_set, spapr);
2037 2038
}

2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056
static int spapr_kvm_type(const char *vm_type)
{
    if (!vm_type) {
        return 0;
    }

    if (!strcmp(vm_type, "HV")) {
        return 1;
    }

    if (!strcmp(vm_type, "PR")) {
        return 2;
    }

    error_report("Unknown kvm-type specified '%s'", vm_type);
    exit(1);
}

2057
/*
2058
 * Implementation of an interface to adjust firmware path
2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113
 * for the bootindex property handling.
 */
static char *spapr_get_fw_dev_path(FWPathProvider *p, BusState *bus,
                                   DeviceState *dev)
{
#define CAST(type, obj, name) \
    ((type *)object_dynamic_cast(OBJECT(obj), (name)))
    SCSIDevice *d = CAST(SCSIDevice,  dev, TYPE_SCSI_DEVICE);
    sPAPRPHBState *phb = CAST(sPAPRPHBState, dev, TYPE_SPAPR_PCI_HOST_BRIDGE);

    if (d) {
        void *spapr = CAST(void, bus->parent, "spapr-vscsi");
        VirtIOSCSI *virtio = CAST(VirtIOSCSI, bus->parent, TYPE_VIRTIO_SCSI);
        USBDevice *usb = CAST(USBDevice, bus->parent, TYPE_USB_DEVICE);

        if (spapr) {
            /*
             * Replace "channel@0/disk@0,0" with "disk@8000000000000000":
             * We use SRP luns of the form 8000 | (bus << 8) | (id << 5) | lun
             * in the top 16 bits of the 64-bit LUN
             */
            unsigned id = 0x8000 | (d->id << 8) | d->lun;
            return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev),
                                   (uint64_t)id << 48);
        } else if (virtio) {
            /*
             * We use SRP luns of the form 01000000 | (target << 8) | lun
             * in the top 32 bits of the 64-bit LUN
             * Note: the quote above is from SLOF and it is wrong,
             * the actual binding is:
             * swap 0100 or 10 << or 20 << ( target lun-id -- srplun )
             */
            unsigned id = 0x1000000 | (d->id << 16) | d->lun;
            return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev),
                                   (uint64_t)id << 32);
        } else if (usb) {
            /*
             * We use SRP luns of the form 01000000 | (usb-port << 16) | lun
             * in the top 32 bits of the 64-bit LUN
             */
            unsigned usb_port = atoi(usb->port->path);
            unsigned id = 0x1000000 | (usb_port << 16) | d->lun;
            return g_strdup_printf("%s@%"PRIX64, qdev_fw_name(dev),
                                   (uint64_t)id << 32);
        }
    }

    if (phb) {
        /* Replace "pci" with "pci@800000020000000" */
        return g_strdup_printf("pci@%"PRIX64, phb->buid);
    }

    return NULL;
}

E
Eduardo Habkost 已提交
2114 2115
static char *spapr_get_kvm_type(Object *obj, Error **errp)
{
2116
    sPAPRMachineState *spapr = SPAPR_MACHINE(obj);
E
Eduardo Habkost 已提交
2117

2118
    return g_strdup(spapr->kvm_type);
E
Eduardo Habkost 已提交
2119 2120 2121 2122
}

static void spapr_set_kvm_type(Object *obj, const char *value, Error **errp)
{
2123
    sPAPRMachineState *spapr = SPAPR_MACHINE(obj);
E
Eduardo Habkost 已提交
2124

2125 2126
    g_free(spapr->kvm_type);
    spapr->kvm_type = g_strdup(value);
E
Eduardo Habkost 已提交
2127 2128 2129 2130
}

static void spapr_machine_initfn(Object *obj)
{
2131 2132 2133
    sPAPRMachineState *spapr = SPAPR_MACHINE(obj);

    spapr->htab_fd = -1;
E
Eduardo Habkost 已提交
2134 2135
    object_property_add_str(obj, "kvm-type",
                            spapr_get_kvm_type, spapr_set_kvm_type, NULL);
2136 2137 2138
    object_property_set_description(obj, "kvm-type",
                                    "Specifies the KVM virtualization mode (HV, PR)",
                                    NULL);
E
Eduardo Habkost 已提交
2139 2140
}

2141 2142 2143 2144 2145 2146 2147
static void spapr_machine_finalizefn(Object *obj)
{
    sPAPRMachineState *spapr = SPAPR_MACHINE(obj);

    g_free(spapr->kvm_type);
}

2148
static void ppc_cpu_do_nmi_on_cpu(CPUState *cs, void *arg)
2149 2150 2151 2152 2153 2154 2155 2156 2157 2158
{
    cpu_synchronize_state(cs);
    ppc_cpu_do_system_reset(cs);
}

static void spapr_nmi(NMIState *n, int cpu_index, Error **errp)
{
    CPUState *cs;

    CPU_FOREACH(cs) {
2159
        async_run_on_cpu(cs, ppc_cpu_do_nmi_on_cpu, NULL);
2160 2161 2162
    }
}

B
Bharata B Rao 已提交
2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184
static void spapr_add_lmbs(DeviceState *dev, uint64_t addr, uint64_t size,
                           uint32_t node, Error **errp)
{
    sPAPRDRConnector *drc;
    sPAPRDRConnectorClass *drck;
    uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE;
    int i, fdt_offset, fdt_size;
    void *fdt;

    for (i = 0; i < nr_lmbs; i++) {
        drc = spapr_dr_connector_by_id(SPAPR_DR_CONNECTOR_TYPE_LMB,
                addr/SPAPR_MEMORY_BLOCK_SIZE);
        g_assert(drc);

        fdt = create_device_tree(&fdt_size);
        fdt_offset = spapr_populate_memory_node(fdt, node, addr,
                                                SPAPR_MEMORY_BLOCK_SIZE);

        drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
        drck->attach(drc, dev, fdt, fdt_offset, !dev->hotplugged, errp);
        addr += SPAPR_MEMORY_BLOCK_SIZE;
    }
2185 2186 2187 2188 2189 2190
    /* send hotplug notification to the
     * guest only in case of hotplugged memory
     */
    if (dev->hotplugged) {
       spapr_hotplug_req_add_by_count(SPAPR_DR_CONNECTOR_TYPE_LMB, nr_lmbs);
    }
B
Bharata B Rao 已提交
2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210
}

static void spapr_memory_plug(HotplugHandler *hotplug_dev, DeviceState *dev,
                              uint32_t node, Error **errp)
{
    Error *local_err = NULL;
    sPAPRMachineState *ms = SPAPR_MACHINE(hotplug_dev);
    PCDIMMDevice *dimm = PC_DIMM(dev);
    PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm);
    MemoryRegion *mr = ddc->get_memory_region(dimm);
    uint64_t align = memory_region_get_alignment(mr);
    uint64_t size = memory_region_size(mr);
    uint64_t addr;

    if (size % SPAPR_MEMORY_BLOCK_SIZE) {
        error_setg(&local_err, "Hotplugged memory size must be a multiple of "
                      "%lld MB", SPAPR_MEMORY_BLOCK_SIZE/M_BYTE);
        goto out;
    }

2211
    pc_dimm_memory_plug(dev, &ms->hotplug_memory, mr, align, &local_err);
B
Bharata B Rao 已提交
2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227
    if (local_err) {
        goto out;
    }

    addr = object_property_get_int(OBJECT(dimm), PC_DIMM_ADDR_PROP, &local_err);
    if (local_err) {
        pc_dimm_memory_unplug(dev, &ms->hotplug_memory, mr);
        goto out;
    }

    spapr_add_lmbs(dev, addr, size, node, &error_abort);

out:
    error_propagate(errp, local_err);
}

B
Bharata B Rao 已提交
2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248
void *spapr_populate_hotplug_cpu_dt(CPUState *cs, int *fdt_offset,
                                    sPAPRMachineState *spapr)
{
    PowerPCCPU *cpu = POWERPC_CPU(cs);
    DeviceClass *dc = DEVICE_GET_CLASS(cs);
    int id = ppc_get_vcpu_dt_id(cpu);
    void *fdt;
    int offset, fdt_size;
    char *nodename;

    fdt = create_device_tree(&fdt_size);
    nodename = g_strdup_printf("%s@%x", dc->fw_name, id);
    offset = fdt_add_subnode(fdt, 0, nodename);

    spapr_populate_cpu_dt(cs, fdt, offset, spapr);
    g_free(nodename);

    *fdt_offset = offset;
    return fdt;
}

B
Bharata B Rao 已提交
2249 2250 2251 2252 2253 2254
static void spapr_machine_device_plug(HotplugHandler *hotplug_dev,
                                      DeviceState *dev, Error **errp)
{
    sPAPRMachineClass *smc = SPAPR_MACHINE_GET_CLASS(qdev_get_machine());

    if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) {
2255
        int node;
B
Bharata B Rao 已提交
2256 2257 2258 2259 2260 2261 2262 2263 2264

        if (!smc->dr_lmb_enabled) {
            error_setg(errp, "Memory hotplug not supported for this machine");
            return;
        }
        node = object_property_get_int(OBJECT(dev), PC_DIMM_NODE_PROP, errp);
        if (*errp) {
            return;
        }
2265 2266 2267 2268
        if (node < 0 || node >= MAX_NODES) {
            error_setg(errp, "Invaild node %d", node);
            return;
        }
B
Bharata B Rao 已提交
2269

2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291
        /*
         * Currently PowerPC kernel doesn't allow hot-adding memory to
         * memory-less node, but instead will silently add the memory
         * to the first node that has some memory. This causes two
         * unexpected behaviours for the user.
         *
         * - Memory gets hotplugged to a different node than what the user
         *   specified.
         * - Since pc-dimm subsystem in QEMU still thinks that memory belongs
         *   to memory-less node, a reboot will set things accordingly
         *   and the previously hotplugged memory now ends in the right node.
         *   This appears as if some memory moved from one node to another.
         *
         * So until kernel starts supporting memory hotplug to memory-less
         * nodes, just prevent such attempts upfront in QEMU.
         */
        if (nb_numa_nodes && !numa_info[node].node_mem) {
            error_setg(errp, "Can't hotplug memory to memory-less node %d",
                       node);
            return;
        }

B
Bharata B Rao 已提交
2292
        spapr_memory_plug(hotplug_dev, dev, node, errp);
B
Bharata B Rao 已提交
2293 2294
    } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) {
        spapr_core_plug(hotplug_dev, dev, errp);
B
Bharata B Rao 已提交
2295 2296 2297 2298 2299 2300
    }
}

static void spapr_machine_device_unplug(HotplugHandler *hotplug_dev,
                                      DeviceState *dev, Error **errp)
{
2301
    MachineClass *mc = MACHINE_GET_CLASS(qdev_get_machine());
B
Bharata B Rao 已提交
2302

B
Bharata B Rao 已提交
2303 2304
    if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM)) {
        error_setg(errp, "Memory hot unplug not supported by sPAPR");
B
Bharata B Rao 已提交
2305
    } else if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) {
2306
        if (!mc->query_hotpluggable_cpus) {
B
Bharata B Rao 已提交
2307 2308 2309 2310
            error_setg(errp, "CPU hot unplug not supported on this machine");
            return;
        }
        spapr_core_unplug(hotplug_dev, dev, errp);
B
Bharata B Rao 已提交
2311 2312 2313
    }
}

2314 2315 2316 2317 2318 2319 2320 2321
static void spapr_machine_device_pre_plug(HotplugHandler *hotplug_dev,
                                          DeviceState *dev, Error **errp)
{
    if (object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) {
        spapr_core_pre_plug(hotplug_dev, dev, errp);
    }
}

2322 2323
static HotplugHandler *spapr_get_hotplug_handler(MachineState *machine,
                                                 DeviceState *dev)
B
Bharata B Rao 已提交
2324
{
2325 2326
    if (object_dynamic_cast(OBJECT(dev), TYPE_PC_DIMM) ||
        object_dynamic_cast(OBJECT(dev), TYPE_SPAPR_CPU_CORE)) {
B
Bharata B Rao 已提交
2327 2328 2329 2330 2331
        return HOTPLUG_HANDLER(machine);
    }
    return NULL;
}

2332 2333 2334 2335 2336 2337 2338
static unsigned spapr_cpu_index_to_socket_id(unsigned cpu_index)
{
    /* Allocate to NUMA nodes on a "socket" basis (not that concept of
     * socket means much for the paravirtualized PAPR platform) */
    return cpu_index / smp_threads / smp_cores;
}

2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352
static HotpluggableCPUList *spapr_query_hotpluggable_cpus(MachineState *machine)
{
    int i;
    HotpluggableCPUList *head = NULL;
    sPAPRMachineState *spapr = SPAPR_MACHINE(machine);
    int spapr_max_cores = max_cpus / smp_threads;

    for (i = 0; i < spapr_max_cores; i++) {
        HotpluggableCPUList *list_item = g_new0(typeof(*list_item), 1);
        HotpluggableCPU *cpu_item = g_new0(typeof(*cpu_item), 1);
        CpuInstanceProperties *cpu_props = g_new0(typeof(*cpu_props), 1);

        cpu_item->type = spapr_get_cpu_core_type(machine->cpu_model);
        cpu_item->vcpus_count = smp_threads;
2353
        cpu_props->has_core_id = true;
2354
        cpu_props->core_id = i * smp_threads;
2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369
        /* TODO: add 'has_node/node' here to describe
           to which node core belongs */

        cpu_item->props = cpu_props;
        if (spapr->cores[i]) {
            cpu_item->has_qom_path = true;
            cpu_item->qom_path = object_get_canonical_path(spapr->cores[i]);
        }
        list_item->value = cpu_item;
        list_item->next = head;
        head = list_item;
    }
    return head;
}

2370 2371 2372
static void spapr_machine_class_init(ObjectClass *oc, void *data)
{
    MachineClass *mc = MACHINE_CLASS(oc);
D
David Gibson 已提交
2373
    sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc);
2374
    FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc);
2375
    NMIClass *nc = NMI_CLASS(oc);
B
Bharata B Rao 已提交
2376
    HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc);
2377

2378
    mc->desc = "pSeries Logical Partition (PAPR compliant)";
2379 2380 2381 2382 2383 2384

    /*
     * We set up the default / latest behaviour here.  The class_init
     * functions for the specific versioned machine types can override
     * these details for backwards compatibility
     */
2385 2386 2387
    mc->init = ppc_spapr_init;
    mc->reset = ppc_spapr_reset;
    mc->block_default_type = IF_SCSI;
2388
    mc->max_cpus = MAX_CPUMASK_BITS;
2389
    mc->no_parallel = 1;
2390
    mc->default_boot_order = "";
2391
    mc->default_ram_size = 512 * M_BYTE;
2392
    mc->kvm_type = spapr_kvm_type;
2393
    mc->has_dynamic_sysbus = true;
2394
    mc->pci_allow_0_address = true;
2395
    mc->get_hotplug_handler = spapr_get_hotplug_handler;
2396
    hc->pre_plug = spapr_machine_device_pre_plug;
B
Bharata B Rao 已提交
2397 2398
    hc->plug = spapr_machine_device_plug;
    hc->unplug = spapr_machine_device_unplug;
2399
    mc->cpu_index_to_socket_id = spapr_cpu_index_to_socket_id;
2400

2401
    smc->dr_lmb_enabled = true;
2402
    mc->query_hotpluggable_cpus = spapr_query_hotpluggable_cpus;
2403
    fwc->get_dev_path = spapr_get_fw_dev_path;
2404
    nc->nmi_monitor_handler = spapr_nmi;
2405 2406 2407 2408 2409
}

static const TypeInfo spapr_machine_info = {
    .name          = TYPE_SPAPR_MACHINE,
    .parent        = TYPE_MACHINE,
2410
    .abstract      = true,
2411
    .instance_size = sizeof(sPAPRMachineState),
E
Eduardo Habkost 已提交
2412
    .instance_init = spapr_machine_initfn,
2413
    .instance_finalize = spapr_machine_finalizefn,
D
David Gibson 已提交
2414
    .class_size    = sizeof(sPAPRMachineClass),
2415
    .class_init    = spapr_machine_class_init,
2416 2417
    .interfaces = (InterfaceInfo[]) {
        { TYPE_FW_PATH_PROVIDER },
2418
        { TYPE_NMI },
B
Bharata B Rao 已提交
2419
        { TYPE_HOTPLUG_HANDLER },
2420 2421
        { }
    },
2422 2423
};

2424
#define DEFINE_SPAPR_MACHINE(suffix, verstr, latest)                 \
D
David Gibson 已提交
2425 2426 2427 2428 2429
    static void spapr_machine_##suffix##_class_init(ObjectClass *oc, \
                                                    void *data)      \
    {                                                                \
        MachineClass *mc = MACHINE_CLASS(oc);                        \
        spapr_machine_##suffix##_class_options(mc);                  \
2430 2431 2432 2433
        if (latest) {                                                \
            mc->alias = "pseries";                                   \
            mc->is_default = 1;                                      \
        }                                                            \
D
David Gibson 已提交
2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449
    }                                                                \
    static void spapr_machine_##suffix##_instance_init(Object *obj)  \
    {                                                                \
        MachineState *machine = MACHINE(obj);                        \
        spapr_machine_##suffix##_instance_options(machine);          \
    }                                                                \
    static const TypeInfo spapr_machine_##suffix##_info = {          \
        .name = MACHINE_TYPE_NAME("pseries-" verstr),                \
        .parent = TYPE_SPAPR_MACHINE,                                \
        .class_init = spapr_machine_##suffix##_class_init,           \
        .instance_init = spapr_machine_##suffix##_instance_init,     \
    };                                                               \
    static void spapr_machine_register_##suffix(void)                \
    {                                                                \
        type_register(&spapr_machine_##suffix##_info);               \
    }                                                                \
2450
    type_init(spapr_machine_register_##suffix)
D
David Gibson 已提交
2451

2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465
/*
 * pseries-2.8
 */
static void spapr_machine_2_8_instance_options(MachineState *machine)
{
}

static void spapr_machine_2_8_class_options(MachineClass *mc)
{
    /* Defaults for the latest behaviour inherited from the base class */
}

DEFINE_SPAPR_MACHINE(2_8, "2.8", true);

2466 2467 2468
/*
 * pseries-2.7
 */
2469 2470 2471
#define SPAPR_COMPAT_2_7 \
    HW_COMPAT_2_7 \

2472 2473 2474 2475 2476 2477
static void spapr_machine_2_7_instance_options(MachineState *machine)
{
}

static void spapr_machine_2_7_class_options(MachineClass *mc)
{
2478 2479
    spapr_machine_2_8_class_options(mc);
    SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_7);
2480 2481
}

2482
DEFINE_SPAPR_MACHINE(2_7, "2.7", false);
2483

2484 2485 2486
/*
 * pseries-2.6
 */
2487
#define SPAPR_COMPAT_2_6 \
2488 2489 2490 2491 2492 2493
    HW_COMPAT_2_6 \
    { \
        .driver   = TYPE_SPAPR_PCI_HOST_BRIDGE,\
        .property = "ddw",\
        .value    = stringify(off),\
    },
2494

2495 2496 2497 2498 2499 2500
static void spapr_machine_2_6_instance_options(MachineState *machine)
{
}

static void spapr_machine_2_6_class_options(MachineClass *mc)
{
2501
    spapr_machine_2_7_class_options(mc);
2502
    mc->query_hotpluggable_cpus = NULL;
2503
    SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_6);
2504 2505
}

2506
DEFINE_SPAPR_MACHINE(2_6, "2.6", false);
2507

2508 2509 2510
/*
 * pseries-2.5
 */
2511
#define SPAPR_COMPAT_2_5 \
2512 2513 2514 2515 2516 2517
    HW_COMPAT_2_5 \
    { \
        .driver   = "spapr-vlan", \
        .property = "use-rx-buffer-pools", \
        .value    = "off", \
    },
2518

D
David Gibson 已提交
2519
static void spapr_machine_2_5_instance_options(MachineState *machine)
2520
{
D
David Gibson 已提交
2521 2522 2523 2524
}

static void spapr_machine_2_5_class_options(MachineClass *mc)
{
2525 2526
    sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc);

2527
    spapr_machine_2_6_class_options(mc);
2528
    smc->use_ohci_by_default = true;
2529
    SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_5);
2530 2531
}

2532
DEFINE_SPAPR_MACHINE(2_5, "2.5", false);
2533 2534 2535 2536

/*
 * pseries-2.4
 */
C
Cornelia Huck 已提交
2537 2538 2539
#define SPAPR_COMPAT_2_4 \
        HW_COMPAT_2_4

D
David Gibson 已提交
2540
static void spapr_machine_2_4_instance_options(MachineState *machine)
2541
{
D
David Gibson 已提交
2542 2543
    spapr_machine_2_5_instance_options(machine);
}
2544

D
David Gibson 已提交
2545 2546
static void spapr_machine_2_4_class_options(MachineClass *mc)
{
2547 2548 2549 2550
    sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc);

    spapr_machine_2_5_class_options(mc);
    smc->dr_lmb_enabled = false;
D
David Gibson 已提交
2551
    SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_4);
2552 2553
}

2554
DEFINE_SPAPR_MACHINE(2_4, "2.4", false);
2555 2556 2557 2558

/*
 * pseries-2.3
 */
E
Eduardo Habkost 已提交
2559
#define SPAPR_COMPAT_2_3 \
2560 2561 2562 2563 2564 2565
        HW_COMPAT_2_3 \
        {\
            .driver   = "spapr-pci-host-bridge",\
            .property = "dynamic-reconfiguration",\
            .value    = "off",\
        },
E
Eduardo Habkost 已提交
2566

D
David Gibson 已提交
2567
static void spapr_machine_2_3_instance_options(MachineState *machine)
J
Jason Wang 已提交
2568
{
D
David Gibson 已提交
2569
    spapr_machine_2_4_instance_options(machine);
2570
    savevm_skip_section_footers();
2571
    global_state_set_optional();
2572
    savevm_skip_configuration();
J
Jason Wang 已提交
2573 2574
}

D
David Gibson 已提交
2575
static void spapr_machine_2_3_class_options(MachineClass *mc)
2576
{
2577
    spapr_machine_2_4_class_options(mc);
D
David Gibson 已提交
2578
    SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_3);
2579
}
2580
DEFINE_SPAPR_MACHINE(2_3, "2.3", false);
2581

2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593
/*
 * pseries-2.2
 */

#define SPAPR_COMPAT_2_2 \
        HW_COMPAT_2_2 \
        {\
            .driver   = TYPE_SPAPR_PCI_HOST_BRIDGE,\
            .property = "mem_win_size",\
            .value    = "0x20000000",\
        },

D
David Gibson 已提交
2594
static void spapr_machine_2_2_instance_options(MachineState *machine)
2595
{
D
David Gibson 已提交
2596
    spapr_machine_2_3_instance_options(machine);
2597
    machine->suppress_vmdesc = true;
2598 2599
}

D
David Gibson 已提交
2600
static void spapr_machine_2_2_class_options(MachineClass *mc)
2601
{
2602
    spapr_machine_2_3_class_options(mc);
D
David Gibson 已提交
2603
    SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_2);
2604
}
2605
DEFINE_SPAPR_MACHINE(2_2, "2.2", false);
2606

2607 2608 2609 2610 2611
/*
 * pseries-2.1
 */
#define SPAPR_COMPAT_2_1 \
        HW_COMPAT_2_1
2612

D
David Gibson 已提交
2613
static void spapr_machine_2_1_instance_options(MachineState *machine)
2614
{
D
David Gibson 已提交
2615
    spapr_machine_2_2_instance_options(machine);
2616
}
J
Jason Wang 已提交
2617

D
David Gibson 已提交
2618
static void spapr_machine_2_1_class_options(MachineClass *mc)
J
Jason Wang 已提交
2619
{
2620
    spapr_machine_2_2_class_options(mc);
D
David Gibson 已提交
2621
    SET_MACHINE_COMPAT(mc, SPAPR_COMPAT_2_1);
J
Jason Wang 已提交
2622
}
2623
DEFINE_SPAPR_MACHINE(2_1, "2.1", false);
D
David Gibson 已提交
2624

2625
static void spapr_machine_register_types(void)
2626
{
2627
    type_register_static(&spapr_machine_info);
2628 2629
}

2630
type_init(spapr_machine_register_types)