qmp.c 21.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
/*
 * QEMU Management Protocol
 *
 * Copyright IBM, Corp. 2011
 *
 * Authors:
 *  Anthony Liguori   <aliguori@us.ibm.com>
 *
 * This work is licensed under the terms of the GNU GPL, version 2.  See
 * the COPYING file in the top-level directory.
 *
12 13
 * Contributions after 2012-01-13 are licensed under the terms of the
 * GNU GPL, version 2 or (at your option) any later version.
14 15
 */

Peter Maydell's avatar
Peter Maydell committed
16
#include "qemu/osdep.h"
17
#include "qemu-version.h"
18
#include "qemu/cutils.h"
19
#include "qemu/option.h"
20
#include "monitor/monitor.h"
21
#include "sysemu/sysemu.h"
22
#include "qemu/config-file.h"
Fam Zheng's avatar
Fam Zheng committed
23
#include "qemu/uuid.h"
24
#include "chardev/char.h"
25 26
#include "ui/qemu-spice.h"
#include "ui/vnc.h"
27 28
#include "sysemu/kvm.h"
#include "sysemu/arch_init.h"
29
#include "hw/qdev.h"
30
#include "sysemu/blockdev.h"
31
#include "sysemu/block-backend.h"
32
#include "qom/qom-qobject.h"
33
#include "qapi/error.h"
34 35 36
#include "qapi/qapi-commands-block-core.h"
#include "qapi/qapi-commands-misc.h"
#include "qapi/qapi-commands-ui.h"
37
#include "qapi/qmp/qdict.h"
38
#include "qapi/qmp/qerror.h"
39
#include "qapi/qobject-input-visitor.h"
Igor Mammedov's avatar
Igor Mammedov committed
40
#include "hw/boards.h"
41
#include "qom/object_interfaces.h"
42
#include "hw/mem/pc-dimm.h"
43
#include "hw/acpi/acpi_dev_interface.h"
44 45 46 47 48 49 50 51 52 53 54 55

NameInfo *qmp_query_name(Error **errp)
{
    NameInfo *info = g_malloc0(sizeof(*info));

    if (qemu_name) {
        info->has_name = true;
        info->name = g_strdup(qemu_name);
    }

    return info;
}
56

57
VersionInfo *qmp_query_version(Error **errp)
58
{
59
    VersionInfo *info = g_new0(VersionInfo, 1);
60

61
    info->qemu = g_new0(VersionTriple, 1);
62 63 64
    info->qemu->major = QEMU_VERSION_MAJOR;
    info->qemu->minor = QEMU_VERSION_MINOR;
    info->qemu->micro = QEMU_VERSION_MICRO;
65 66 67 68
    info->package = g_strdup(QEMU_PKGVERSION);

    return info;
}
69 70 71 72 73 74 75 76 77 78 79

KvmInfo *qmp_query_kvm(Error **errp)
{
    KvmInfo *info = g_malloc0(sizeof(*info));

    info->enabled = kvm_enabled();
    info->present = kvm_available();

    return info;
}

80 81 82 83
UuidInfo *qmp_query_uuid(Error **errp)
{
    UuidInfo *info = g_malloc0(sizeof(*info));

84
    info->UUID = qemu_uuid_unparse_strdup(&qemu_uuid);
85 86 87
    return info;
}

88
void qmp_quit(Error **errp)
Luiz Capitulino's avatar
Luiz Capitulino committed
89 90
{
    no_shutdown = 0;
91
    qemu_system_shutdown_request(SHUTDOWN_CAUSE_HOST_QMP);
Luiz Capitulino's avatar
Luiz Capitulino committed
92 93
}

Luiz Capitulino's avatar
Luiz Capitulino committed
94 95
void qmp_stop(Error **errp)
{
96 97 98 99 100 101 102
    /* if there is a dump in background, we should wait until the dump
     * finished */
    if (dump_in_progress()) {
        error_setg(errp, "There is a dump in process, please wait.");
        return;
    }

103 104 105 106 107
    if (runstate_check(RUN_STATE_INMIGRATE)) {
        autostart = 0;
    } else {
        vm_stop(RUN_STATE_PAUSED);
    }
Luiz Capitulino's avatar
Luiz Capitulino committed
108 109
}

110 111
void qmp_system_reset(Error **errp)
{
112
    qemu_system_reset_request(SHUTDOWN_CAUSE_HOST_QMP);
113
}
114 115 116 117 118

void qmp_system_powerdown(Error **erp)
{
    qemu_system_powerdown_request();
}
119

Igor Mammedov's avatar
Igor Mammedov committed
120 121
void qmp_cpu_add(int64_t id, Error **errp)
{
122 123 124
    MachineClass *mc;

    mc = MACHINE_GET_CLASS(current_machine);
125 126
    if (mc->hot_add_cpu) {
        mc->hot_add_cpu(id, errp);
Igor Mammedov's avatar
Igor Mammedov committed
127 128 129 130 131
    } else {
        error_setg(errp, "Not supported");
    }
}

132 133 134 135 136
#ifndef CONFIG_VNC
/* If VNC support is enabled, the "true" query-vnc command is
   defined in the VNC subsystem */
VncInfo *qmp_query_vnc(Error **errp)
{
137
    error_setg(errp, QERR_FEATURE_DISABLED, "vnc");
138 139
    return NULL;
};
140 141 142

VncInfo2List *qmp_query_vnc_servers(Error **errp)
{
143
    error_setg(errp, QERR_FEATURE_DISABLED, "vnc");
144 145
    return NULL;
};
146
#endif
147 148

#ifndef CONFIG_SPICE
149
/*
150 151 152 153 154 155 156
 * qmp_unregister_commands_hack() ensures that QMP command query-spice
 * exists only #ifdef CONFIG_SPICE.  Necessary for an accurate
 * query-commands result.  However, the QAPI schema is blissfully
 * unaware of that, and the QAPI code generator happily generates a
 * dead qmp_marshal_query_spice() that calls qmp_query_spice().
 * Provide it one, or else linking fails.  FIXME Educate the QAPI
 * schema on CONFIG_SPICE.
157
 */
158 159
SpiceInfo *qmp_query_spice(Error **errp)
{
160
    abort();
161 162
};
#endif
Luiz Capitulino's avatar
Luiz Capitulino committed
163 164 165

void qmp_cont(Error **errp)
{
166
    BlockBackend *blk;
167
    Error *local_err = NULL;
Luiz Capitulino's avatar
Luiz Capitulino committed
168

169 170 171 172 173 174 175
    /* if there is a dump in background, we should wait until the dump
     * finished */
    if (dump_in_progress()) {
        error_setg(errp, "There is a dump in process, please wait.");
        return;
    }

176
    if (runstate_needs_reset()) {
177
        error_setg(errp, "Resetting the Virtual Machine is required");
Luiz Capitulino's avatar
Luiz Capitulino committed
178
        return;
179 180
    } else if (runstate_check(RUN_STATE_SUSPENDED)) {
        return;
Luiz Capitulino's avatar
Luiz Capitulino committed
181 182
    }

183 184
    for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
        blk_iostatus_reset(blk);
185
    }
186

187
    /* Continuing after completed migration. Images have been inactivated to
188 189 190 191 192 193 194 195 196
     * allow the destination to take control. Need to get control back now.
     *
     * If there are no inactive block nodes (e.g. because the VM was just
     * paused rather than completing a migration), bdrv_inactivate_all() simply
     * doesn't do anything. */
    bdrv_invalidate_cache_all(&local_err);
    if (local_err) {
        error_propagate(errp, local_err);
        return;
197 198
    }

199 200 201 202 203
    if (runstate_check(RUN_STATE_INMIGRATE)) {
        autostart = 1;
    } else {
        vm_start();
    }
Luiz Capitulino's avatar
Luiz Capitulino committed
204
}
205

206 207 208 209 210
void qmp_system_wakeup(Error **errp)
{
    qemu_system_wakeup_request(QEMU_WAKEUP_REASON_OTHER);
}

211
ObjectPropertyInfoList *qmp_qom_list(const char *path, Error **errp)
212
{
213
    Object *obj;
214
    bool ambiguous = false;
215 216
    ObjectPropertyInfoList *props = NULL;
    ObjectProperty *prop;
217
    ObjectPropertyIterator iter;
218

219 220
    obj = object_resolve_path(path, &ambiguous);
    if (obj == NULL) {
221 222 223
        if (ambiguous) {
            error_setg(errp, "Path '%s' is ambiguous", path);
        } else {
224 225
            error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
                      "Device '%s' not found", path);
226
        }
227 228 229
        return NULL;
    }

230 231
    object_property_iter_init(&iter, obj);
    while ((prop = object_property_iter_next(&iter))) {
232
        ObjectPropertyInfoList *entry = g_malloc0(sizeof(*entry));
233

234
        entry->value = g_malloc0(sizeof(ObjectPropertyInfo));
235 236 237 238 239 240 241 242 243
        entry->next = props;
        props = entry;

        entry->value->name = g_strdup(prop->name);
        entry->value->type = g_strdup(prop->type);
    }

    return props;
}
244

245 246
void qmp_qom_set(const char *path, const char *property, QObject *value,
                 Error **errp)
247
{
248
    Object *obj;
249

250 251
    obj = object_resolve_path(path, NULL);
    if (!obj) {
252
        error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
253
                  "Device '%s' not found", path);
254
        return;
255 256
    }

257
    object_property_set_qobject(obj, value, property, errp);
258 259
}

260
QObject *qmp_qom_get(const char *path, const char *property, Error **errp)
261
{
262
    Object *obj;
263

264 265
    obj = object_resolve_path(path, NULL);
    if (!obj) {
266
        error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
267
                  "Device '%s' not found", path);
268
        return NULL;
269 270
    }

271
    return object_property_get_qobject(obj, property, errp);
272
}
273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288

void qmp_set_password(const char *protocol, const char *password,
                      bool has_connected, const char *connected, Error **errp)
{
    int disconnect_if_connected = 0;
    int fail_if_connected = 0;
    int rc;

    if (has_connected) {
        if (strcmp(connected, "fail") == 0) {
            fail_if_connected = 1;
        } else if (strcmp(connected, "disconnect") == 0) {
            disconnect_if_connected = 1;
        } else if (strcmp(connected, "keep") == 0) {
            /* nothing */
        } else {
289
            error_setg(errp, QERR_INVALID_PARAMETER, "connected");
290 291 292 293 294
            return;
        }
    }

    if (strcmp(protocol, "spice") == 0) {
295
        if (!qemu_using_spice(errp)) {
296 297 298 299 300
            return;
        }
        rc = qemu_spice_set_passwd(password, fail_if_connected,
                                   disconnect_if_connected);
        if (rc != 0) {
301
            error_setg(errp, QERR_SET_PASSWD_FAILED);
302 303 304 305 306 307 308
        }
        return;
    }

    if (strcmp(protocol, "vnc") == 0) {
        if (fail_if_connected || disconnect_if_connected) {
            /* vnc supports "connected=keep" only */
309
            error_setg(errp, QERR_INVALID_PARAMETER, "connected");
310 311 312 313 314 315
            return;
        }
        /* Note that setting an empty password will not disable login through
         * this interface. */
        rc = vnc_display_password(NULL, password);
        if (rc < 0) {
316
            error_setg(errp, QERR_SET_PASSWD_FAILED);
317 318 319 320
        }
        return;
    }

321
    error_setg(errp, QERR_INVALID_PARAMETER, "protocol");
322
}
323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340

void qmp_expire_password(const char *protocol, const char *whenstr,
                         Error **errp)
{
    time_t when;
    int rc;

    if (strcmp(whenstr, "now") == 0) {
        when = 0;
    } else if (strcmp(whenstr, "never") == 0) {
        when = TIME_MAX;
    } else if (whenstr[0] == '+') {
        when = time(NULL) + strtoull(whenstr+1, NULL, 10);
    } else {
        when = strtoull(whenstr, NULL, 10);
    }

    if (strcmp(protocol, "spice") == 0) {
341
        if (!qemu_using_spice(errp)) {
342 343 344 345
            return;
        }
        rc = qemu_spice_set_pw_expire(when);
        if (rc != 0) {
346
            error_setg(errp, QERR_SET_PASSWD_FAILED);
347 348 349 350 351 352 353
        }
        return;
    }

    if (strcmp(protocol, "vnc") == 0) {
        rc = vnc_display_pw_expire(NULL, when);
        if (rc != 0) {
354
            error_setg(errp, QERR_SET_PASSWD_FAILED);
355 356 357 358
        }
        return;
    }

359
    error_setg(errp, QERR_INVALID_PARAMETER, "protocol");
360
}
361

Luiz Capitulino's avatar
Luiz Capitulino committed
362
#ifdef CONFIG_VNC
363 364 365
void qmp_change_vnc_password(const char *password, Error **errp)
{
    if (vnc_display_password(NULL, password) < 0) {
366
        error_setg(errp, QERR_SET_PASSWD_FAILED);
367 368
    }
}
Luiz Capitulino's avatar
Luiz Capitulino committed
369

370
static void qmp_change_vnc_listen(const char *target, Error **errp)
Luiz Capitulino's avatar
Luiz Capitulino committed
371
{
372 373 374 375 376 377 378 379 380 381 382 383
    QemuOptsList *olist = qemu_find_opts("vnc");
    QemuOpts *opts;

    if (strstr(target, "id=")) {
        error_setg(errp, "id not supported");
        return;
    }

    opts = qemu_opts_find(olist, "default");
    if (opts) {
        qemu_opts_del(opts);
    }
384
    opts = vnc_parse(target, errp);
385 386 387 388
    if (!opts) {
        return;
    }

389
    vnc_display_open("default", errp);
Luiz Capitulino's avatar
Luiz Capitulino committed
390 391 392 393 394 395 396
}

static void qmp_change_vnc(const char *target, bool has_arg, const char *arg,
                           Error **errp)
{
    if (strcmp(target, "passwd") == 0 || strcmp(target, "password") == 0) {
        if (!has_arg) {
397
            error_setg(errp, QERR_MISSING_PARAMETER, "password");
Luiz Capitulino's avatar
Luiz Capitulino committed
398 399 400 401 402 403 404 405 406 407
        } else {
            qmp_change_vnc_password(arg, errp);
        }
    } else {
        qmp_change_vnc_listen(target, errp);
    }
}
#else
void qmp_change_vnc_password(const char *password, Error **errp)
{
408
    error_setg(errp, QERR_FEATURE_DISABLED, "vnc");
Luiz Capitulino's avatar
Luiz Capitulino committed
409 410 411 412
}
static void qmp_change_vnc(const char *target, bool has_arg, const char *arg,
                           Error **errp)
{
413
    error_setg(errp, QERR_FEATURE_DISABLED, "vnc");
Luiz Capitulino's avatar
Luiz Capitulino committed
414 415 416 417
}
#endif /* !CONFIG_VNC */

void qmp_change(const char *device, const char *target,
418
                bool has_arg, const char *arg, Error **errp)
Luiz Capitulino's avatar
Luiz Capitulino committed
419 420
{
    if (strcmp(device, "vnc") == 0) {
421
        qmp_change_vnc(target, has_arg, arg, errp);
Luiz Capitulino's avatar
Luiz Capitulino committed
422
    } else {
423 424
        qmp_blockdev_change_medium(true, device, false, NULL, target,
                                   has_arg, arg, false, 0, errp);
Luiz Capitulino's avatar
Luiz Capitulino committed
425 426
    }
}
427 428 429 430 431

static void qom_list_types_tramp(ObjectClass *klass, void *data)
{
    ObjectTypeInfoList *e, **pret = data;
    ObjectTypeInfo *info;
432
    ObjectClass *parent = object_class_get_parent(klass);
433 434 435

    info = g_malloc0(sizeof(*info));
    info->name = g_strdup(object_class_get_name(klass));
436
    info->has_abstract = info->abstract = object_class_is_abstract(klass);
437 438 439 440
    if (parent) {
        info->has_parent = true;
        info->parent = g_strdup(object_class_get_name(parent));
    }
441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459

    e = g_malloc0(sizeof(*e));
    e->value = info;
    e->next = *pret;
    *pret = e;
}

ObjectTypeInfoList *qmp_qom_list_types(bool has_implements,
                                       const char *implements,
                                       bool has_abstract,
                                       bool abstract,
                                       Error **errp)
{
    ObjectTypeInfoList *ret = NULL;

    object_class_foreach(qom_list_types_tramp, implements, abstract, &ret);

    return ret;
}
460

461 462 463 464 465 466 467
/* Return a DevicePropertyInfo for a qdev property.
 *
 * If a qdev property with the given name does not exist, use the given default
 * type.  If the qdev property info should not be shown, return NULL.
 *
 * The caller must free the return value.
 */
468 469 470 471
static ObjectPropertyInfo *make_device_property_info(ObjectClass *klass,
                                                  const char *name,
                                                  const char *default_type,
                                                  const char *description)
472
{
473
    ObjectPropertyInfo *info;
474 475 476 477 478 479 480 481 482 483 484 485 486 487
    Property *prop;

    do {
        for (prop = DEVICE_CLASS(klass)->props; prop && prop->name; prop++) {
            if (strcmp(name, prop->name) != 0) {
                continue;
            }

            /*
             * TODO Properties without a parser are just for dirty hacks.
             * qdev_prop_ptr is the only such PropertyInfo.  It's marked
             * for removal.  This conditional should be removed along with
             * it.
             */
488
            if (!prop->info->set && !prop->info->create) {
489 490 491 492 493
                return NULL;           /* no way to set it, don't show */
            }

            info = g_malloc0(sizeof(*info));
            info->name = g_strdup(prop->name);
494 495
            info->type = default_type ? g_strdup(default_type)
                                      : g_strdup(prop->info->name);
496 497
            info->has_description = !!prop->info->description;
            info->description = g_strdup(prop->info->description);
498 499 500 501 502 503 504 505 506
            return info;
        }
        klass = object_class_get_parent(klass);
    } while (klass != object_class_by_name(TYPE_DEVICE));

    /* Not a qdev property, use the default type */
    info = g_malloc0(sizeof(*info));
    info->name = g_strdup(name);
    info->type = g_strdup(default_type);
507 508 509
    info->has_description = !!description;
    info->description = g_strdup(description);

510 511 512
    return info;
}

513 514
ObjectPropertyInfoList *qmp_device_list_properties(const char *typename,
                                                Error **errp)
515 516
{
    ObjectClass *klass;
517 518
    Object *obj;
    ObjectProperty *prop;
519
    ObjectPropertyIterator iter;
520
    ObjectPropertyInfoList *prop_list = NULL;
521 522 523

    klass = object_class_by_name(typename);
    if (klass == NULL) {
524 525
        error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
                  "Device '%s' not found", typename);
526 527 528 529 530
        return NULL;
    }

    klass = object_class_dynamic_cast(klass, TYPE_DEVICE);
    if (klass == NULL) {
531
        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "typename", TYPE_DEVICE);
532 533 534
        return NULL;
    }

535
    if (object_class_is_abstract(klass)) {
536
        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "typename",
537 538 539 540
                   "non-abstract device type");
        return NULL;
    }

541
    obj = object_new(typename);
542

543 544
    object_property_iter_init(&iter, obj);
    while ((prop = object_property_iter_next(&iter))) {
545 546
        ObjectPropertyInfo *info;
        ObjectPropertyInfoList *entry;
547 548 549 550 551

        /* Skip Object and DeviceState properties */
        if (strcmp(prop->name, "type") == 0 ||
            strcmp(prop->name, "realized") == 0 ||
            strcmp(prop->name, "hotpluggable") == 0 ||
552
            strcmp(prop->name, "hotplugged") == 0 ||
553 554 555
            strcmp(prop->name, "parent_bus") == 0) {
            continue;
        }
556

557 558 559 560 561 562
        /* Skip legacy properties since they are just string versions of
         * properties that we already list.
         */
        if (strstart(prop->name, "legacy-", NULL)) {
            continue;
        }
563

564 565
        info = make_device_property_info(klass, prop->name, prop->type,
                                         prop->description);
566 567
        if (!info) {
            continue;
568
        }
569 570

        entry = g_malloc0(sizeof(*entry));
571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619
        entry->value = info;
        entry->next = prop_list;
        prop_list = entry;
    }

    object_unref(obj);

    return prop_list;
}

ObjectPropertyInfoList *qmp_qom_list_properties(const char *typename,
                                             Error **errp)
{
    ObjectClass *klass;
    Object *obj = NULL;
    ObjectProperty *prop;
    ObjectPropertyIterator iter;
    ObjectPropertyInfoList *prop_list = NULL;

    klass = object_class_by_name(typename);
    if (klass == NULL) {
        error_set(errp, ERROR_CLASS_DEVICE_NOT_FOUND,
                  "Class '%s' not found", typename);
        return NULL;
    }

    klass = object_class_dynamic_cast(klass, TYPE_OBJECT);
    if (klass == NULL) {
        error_setg(errp, QERR_INVALID_PARAMETER_VALUE, "typename", TYPE_OBJECT);
        return NULL;
    }

    if (object_class_is_abstract(klass)) {
        object_class_property_iter_init(&iter, klass);
    } else {
        obj = object_new(typename);
        object_property_iter_init(&iter, obj);
    }
    while ((prop = object_property_iter_next(&iter))) {
        ObjectPropertyInfo *info;
        ObjectPropertyInfoList *entry;

        info = g_malloc0(sizeof(*info));
        info->name = g_strdup(prop->name);
        info->type = g_strdup(prop->type);
        info->has_description = !!prop->description;
        info->description = g_strdup(prop->description);

        entry = g_malloc0(sizeof(*entry));
620 621 622 623 624 625
        entry->value = info;
        entry->next = prop_list;
        prop_list = entry;
    }

    object_unref(obj);
626 627 628

    return prop_list;
}
629

630 631 632 633 634
CpuDefinitionInfoList *qmp_query_cpu_definitions(Error **errp)
{
    return arch_query_cpu_definitions(errp);
}

635 636 637 638 639 640 641
CpuModelExpansionInfo *qmp_query_cpu_model_expansion(CpuModelExpansionType type,
                                                     CpuModelInfo *model,
                                                     Error **errp)
{
    return arch_query_cpu_model_expansion(type, model, errp);
}

642 643 644 645 646 647 648
CpuModelCompareInfo *qmp_query_cpu_model_comparison(CpuModelInfo *modela,
                                                    CpuModelInfo *modelb,
                                                    Error **errp)
{
    return arch_query_cpu_model_comparison(modela, modelb, errp);
}

649 650 651 652 653 654 655
CpuModelBaselineInfo *qmp_query_cpu_model_baseline(CpuModelInfo *modela,
                                                   CpuModelInfo *modelb,
                                                   Error **errp)
{
    return arch_query_cpu_model_baseline(modela, modelb, errp);
}

656 657 658 659
void qmp_add_client(const char *protocol, const char *fdname,
                    bool has_skipauth, bool skipauth, bool has_tls, bool tls,
                    Error **errp)
{
660
    Chardev *s;
661 662 663 664 665 666 667 668
    int fd;

    fd = monitor_get_fd(cur_mon, fdname, errp);
    if (fd < 0) {
        return;
    }

    if (strcmp(protocol, "spice") == 0) {
669
        if (!qemu_using_spice(errp)) {
670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697
            close(fd);
            return;
        }
        skipauth = has_skipauth ? skipauth : false;
        tls = has_tls ? tls : false;
        if (qemu_spice_display_add_client(fd, skipauth, tls) < 0) {
            error_setg(errp, "spice failed to add client");
            close(fd);
        }
        return;
#ifdef CONFIG_VNC
    } else if (strcmp(protocol, "vnc") == 0) {
        skipauth = has_skipauth ? skipauth : false;
        vnc_display_add_client(NULL, fd, skipauth);
        return;
#endif
    } else if ((s = qemu_chr_find(protocol)) != NULL) {
        if (qemu_chr_add_client(s, fd) < 0) {
            error_setg(errp, "failed to add client");
            close(fd);
            return;
        }
        return;
    }

    error_setg(errp, "protocol '%s' is invalid", protocol);
    close(fd);
}
698

699

700 701
void qmp_object_add(const char *type, const char *id,
                    bool has_props, QObject *props, Error **errp)
702
{
703
    QDict *pdict;
704
    Visitor *v;
705
    Object *obj;
706 707

    if (props) {
708
        pdict = qobject_to(QDict, props);
709
        if (!pdict) {
710 711
            error_setg(errp, QERR_INVALID_PARAMETER_TYPE, "props", "dict");
            return;
712
        }
713 714 715
        QINCREF(pdict);
    } else {
        pdict = qdict_new();
716 717
    }

718
    v = qobject_input_visitor_new(QOBJECT(pdict));
719 720
    obj = user_creatable_add_type(type, id, pdict, v, errp);
    visit_free(v);
721 722 723
    if (obj) {
        object_unref(obj);
    }
724
    QDECREF(pdict);
725 726
}

727 728
void qmp_object_del(const char *id, Error **errp)
{
729
    user_creatable_del(id, errp);
730
}
731 732 733

MemoryDeviceInfoList *qmp_query_memory_devices(Error **errp)
{
734
    return qmp_pc_dimm_device_list();
735
}
736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754

ACPIOSTInfoList *qmp_query_acpi_ospm_status(Error **errp)
{
    bool ambig;
    ACPIOSTInfoList *head = NULL;
    ACPIOSTInfoList **prev = &head;
    Object *obj = object_resolve_path_type("", TYPE_ACPI_DEVICE_IF, &ambig);

    if (obj) {
        AcpiDeviceIfClass *adevc = ACPI_DEVICE_IF_GET_CLASS(obj);
        AcpiDeviceIf *adev = ACPI_DEVICE_IF(obj);

        adevc->ospm_status(adev, &prev);
    } else {
        error_setg(errp, "command is not supported, missing ACPI device");
    }

    return head;
}
755 756 757 758 759 760 761 762 763 764 765 766 767

MemoryInfo *qmp_query_memory_size_summary(Error **errp)
{
    MemoryInfo *mem_info = g_malloc0(sizeof(MemoryInfo));

    mem_info->base_memory = ram_size;

    mem_info->plugged_memory = get_plugged_memory_size();
    mem_info->has_plugged_memory =
        mem_info->plugged_memory != (uint64_t)-1;

    return mem_info;
}
Peter Xu's avatar
Peter Xu committed
768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783

static QemuSemaphore x_oob_test_sem;

static void __attribute__((constructor)) x_oob_test_init(void)
{
    qemu_sem_init(&x_oob_test_sem, 0);
}

void qmp_x_oob_test(bool lock, Error **errp)
{
    if (lock) {
        qemu_sem_wait(&x_oob_test_sem);
    } else {
        qemu_sem_post(&x_oob_test_sem);
    }
}