qemu_monitor_text.c 83.5 KB
Newer Older
1 2 3
/*
 * qemu_monitor_text.c: interaction with QEMU monitor console
 *
4
 * Copyright (C) 2006-2014 Red Hat, Inc.
5 6 7 8 9 10 11 12 13 14 15 16 17
 * Copyright (C) 2006 Daniel P. Berrange
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with this library.  If not, see
O
Osier Yang 已提交
19
 * <http://www.gnu.org/licenses/>.
20 21 22 23 24 25 26 27 28 29 30
 *
 * Author: Daniel P. Berrange <berrange@redhat.com>
 */

#include <config.h>

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <poll.h>
#include <unistd.h>
31
#include <string.h>
32 33

#include "qemu_monitor_text.h"
34
#include "qemu_command.h"
35
#include "c-ctype.h"
36
#include "c-strcasestr.h"
37
#include "viralloc.h"
38
#include "virlog.h"
39 40
#include "driver.h"
#include "datatypes.h"
41
#include "virerror.h"
42
#include "virbuffer.h"
43
#include "virprobe.h"
44
#include "virstring.h"
45

46 47 48 49
#ifdef WITH_DTRACE_PROBES
# include "libvirt_qemu_probes.h"
#endif

50 51
#define VIR_FROM_THIS VIR_FROM_QEMU

52 53
VIR_LOG_INIT("qemu.qemu_monitor_text");

54 55
#define DEBUG_IO 0

56
/* Return -1 for error, 0 for success */
57
typedef int qemuMonitorExtraPromptHandler(qemuMonitorPtr mon,
58 59 60 61 62
                                          const char *buf,
                                          const char *prompt,
                                          void *data);


63 64 65 66 67
/* When connecting to a monitor, QEMU will print a greeting like
 *
 * QEMU 0.11.0 monitor - type 'help' for more information
 *
 * Don't expect the version number bit to be stable :-)
68
 */
69 70 71 72 73 74 75 76 77 78
#define GREETING_PREFIX "QEMU "
#define GREETING_POSTFIX "type 'help' for more information\r\n(qemu) "
#define BASIC_PROMPT "(qemu) "
#define PASSWORD_PROMPT "Password:"
#define DISK_ENCRYPTION_PREFIX "("
#define DISK_ENCRYPTION_POSTFIX ") is encrypted."
#define LINE_ENDING "\r\n"

int qemuMonitorTextIOProcess(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                             const char *data,
79
                             size_t len ATTRIBUTE_UNUSED,
80 81 82
                             qemuMonitorMessagePtr msg)
{
    int used = 0;
83

84 85 86
    /* Check for & discard greeting */
    if (STRPREFIX(data, GREETING_PREFIX)) {
        const char *offset = strstr(data, GREETING_POSTFIX);
87

88 89 90
        /* We see the greeting prefix, but not postfix, so pretend we've
           not consumed anything. We'll restart when more data arrives. */
        if (!offset) {
91
#if DEBUG_IO
92
            VIR_DEBUG("Partial greeting seen, getting out & waiting for more");
93
#endif
94 95
            return 0;
        }
96

97 98
        used = offset - data + strlen(GREETING_POSTFIX);

99
#if DEBUG_IO
100
        VIR_DEBUG("Discarded monitor greeting");
101
#endif
102
    }
103

104 105
    /* Don't print raw data in debug because its full of control chars */
    /*VIR_DEBUG("Process data %d byts of data [%s]", len - used, data + used);*/
106
#if DEBUG_IO
107
    VIR_DEBUG("Process data %d byts of data", (int)(len - used));
108
#endif
109 110 111

    /* Look for a non-zero reply followed by prompt */
    if (msg && !msg->finished) {
112 113 114 115 116 117 118 119 120 121 122
        char *start = NULL;
        char *end = NULL;
        char *skip;

        /* If we're here, we've already sent the command. We now
         * strip the trailing '\r' because it makes the matching
         * code that follows a little easier ie we can just strstr()
         * for the original command
         */
        if (msg->txLength > 0) {
            char *tmp;
123
            if ((tmp = strchr(msg->txBuffer, '\r')))
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
                *tmp = '\0';
        }

        /* QEMU echos the command back to us, full of control
         * character junk that we don't want. We have to skip
         * over this junk by looking for the first complete
         * repetition of our command. Then we can look for
         * the prompt that is supposed to follow
         *
         * NB, we can't optimize by immediately looking for
         * LINE_ENDING, because QEMU 0.10 has bad problems
         * when initially connecting where it might write a
         * prompt in the wrong place. So we must not look
         * for LINE_ENDING, or BASIC_PROMPT until we've
         * seen our original command echod.
         */
        skip = strstr(data + used, msg->txBuffer);

        /* After the junk we should have a line ending... */
143
        if (skip)
144
            start = strstr(skip + strlen(msg->txBuffer), LINE_ENDING);
145

146 147 148 149 150 151 152 153
        /* ... then our command reply data, following by a (qemu) prompt */
        if (start) {
            char *passwd;
            start += strlen(LINE_ENDING);

            /* We might get a prompt for a password before the (qemu) prompt */
            passwd = strstr(start, PASSWORD_PROMPT);
            if (passwd) {
154
#if DEBUG_IO
155
                VIR_DEBUG("Seen a password prompt [%s]", data + used);
156
#endif
157
                if (msg->passwordHandler) {
158
                    size_t i;
159 160
                    /* Try and handle the prompt. The handler is required
                     * to report a normal libvirt error */
161 162 163 164 165 166 167 168
                    if (msg->passwordHandler(mon, msg,
                                             start,
                                             passwd - start + strlen(PASSWORD_PROMPT),
                                             msg->passwordOpaque) < 0)
                        return -1;

                    /* Blank out the password prompt so we don't re-trigger
                     * if we have to go back to sleep for more I/O */
169
                    for (i = 0; i < strlen(PASSWORD_PROMPT); i++)
170 171 172 173 174
                        start[i] = ' ';

                    /* Handled, so skip forward over password prompt */
                    start = passwd;
                } else {
175 176
                    virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                                   _("Password request seen, but no handler available"));
177 178
                    return -1;
                }
179
            }
180 181

            end = strstr(start, BASIC_PROMPT);
182
        }
183

184
        if (start && end) {
185 186 187 188 189 190
            int want = end - start;
            /* Annoyingly some commands may not have any reply data
             * at all upon success, but since we've detected the
             * BASIC_PROMPT we can reasonably reliably cope */
            if (want) {
                if (VIR_REALLOC_N(msg->rxBuffer,
191
                                  msg->rxLength + want + 1) < 0)
192 193 194 195
                    return -1;
                memcpy(msg->rxBuffer + msg->rxLength, start, want);
                msg->rxLength += want;
                msg->rxBuffer[msg->rxLength] = '\0';
196
#if DEBUG_IO
197 198
                VIR_DEBUG("Finished %d byte reply [%s]", want, msg->rxBuffer);
            } else {
199
                VIR_DEBUG("Finished 0 byte reply");
200
#endif
201
            }
202 203 204
            PROBE(QEMU_MONITOR_RECV_REPLY,
                  "mon=%p reply=%s",
                  mon, msg->rxBuffer);
205 206 207 208 209 210
            msg->finished = 1;
            used += end - (data + used);
            used += strlen(BASIC_PROMPT);
        }
    }

211
#if DEBUG_IO
212
    VIR_DEBUG("Total used %d", used);
213
#endif
214
    return used;
215 216
}

217
static int
218 219 220 221 222 223 224
qemuMonitorTextCommandWithHandler(qemuMonitorPtr mon,
                                  const char *cmd,
                                  qemuMonitorPasswordHandler passwordHandler,
                                  void *passwordOpaque,
                                  int scm_fd,
                                  char **reply)
{
225 226
    int ret;
    qemuMonitorMessage msg;
227

228
    *reply = NULL;
229

230
    memset(&msg, 0, sizeof(msg));
231

232
    if (virAsprintf(&msg.txBuffer, "%s\r", cmd) < 0)
233 234 235 236 237
        return -1;
    msg.txLength = strlen(msg.txBuffer);
    msg.txFD = scm_fd;
    msg.passwordHandler = passwordHandler;
    msg.passwordOpaque = passwordOpaque;
238

239
    VIR_DEBUG("Send command '%s' for write with FD %d", cmd, scm_fd);
240

241
    ret = qemuMonitorSend(mon, &msg);
242

243 244
    VIR_DEBUG("Receive command reply ret=%d rxLength=%d rxBuffer='%s'",
              ret, msg.rxLength, msg.rxBuffer);
245

246 247 248
    /* Just in case buffer had some passwords in */
    memset(msg.txBuffer, 0, msg.txLength);
    VIR_FREE(msg.txBuffer);
249

250 251 252 253 254
    if (ret >= 0) {
        /* To make life safer for callers, already ensure there's at least an empty string */
        if (msg.rxBuffer) {
            *reply = msg.rxBuffer;
        } else {
255
            if (VIR_STRDUP(*reply, "") < 0)
256
                return -1;
257 258 259
        }
    }

260
    return ret;
261 262
}

263 264 265 266 267 268
int
qemuMonitorTextCommandWithFd(qemuMonitorPtr mon,
                             const char *cmd,
                             int scm_fd,
                             char **reply)
{
269 270
    return qemuMonitorTextCommandWithHandler(mon, cmd, NULL, NULL,
                                             scm_fd, reply);
271 272
}

273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
/* Check monitor output for evidence that the command was not recognized.
 * For 'info' commands, qemu returns help text.  For other commands, qemu
 * returns 'unknown command:'.
 */
static int
qemuMonitorTextCommandNotFound(const char *cmd, const char *reply)
{
    if (STRPREFIX(cmd, "info ")) {
        if (strstr(reply, "info version"))
            return 1;
    } else {
        if (strstr(reply, "unknown command:"))
            return 1;
    }

    return 0;
}
290 291

static int
292 293 294 295 296
qemuMonitorSendDiskPassphrase(qemuMonitorPtr mon,
                              qemuMonitorMessagePtr msg,
                              const char *data,
                              size_t len ATTRIBUTE_UNUSED,
                              void *opaque)
297
{
298 299 300 301
    virConnectPtr conn = opaque;
    char *path;
    char *passphrase = NULL;
    size_t passphrase_len = 0;
302
    int res;
303 304
    const char *pathStart;
    const char *pathEnd;
305

306 307 308 309 310 311 312 313 314 315
    /*
     * For disk passwords:
     *
     *    ide0-hd0 (/path/to/volume) is encrypted.
     *    Password:
     *
     */
    pathStart = strstr(data, DISK_ENCRYPTION_PREFIX);
    pathEnd = strstr(data, DISK_ENCRYPTION_POSTFIX);
    if (!pathStart || !pathEnd || pathStart >= pathEnd) {
316 317 318
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("Unable to extract disk path from %s"),
                       data);
319
        return -1;
320 321 322 323
    }

    /* Extra the path */
    pathStart += strlen(DISK_ENCRYPTION_PREFIX);
324
    if (VIR_STRNDUP(path, pathStart, pathEnd - pathStart) < 0)
325 326
        return -1;

327 328 329 330 331 332
    /* Fetch the disk password if possible */
    res = qemuMonitorGetDiskSecret(mon,
                                   conn,
                                   path,
                                   &passphrase,
                                   &passphrase_len);
333
    VIR_FREE(path);
334
    if (res < 0)
335 336
        return -1;

337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
    /* Enlarge transmit buffer to allow for the extra data
     * to be sent back */
    if (VIR_REALLOC_N(msg->txBuffer,
                      msg->txLength + passphrase_len + 1 + 1) < 0) {
        memset(passphrase, 0, passphrase_len);
        VIR_FREE(passphrase);
        return -1;
    }

    /* Queue the password for sending */
    memcpy(msg->txBuffer + msg->txLength,
           passphrase, passphrase_len);
    msg->txLength += passphrase_len;
    msg->txBuffer[msg->txLength] = '\r';
    msg->txLength++;
    msg->txBuffer[msg->txLength] = '\0';
353 354 355 356

    memset(passphrase, 0, passphrase_len);
    VIR_FREE(passphrase);

357
    return 0;
358 359 360
}

int
361
qemuMonitorTextStartCPUs(qemuMonitorPtr mon,
362 363
                         virConnectPtr conn)
{
364 365
    char *reply;

366 367 368 369
    if (qemuMonitorTextCommandWithHandler(mon, "cont",
                                          qemuMonitorSendDiskPassphrase,
                                          conn,
                                          -1, &reply) < 0)
370
        return -1;
371

372 373 374
    VIR_FREE(reply);
    return 0;
}
375 376


377
int
378 379
qemuMonitorTextStopCPUs(qemuMonitorPtr mon)
{
380
    char *info;
381
    int ret;
382

383
    ret = qemuMonitorHMPCommand(mon, "stop", &info);
384
    VIR_FREE(info);
385
    return ret;
386 387
}

388

389
int
390 391 392
qemuMonitorTextGetStatus(qemuMonitorPtr mon,
                         bool *running,
                         virDomainPausedReason *reason)
393 394 395 396
{
    char *reply;
    int ret = -1;

397 398 399
    if (reason)
        *reason = VIR_DOMAIN_PAUSED_UNKNOWN;

400
    if (qemuMonitorHMPCommand(mon, "info status", &reply) < 0)
401 402 403 404 405
        return -1;

    if (strstr(reply, "running")) {
        *running = true;
    } else if (strstr(reply, "paused")) {
406 407 408 409 410 411 412 413 414 415 416 417 418
        char *status;

        if ((status = strchr(reply, '('))) {
            char *end = strchr(status, ')');
            if (end)
                *end = '\0';
            else
                status = NULL;
        }
        if (!status)
            VIR_DEBUG("info status was missing status details");
        else if (reason)
            *reason = qemuMonitorVMStatusToPausedReason(status);
419 420
        *running = false;
    } else {
421 422
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("unexpected reply from info status: %s"), reply);
423 424 425 426 427
        goto cleanup;
    }

    ret = 0;

428
 cleanup:
429 430 431 432 433
    VIR_FREE(reply);
    return ret;
}


434 435
int qemuMonitorTextSystemPowerdown(qemuMonitorPtr mon)
{
436
    char *info;
437 438 439
    int ret;

    ret = qemuMonitorHMPCommand(mon, "system_powerdown", &info);
440 441

    VIR_FREE(info);
442
    return ret;
443 444
}

445 446 447
int
qemuMonitorTextSetLink(qemuMonitorPtr mon,
                       const char *name,
448
                       virDomainNetInterfaceLinkState state)
449
{
450 451 452 453 454 455 456 457 458 459
    char *info = NULL;
    char *cmd = NULL;
    const char *st_str = NULL;

    /* determine state */
    if (state == VIR_DOMAIN_NET_INTERFACE_LINK_STATE_DOWN)
        st_str = "off";
    else
        st_str = "on";

460
    if (virAsprintf(&cmd, "set_link %s %s", name, st_str) < 0)
461
        goto error;
462
    if (qemuMonitorHMPCommand(mon, cmd, &info) < 0)
463 464 465 466
        goto error;

    /* check if set_link command is supported */
    if (strstr(info, "\nunknown ")) {
467
        virReportError(VIR_ERR_OPERATION_UNSUPPORTED,
468 469
                       "%s",
                       _("\'set_link\' not supported by this qemu"));
470 471 472 473 474
        goto error;
    }

    /* check if qemu didn't reject device name */
    if (strstr(info, "\nDevice ")) {
475 476
        virReportError(VIR_ERR_OPERATION_FAILED,
                       "%s", _("device name rejected"));
477 478 479 480 481 482 483
        goto error;
    }

    VIR_FREE(info);
    VIR_FREE(cmd);
    return 0;

484
 error:
485 486 487 488 489
    VIR_FREE(info);
    VIR_FREE(cmd);

    return -1;
}
490

491 492
int qemuMonitorTextSystemReset(qemuMonitorPtr mon)
{
493
    char *info;
494 495 496
    int ret;

    ret = qemuMonitorHMPCommand(mon, "system_reset", &info);
497 498

    VIR_FREE(info);
499
    return ret;
500 501 502
}


503 504
int qemuMonitorTextGetCPUInfo(qemuMonitorPtr mon,
                              int **pids)
505 506 507 508 509 510
{
    char *qemucpus = NULL;
    char *line;
    pid_t *cpupids = NULL;
    size_t ncpupids = 0;

511
    if (qemuMonitorHMPCommand(mon, "info cpus", &qemucpus) < 0)
512 513 514 515 516 517 518 519 520 521 522 523 524
        return -1;

    /*
     * This is the gross format we're about to parse :-{
     *
     * (qemu) info cpus
     * * CPU #0: pc=0x00000000000f0c4a thread_id=30019
     *   CPU #1: pc=0x00000000fffffff0 thread_id=30020
     *   CPU #2: pc=0x00000000fffffff0 thread_id=30021
     *
     */
    line = qemucpus;
    do {
525
        char *offset = NULL;
526
        char *end = NULL;
527
        int tid = 0;
528 529 530 531 532 533 534 535 536 537

        /* Extract host Thread ID */
        if ((offset = strstr(line, "thread_id=")) == NULL)
            goto error;

        if (virStrToLong_i(offset + strlen("thread_id="), &end, 10, &tid) < 0)
            goto error;
        if (end == NULL || !c_isspace(*end))
            goto error;

538
        if (VIR_APPEND_ELEMENT_COPY(cpupids, ncpupids, tid) < 0)
539 540
            goto error;

541
        VIR_DEBUG("tid=%d", tid);
542 543 544 545 546 547 548 549 550 551 552 553

        /* Skip to next data line */
        line = strchr(offset, '\r');
        if (line == NULL)
            line = strchr(offset, '\n');
    } while (line != NULL);

    /* Validate we got data for all VCPUs we expected */
    VIR_FREE(qemucpus);
    *pids = cpupids;
    return ncpupids;

554
 error:
555 556 557 558 559 560 561 562 563 564
    VIR_FREE(qemucpus);
    VIR_FREE(cpupids);

    /* Returning 0 to indicate non-fatal failure, since
     * older QEMU does not have VCPU<->PID mapping and
     * we don't want to fail on that
     */
    return 0;
}

565 566

int qemuMonitorTextGetVirtType(qemuMonitorPtr mon,
567
                               virDomainVirtType *virtType)
568 569 570 571 572
{
    char *reply = NULL;

    *virtType = VIR_DOMAIN_VIRT_QEMU;

573
    if (qemuMonitorHMPCommand(mon, "info kvm", &reply) < 0)
574 575 576 577 578 579 580 581 582 583
        return -1;

    if (strstr(reply, "enabled"))
        *virtType = VIR_DOMAIN_VIRT_KVM;

    VIR_FREE(reply);
    return 0;
}


584 585 586 587 588 589
static int parseMemoryStat(char **text, unsigned int tag,
                           const char *search, virDomainMemoryStatPtr stat)
{
    char *dummy;
    unsigned long long value;

590
    if (STRPREFIX(*text, search)) {
591
        *text += strlen(search);
592 593
        if (virStrToLong_ull(*text, &dummy, 10, &value)) {
            VIR_DEBUG("error reading %s: %s", search, *text);
594 595 596 597
            return 0;
        }

        switch (tag) {
598 599 600 601 602
            /* Convert megabytes to kilobytes for libvirt */
            case VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON:
                value <<= 10;
                break;
            /* Convert bytes to kilobytes for libvirt */
603 604 605 606
            case VIR_DOMAIN_MEMORY_STAT_SWAP_IN:
            case VIR_DOMAIN_MEMORY_STAT_SWAP_OUT:
            case VIR_DOMAIN_MEMORY_STAT_UNUSED:
            case VIR_DOMAIN_MEMORY_STAT_AVAILABLE:
607
                value >>= 10;
608 609 610 611 612 613 614 615 616
        }
        stat->tag = tag;
        stat->val = value;
        return 1;
    }
    return 0;
}

/* The reply from the 'info balloon' command may contain additional memory
617
 * statistics in the form: 'actual=<val> [,<tag>=<val>]*'
618
 */
619 620 621
static int qemuMonitorParseBalloonInfo(char *text,
                                       virDomainMemoryStatPtr stats,
                                       unsigned int nr_stats)
622 623 624 625
{
    char *p = text;
    unsigned int nr_stats_found = 0;

626 627 628 629 630 631 632 633 634 635
    /* Since "actual=" always comes first in the returned string,
     * and sometime we only care about the value of "actual", such
     * as qemuMonitorGetBalloonInfo, we parse it outside of the
     * loop.
     */
    if (parseMemoryStat(&p, VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON,
                        "actual=", &stats[nr_stats_found]) == 1) {
        nr_stats_found++;
    }

636 637 638 639 640 641 642 643 644 645 646 647
    while (*p && nr_stats_found < nr_stats) {
        if (parseMemoryStat(&p, VIR_DOMAIN_MEMORY_STAT_SWAP_IN,
                            ",mem_swapped_in=", &stats[nr_stats_found]) ||
            parseMemoryStat(&p, VIR_DOMAIN_MEMORY_STAT_SWAP_OUT,
                            ",mem_swapped_out=", &stats[nr_stats_found]) ||
            parseMemoryStat(&p, VIR_DOMAIN_MEMORY_STAT_MAJOR_FAULT,
                            ",major_page_faults=", &stats[nr_stats_found]) ||
            parseMemoryStat(&p, VIR_DOMAIN_MEMORY_STAT_MINOR_FAULT,
                            ",minor_page_faults=", &stats[nr_stats_found]) ||
            parseMemoryStat(&p, VIR_DOMAIN_MEMORY_STAT_UNUSED,
                            ",free_mem=", &stats[nr_stats_found]) ||
            parseMemoryStat(&p, VIR_DOMAIN_MEMORY_STAT_AVAILABLE,
648
                            ",total_mem=", &stats[nr_stats_found]))
649 650
            nr_stats_found++;

651 652 653 654 655
        /* Skip to the next label.  When *p is ',' the last match attempt
         * failed so try to match the next ','.
         */
        if (*p == ',')
            p++;
656
        p = strchr(p, ',');
657 658 659 660
        if (!p) break;
    }
    return nr_stats_found;
}
661

662 663

/* The reply from QEMU contains 'ballon: actual=421' where value is in MB */
664
#define BALLOON_PREFIX "balloon: "
665

666 667 668
int
qemuMonitorTextGetBalloonInfo(qemuMonitorPtr mon,
                              unsigned long long *currmem)
669 670 671 672 673
{
    char *reply = NULL;
    int ret = -1;
    char *offset;

674
    if (qemuMonitorHMPCommand(mon, "info balloon", &reply) < 0)
675 676 677 678
        return -1;

    if ((offset = strstr(reply, BALLOON_PREFIX)) != NULL) {
        offset += strlen(BALLOON_PREFIX);
679
        virDomainMemoryStatStruct stats[1];
680 681

        if (qemuMonitorParseBalloonInfo(offset, stats, 1) == 0) {
682 683
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("unexpected balloon information '%s'"), reply);
684 685
            goto cleanup;
        }
686 687

        if (stats[0].tag != VIR_DOMAIN_MEMORY_STAT_ACTUAL_BALLOON) {
688 689
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("unexpected balloon information '%s'"), reply);
690 691 692 693
            goto cleanup;
        }

        *currmem = stats[0].val;
694 695 696 697 698 699 700 701
        ret = 1;
    } else {
        /* We don't raise an error here, since its to be expected that
         * many QEMU's don't support ballooning
         */
        ret = 0;
    }

702
 cleanup:
703 704 705 706
    VIR_FREE(reply);
    return ret;
}

707 708 709 710 711 712 713 714
int qemuMonitorTextGetMemoryStats(qemuMonitorPtr mon,
                                  virDomainMemoryStatPtr stats,
                                  unsigned int nr_stats)
{
    char *reply = NULL;
    int ret = 0;
    char *offset;

715
    if (qemuMonitorHMPCommand(mon, "info balloon", &reply) < 0)
716 717 718
        return -1;

    if ((offset = strstr(reply, BALLOON_PREFIX)) != NULL) {
719
        offset += strlen(BALLOON_PREFIX);
720
        ret = qemuMonitorParseBalloonInfo(offset, stats, nr_stats);
721 722 723 724 725 726
    }

    VIR_FREE(reply);
    return ret;
}

727

728
int qemuMonitorTextGetBlockInfo(qemuMonitorPtr mon,
729
                                virHashTablePtr table)
730
{
731
    struct qemuDomainDiskInfo *info = NULL;
732 733 734
    char *reply = NULL;
    int ret = -1;
    char *dummy;
735 736
    char *p, *eol;
    char *dev;
737 738
    int tmp;

739
    if (qemuMonitorHMPCommand(mon, "info block", &reply) < 0)
740 741 742
        goto cleanup;

    if (strstr(reply, "\ninfo ")) {
743 744 745
        virReportError(VIR_ERR_OPERATION_INVALID,
                       "%s",
                       _("info block not supported by this qemu"));
746 747 748 749 750 751 752 753 754 755 756 757 758
        goto cleanup;
    }

    /* The output looks like this:
     * drive-ide0-0-0: removable=0 file=<path> ro=0 drv=raw encrypted=0
     * drive-ide0-1-0: removable=1 locked=0 file=<path> ro=1 drv=raw encrypted=0
     */
    p = reply;

    while (*p) {
        if (STRPREFIX(p, QEMU_DRIVE_HOST_PREFIX))
            p += strlen(QEMU_DRIVE_HOST_PREFIX);

759 760 761
        eol = strchr(p, '\n');
        if (!eol)
            eol = p + strlen(p) - 1;
762

763 764 765
        dev = p;
        p = strchr(p, ':');
        if (p && p < eol && *(p + 1) == ' ') {
766
            if (VIR_ALLOC(info) < 0)
767
                goto cleanup;
768

769 770
            *p = '\0';
            p += 2;
771

772
            while (p < eol) {
773 774 775 776 777
                if (STRPREFIX(p, "removable=")) {
                    p += strlen("removable=");
                    if (virStrToLong_i(p, &dummy, 10, &tmp) == -1)
                        VIR_DEBUG("error reading removable: %s", p);
                    else
E
Eric Blake 已提交
778
                        info->removable = (tmp != 0);
779 780 781 782 783
                } else if (STRPREFIX(p, "locked=")) {
                    p += strlen("locked=");
                    if (virStrToLong_i(p, &dummy, 10, &tmp) == -1)
                        VIR_DEBUG("error reading locked: %s", p);
                    else
E
Eric Blake 已提交
784
                        info->locked = (tmp != 0);
785 786
                } else if (STRPREFIX(p, "tray-open=")) {
                    p += strlen("tray-open=");
787
                    if (virStrToLong_i(p, &dummy, 10, &tmp) == -1)
788
                        VIR_DEBUG("error reading tray-open: %s", p);
789
                    else
E
Eric Blake 已提交
790
                        info->tray_open = (tmp != 0);
791 792 793 794 795 796 797 798 799 800 801 802 803 804 805
                } else if (STRPREFIX(p, "io-status=")) {
                    char *end;
                    char c;

                    p += strlen("io-status=");
                    end = strchr(p, ' ');
                    if (!end || end > eol)
                        end = eol;

                    c = *end;
                    *end = '\0';
                    info->io_status = qemuMonitorBlockIOStatusToError(p);
                    *end = c;
                    if (info->io_status < 0)
                        goto cleanup;
806 807 808 809 810 811
                } else {
                    /* ignore because we don't parse all options */
                }

                /* skip to next label */
                p = strchr(p, ' ');
812 813
                if (!p)
                    break;
814 815 816
                p++;
            }

817 818 819 820
            if (virHashAddEntry(table, dev, info) < 0)
                goto cleanup;
            else
                info = NULL;
821 822
        }

823 824
        /* skip to the next line */
        p = eol + 1;
825 826
    }

827
    ret = 0;
828

829
 cleanup:
830
    VIR_FREE(info);
831 832 833 834
    VIR_FREE(reply);
    return ret;
}

835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850

int
qemuMonitorTextGetAllBlockStatsInfo(qemuMonitorPtr mon,
                                    virHashTablePtr hash)
{
    qemuBlockStatsPtr stats = NULL;
    char *info = NULL;
    char *dev_name;
    char **lines = NULL;
    char **values = NULL;
    char *line;
    char *value;
    char *key;
    size_t i;
    size_t j;
    int ret = -1;
851 852
    int nstats;
    int maxstats = 0;
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 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909

    if (qemuMonitorHMPCommand(mon, "info blockstats", &info) < 0)
        goto cleanup;

    /* If the command isn't supported then qemu prints the supported info
     * commands, so the output starts "info ".  Since this is unlikely to be
     * the name of a block device, we can use this to detect if qemu supports
     * the command. */
    if (strstr(info, "\ninfo ")) {
        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                       _("'info blockstats' not supported by this qemu"));
        goto cleanup;
    }

    /* The output format for both qemu & KVM is:
     *   blockdevice: rd_bytes=% wr_bytes=% rd_operations=% wr_operations=%
     *   (repeated for each block device)
     * where '%' is a 64 bit number.
     */
    if (!(lines = virStringSplit(info, "\n", 0)))
        goto cleanup;

    for (i = 0; lines[i] && *lines[i]; i++) {
        line = lines[i];

        if (VIR_ALLOC(stats) < 0)
            goto cleanup;

        /* set the entries to -1, the JSON monitor enforces them, but it would
         * be overly complex to achieve this here */
        stats->rd_req = -1;
        stats->rd_bytes = -1;
        stats->wr_req = -1;
        stats->wr_bytes = -1;
        stats->rd_total_times = -1;
        stats->wr_total_times = -1;
        stats->flush_req = -1;
        stats->flush_total_times = -1;

        /* extract device name and make sure that it's followed by
         * a colon and space */
        dev_name = line;
        if (!(line = strchr(line, ':')) && line[1] != ' ') {
            virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                           _("info blockstats reply was malformed"));
            goto cleanup;
        }

        *line = '\0';
        line += 2;

        if (STRPREFIX(dev_name, QEMU_DRIVE_HOST_PREFIX))
            dev_name += strlen(QEMU_DRIVE_HOST_PREFIX);

        if (!(values = virStringSplit(line, " ", 0)))
            goto cleanup;

910 911
        nstats = 0;

912 913 914 915 916 917 918 919 920 921 922 923 924 925
        for (j = 0; values[j] && *values[j]; j++) {
            key = values[j];

            if (!(value = strchr(key, '='))) {
                virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
                               _("info blockstats entry was malformed"));
                goto cleanup;
            }

            *value = '\0';
            value++;

#define QEMU_MONITOR_TEXT_READ_BLOCK_STAT(NAME, VAR)                           \
            if (STREQ(key, NAME)) {                                            \
926
                nstats++;                                                      \
927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949
                if (virStrToLong_ll(value, NULL, 10, &VAR) < 0) {              \
                    virReportError(VIR_ERR_INTERNAL_ERROR,                     \
                                   _("'info blockstats' contains malformed "   \
                                     "parameter '%s' value '%s'"), NAME, value);\
                    goto cleanup;                                              \
                }                                                              \
                continue;                                                      \
            }

            QEMU_MONITOR_TEXT_READ_BLOCK_STAT("rd_bytes", stats->rd_bytes);
            QEMU_MONITOR_TEXT_READ_BLOCK_STAT("wr_bytes", stats->wr_bytes);
            QEMU_MONITOR_TEXT_READ_BLOCK_STAT("rd_operations", stats->rd_req);
            QEMU_MONITOR_TEXT_READ_BLOCK_STAT("wr_operations", stats->wr_req);
            QEMU_MONITOR_TEXT_READ_BLOCK_STAT("rd_total_time_ns", stats->rd_total_times);
            QEMU_MONITOR_TEXT_READ_BLOCK_STAT("wr_total_time_ns", stats->wr_total_times);
            QEMU_MONITOR_TEXT_READ_BLOCK_STAT("flush_operations", stats->flush_req);
            QEMU_MONITOR_TEXT_READ_BLOCK_STAT("flush_total_time_ns", stats->flush_total_times);
#undef QEMU_MONITOR_TEXT_READ_BLOCK_STAT

            /* log if we get statistic element different from the above */
            VIR_DEBUG("unknown block stat field '%s'", key);
        }

950 951 952
        if (nstats > maxstats)
            maxstats = nstats;

953 954 955 956 957 958 959 960
        if (virHashAddEntry(hash, dev_name, stats) < 0)
            goto cleanup;
        stats = NULL;

        virStringFreeList(values);
        values = NULL;
    }

961
    ret = maxstats;
962 963 964 965 966 967 968 969 970

 cleanup:
    virStringFreeList(lines);
    virStringFreeList(values);
    VIR_FREE(stats);
    VIR_FREE(info);
    return ret;
}

E
Eric Blake 已提交
971 972
/* Return 0 on success, -1 on failure, or -2 if not supported.  Size
 * is in bytes. */
973 974 975 976 977 978 979 980
int qemuMonitorTextBlockResize(qemuMonitorPtr mon,
                               const char *device,
                               unsigned long long size)
{
    char *cmd = NULL;
    char *reply = NULL;
    int ret = -1;

981
    if (virAsprintf(&cmd, "block_resize %s %lluB", device, size) < 0)
982 983
        goto cleanup;

984
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
985 986 987 988 989 990 991 992 993
        goto cleanup;

    if (strstr(reply, "unknown command:")) {
        ret = -2;
        goto cleanup;
    }

    ret = 0;

994
 cleanup:
995 996 997 998
    VIR_FREE(cmd);
    VIR_FREE(reply);
    return ret;
}
999

1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
static int
qemuMonitorSendVNCPassphrase(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
                             qemuMonitorMessagePtr msg,
                             const char *data ATTRIBUTE_UNUSED,
                             size_t len ATTRIBUTE_UNUSED,
                             void *opaque)
{
    char *passphrase = opaque;
    size_t passphrase_len = strlen(passphrase);

    /* Enlarge transmit buffer to allow for the extra data
     * to be sent back */
    if (VIR_REALLOC_N(msg->txBuffer,
1013
                      msg->txLength + passphrase_len + 1 + 1) < 0)
1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026
        return -1;

    /* Queue the password for sending */
    memcpy(msg->txBuffer + msg->txLength,
           passphrase, passphrase_len);
    msg->txLength += passphrase_len;
    msg->txBuffer[msg->txLength] = '\r';
    msg->txLength++;
    msg->txBuffer[msg->txLength] = '\0';

    return 0;
}

1027 1028
int qemuMonitorTextSetVNCPassword(qemuMonitorPtr mon,
                                  const char *password)
1029 1030
{
    char *info = NULL;
1031

1032 1033 1034 1035
    if (qemuMonitorTextCommandWithHandler(mon, "change vnc password",
                                          qemuMonitorSendVNCPassphrase,
                                          (char *)password,
                                          -1, &info) < 0) {
1036 1037
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       "%s", _("setting VNC password failed"));
1038 1039 1040 1041 1042
        return -1;
    }
    VIR_FREE(info);
    return 0;
}
1043

1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054
/* Returns -1 on error, -2 if not supported */
int qemuMonitorTextSetPassword(qemuMonitorPtr mon,
                               const char *protocol,
                               const char *password,
                               const char *action_if_connected)
{
    char *cmd = NULL;
    char *reply = NULL;
    int ret = -1;

    if (virAsprintf(&cmd, "set_password %s \"%s\" %s",
1055
                    protocol, password, action_if_connected) < 0)
1056 1057
        goto cleanup;

1058
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
1059 1060 1061 1062 1063 1064 1065 1066 1067
        goto cleanup;

    if (strstr(reply, "unknown command:")) {
        ret = -2;
        goto cleanup;
    }

    ret = 0;

1068
 cleanup:
1069 1070 1071 1072 1073
    VIR_FREE(reply);
    VIR_FREE(cmd);
    return ret;
}

1074
/* Returns -1 on error, -2 if not supported */
1075 1076 1077 1078 1079 1080 1081 1082 1083
int qemuMonitorTextExpirePassword(qemuMonitorPtr mon,
                                  const char *protocol,
                                  const char *expire_time)
{
    char *cmd = NULL;
    char *reply = NULL;
    int ret = -1;

    if (virAsprintf(&cmd, "expire_password %s %s",
1084
                    protocol, expire_time) < 0)
1085 1086
        goto cleanup;

1087
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
1088 1089 1090
        goto cleanup;

    if (strstr(reply, "unknown command:")) {
1091
        ret = -2;
1092 1093 1094 1095 1096
        goto cleanup;
    }

    ret = 0;

1097
 cleanup:
1098 1099 1100 1101 1102
    VIR_FREE(reply);
    VIR_FREE(cmd);
    return ret;
}

1103 1104 1105 1106

int
qemuMonitorTextSetBalloon(qemuMonitorPtr mon,
                          unsigned long long newmem)
1107 1108 1109 1110 1111 1112 1113 1114 1115
{
    char *cmd;
    char *reply = NULL;
    int ret = -1;

    /*
     * 'newmem' is in KB, QEMU monitor works in MB, and we all wish
     * we just worked in bytes with unsigned long long everywhere.
     */
1116
    if (virAsprintf(&cmd, "balloon %llu", VIR_DIV_UP(newmem, 1024)) < 0)
1117 1118
        return -1;

1119
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
1120 1121 1122 1123 1124 1125 1126
        VIR_FREE(cmd);
        return -1;
    }
    VIR_FREE(cmd);

    /* If the command failed qemu prints: 'unknown command'
     * No message is printed on success it seems */
1127
    if (strstr(reply, "unknown command:")) {
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137
        /* Don't set error - it is expected memory balloon fails on many qemu */
        ret = 0;
    } else {
        ret = 1;
    }

    VIR_FREE(reply);
    return ret;
}

1138 1139

/*
1140
 * Returns: 0 if CPU hotplug not supported, +1 if CPU hotplug worked
1141 1142
 * or -1 on failure
 */
1143
int qemuMonitorTextSetCPU(qemuMonitorPtr mon, int cpu, bool online)
1144 1145 1146 1147 1148
{
    char *cmd;
    char *reply = NULL;
    int ret = -1;

1149
    if (virAsprintf(&cmd, "cpu_set %d %s", cpu, online ? "online" : "offline") < 0)
1150 1151
        return -1;

1152
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0) {
1153 1154 1155 1156 1157 1158 1159
        VIR_FREE(cmd);
        return -1;
    }
    VIR_FREE(cmd);

    /* If the command failed qemu prints: 'unknown command'
     * No message is printed on success it seems */
1160
    if (strstr(reply, "unknown command:")) {
1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171
        /* Don't set error - it is expected CPU onlining fails on many qemu - caller will handle */
        ret = 0;
    } else {
        ret = 1;
    }

    VIR_FREE(reply);
    return ret;
}


1172 1173 1174 1175 1176 1177 1178 1179
/**
 * Run HMP command to eject a media from ejectable device.
 *
 * Returns:
 *      -2 on error, when the tray is locked
 *      -1 on all other errors
 *      0 on success
 */
1180
int qemuMonitorTextEjectMedia(qemuMonitorPtr mon,
1181
                              const char *dev_name,
1182
                              bool force)
1183 1184 1185 1186 1187
{
    char *cmd = NULL;
    char *reply = NULL;
    int ret = -1;

1188
    if (virAsprintf(&cmd, "eject %s%s", force ? "-f " : "", dev_name) < 0)
1189 1190
        goto cleanup;

1191
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
1192 1193 1194 1195 1196
        goto cleanup;

    /* If the command failed qemu prints:
     * device not found, device is locked ...
     * No message is printed on success it seems */
1197
    if (c_strcasestr(reply, "device ")) {
1198 1199
        if (c_strcasestr(reply, "is locked"))
            ret = -2;
1200 1201
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("could not eject media on %s: %s"), dev_name, reply);
1202 1203 1204 1205 1206
        goto cleanup;
    }

    ret = 0;

1207
 cleanup:
1208 1209 1210 1211 1212 1213
    VIR_FREE(reply);
    VIR_FREE(cmd);
    return ret;
}


1214
int qemuMonitorTextChangeMedia(qemuMonitorPtr mon,
1215
                               const char *dev_name,
1216 1217
                               const char *newmedia,
                               const char *format ATTRIBUTE_UNUSED)
1218 1219 1220 1221 1222 1223
{
    char *cmd = NULL;
    char *reply = NULL;
    char *safepath = NULL;
    int ret = -1;

1224
    if (!(safepath = qemuMonitorEscapeArg(newmedia)))
1225 1226
        goto cleanup;

1227
    if (virAsprintf(&cmd, "change %s \"%s\"", dev_name, safepath) < 0)
1228 1229
        goto cleanup;

1230
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
1231 1232 1233 1234 1235
        goto cleanup;

    /* If the command failed qemu prints:
     * device not found, device is locked ...
     * No message is printed on success it seems */
1236
    if (c_strcasestr(reply, "device ")) {
1237 1238
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("could not change media on %s: %s"), dev_name, reply);
1239 1240 1241
        goto cleanup;
    }

R
Ryan Harper 已提交
1242
    /* Could not open message indicates bad filename */
1243
    if (strstr(reply, "Could not open ")) {
1244 1245
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("could not change media on %s: %s"), dev_name, reply);
R
Ryan Harper 已提交
1246 1247 1248
        goto cleanup;
    }

1249 1250
    ret = 0;

1251
 cleanup:
1252 1253 1254 1255 1256 1257
    VIR_FREE(reply);
    VIR_FREE(cmd);
    VIR_FREE(safepath);
    return ret;
}

1258 1259 1260 1261 1262
static int qemuMonitorTextSaveMemory(qemuMonitorPtr mon,
                                     const char *cmdtype,
                                     unsigned long long offset,
                                     size_t length,
                                     const char *path)
1263 1264 1265 1266 1267 1268
{
    char *cmd = NULL;
    char *reply = NULL;
    char *safepath = NULL;
    int ret = -1;

1269
    if (!(safepath = qemuMonitorEscapeArg(path)))
1270 1271
        goto cleanup;

1272
    if (virAsprintf(&cmd, "%s %llu %zi \"%s\"", cmdtype, offset, length, safepath) < 0)
1273 1274
        goto cleanup;

1275
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
1276 1277 1278 1279 1280 1281
        goto cleanup;

    /* XXX what is printed on failure ? */

    ret = 0;

1282
 cleanup:
1283 1284 1285 1286 1287 1288 1289
    VIR_FREE(cmd);
    VIR_FREE(reply);
    VIR_FREE(safepath);
    return ret;
}


1290 1291 1292 1293
int qemuMonitorTextSaveVirtualMemory(qemuMonitorPtr mon,
                                     unsigned long long offset,
                                     size_t length,
                                     const char *path)
1294
{
1295
    return qemuMonitorTextSaveMemory(mon, "memsave", offset, length, path);
1296 1297
}

1298 1299 1300 1301
int qemuMonitorTextSavePhysicalMemory(qemuMonitorPtr mon,
                                      unsigned long long offset,
                                      size_t length,
                                      const char *path)
1302
{
1303
    return qemuMonitorTextSaveMemory(mon, "pmemsave", offset, length, path);
1304
}
1305 1306


1307 1308
int qemuMonitorTextSetMigrationSpeed(qemuMonitorPtr mon,
                                     unsigned long bandwidth)
1309 1310 1311 1312 1313
{
    char *cmd = NULL;
    char *info = NULL;
    int ret = -1;

1314
    if (virAsprintf(&cmd, "migrate_set_speed %lum", bandwidth) < 0)
1315 1316
        goto cleanup;

1317
    if (qemuMonitorHMPCommand(mon, cmd, &info) < 0)
1318 1319 1320 1321
        goto cleanup;

    ret = 0;

1322
 cleanup:
1323 1324 1325 1326
    VIR_FREE(info);
    VIR_FREE(cmd);
    return ret;
}
1327 1328


1329 1330 1331 1332 1333 1334 1335
int qemuMonitorTextSetMigrationDowntime(qemuMonitorPtr mon,
                                        unsigned long long downtime)
{
    char *cmd = NULL;
    char *info = NULL;
    int ret = -1;

1336
    if (virAsprintf(&cmd, "migrate_set_downtime %llums", downtime) < 0)
1337 1338
        goto cleanup;

1339
    if (qemuMonitorHMPCommand(mon, cmd, &info) < 0)
1340 1341 1342 1343
        goto cleanup;

    ret = 0;

1344
 cleanup:
1345 1346 1347 1348 1349 1350
    VIR_FREE(info);
    VIR_FREE(cmd);
    return ret;
}


1351 1352 1353 1354
#define MIGRATION_PREFIX "Migration status: "
#define MIGRATION_TRANSFER_PREFIX "transferred ram: "
#define MIGRATION_REMAINING_PREFIX "remaining ram: "
#define MIGRATION_TOTAL_PREFIX "total ram: "
1355 1356 1357
#define MIGRATION_DISK_TRANSFER_PREFIX "transferred disk: "
#define MIGRATION_DISK_REMAINING_PREFIX "remaining disk: "
#define MIGRATION_DISK_TOTAL_PREFIX "total disk: "
1358

1359
int qemuMonitorTextGetMigrationStatus(qemuMonitorPtr mon,
1360 1361
                                      qemuMonitorMigrationStatusPtr status)
{
1362 1363 1364 1365 1366
    char *reply;
    char *tmp;
    char *end;
    int ret = -1;

1367
    memset(status, 0, sizeof(*status));
1368

1369
    if (qemuMonitorHMPCommand(mon, "info migrate", &reply) < 0)
1370 1371 1372 1373
        return -1;

    if ((tmp = strstr(reply, MIGRATION_PREFIX)) != NULL) {
        tmp += strlen(MIGRATION_PREFIX);
P
Paolo Bonzini 已提交
1374
        end = strchr(tmp, '\r');
1375
        if (end == NULL) {
1376 1377
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("unexpected migration status in %s"), reply);
1378 1379
            goto cleanup;
        }
1380 1381
        *end = '\0';

1382 1383
        status->status = qemuMonitorMigrationStatusTypeFromString(tmp);
        if (status->status < 0) {
1384 1385
            virReportError(VIR_ERR_INTERNAL_ERROR,
                           _("unexpected migration status in %s"), reply);
1386 1387 1388
            goto cleanup;
        }

1389
        if (status->status == QEMU_MONITOR_MIGRATION_STATUS_ACTIVE) {
1390 1391 1392 1393 1394 1395
            tmp = end + 1;

            if (!(tmp = strstr(tmp, MIGRATION_TRANSFER_PREFIX)))
                goto done;
            tmp += strlen(MIGRATION_TRANSFER_PREFIX);

1396 1397
            if (virStrToLong_ull(tmp, &end, 10,
                                 &status->ram_transferred) < 0) {
1398 1399 1400
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("cannot parse migration data transferred "
                                 "statistic %s"), tmp);
1401 1402
                goto cleanup;
            }
1403
            status->ram_transferred *= 1024;
1404
            tmp = end;
1405 1406 1407 1408 1409

            if (!(tmp = strstr(tmp, MIGRATION_REMAINING_PREFIX)))
                goto done;
            tmp += strlen(MIGRATION_REMAINING_PREFIX);

1410
            if (virStrToLong_ull(tmp, &end, 10, &status->ram_remaining) < 0) {
1411 1412 1413
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("cannot parse migration data remaining "
                                 "statistic %s"), tmp);
1414 1415
                goto cleanup;
            }
1416
            status->ram_remaining *= 1024;
1417
            tmp = end;
1418 1419 1420 1421 1422

            if (!(tmp = strstr(tmp, MIGRATION_TOTAL_PREFIX)))
                goto done;
            tmp += strlen(MIGRATION_TOTAL_PREFIX);

1423
            if (virStrToLong_ull(tmp, &end, 10, &status->ram_total) < 0) {
1424 1425 1426
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("cannot parse migration data total "
                                 "statistic %s"), tmp);
1427 1428
                goto cleanup;
            }
1429
            status->ram_total *= 1024;
1430 1431 1432 1433 1434 1435 1436 1437 1438
            tmp = end;

            /*
             * Check for Optional Disk Migration status
             */
            if (!(tmp = strstr(tmp, MIGRATION_DISK_TRANSFER_PREFIX)))
                goto done;
            tmp += strlen(MIGRATION_DISK_TRANSFER_PREFIX);

1439 1440
            if (virStrToLong_ull(tmp, &end, 10,
                                 &status->disk_transferred) < 0) {
1441 1442 1443
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("cannot parse disk migration data "
                                 "transferred statistic %s"), tmp);
1444 1445
                goto cleanup;
            }
1446
            status->disk_transferred *= 1024;
1447 1448 1449 1450 1451
            tmp = end;

            if (!(tmp = strstr(tmp, MIGRATION_DISK_REMAINING_PREFIX)))
                goto done;
            tmp += strlen(MIGRATION_DISK_REMAINING_PREFIX);
1452

1453
            if (virStrToLong_ull(tmp, &end, 10, &status->disk_remaining) < 0) {
1454 1455 1456
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("cannot parse disk migration data remaining "
                                 "statistic %s"), tmp);
1457 1458
                goto cleanup;
            }
1459
            status->disk_remaining *= 1024;
1460 1461 1462 1463 1464 1465
            tmp = end;

            if (!(tmp = strstr(tmp, MIGRATION_DISK_TOTAL_PREFIX)))
                goto done;
            tmp += strlen(MIGRATION_DISK_TOTAL_PREFIX);

1466
            if (virStrToLong_ull(tmp, &end, 10, &status->disk_total) < 0) {
1467 1468 1469
                virReportError(VIR_ERR_INTERNAL_ERROR,
                               _("cannot parse disk migration data total "
                                 "statistic %s"), tmp);
1470 1471
                goto cleanup;
            }
1472
            status->disk_total *= 1024;
1473 1474 1475
        }
    }

1476
 done:
1477 1478
    ret = 0;

1479
 cleanup:
1480
    VIR_FREE(reply);
1481 1482
    if (ret < 0)
        memset(status, 0, sizeof(*status));
1483 1484
    return ret;
}
1485 1486


1487 1488 1489
int qemuMonitorTextMigrate(qemuMonitorPtr mon,
                           unsigned int flags,
                           const char *dest)
1490 1491 1492 1493
{
    char *cmd = NULL;
    char *info = NULL;
    int ret = -1;
1494
    char *safedest = qemuMonitorEscapeArg(dest);
1495
    virBuffer extra = VIR_BUFFER_INITIALIZER;
C
Chris Lalancette 已提交
1496
    char *extrastr = NULL;
1497

1498
    if (!safedest)
1499 1500
        return -1;

1501
    if (flags & QEMU_MONITOR_MIGRATE_BACKGROUND)
1502
        virBufferAddLit(&extra, " -d");
1503
    if (flags & QEMU_MONITOR_MIGRATE_NON_SHARED_DISK)
1504
        virBufferAddLit(&extra, " -b");
1505
    if (flags & QEMU_MONITOR_MIGRATE_NON_SHARED_INC)
1506
        virBufferAddLit(&extra, " -i");
1507
    if (virBufferCheckError(&extra) < 0)
C
Chris Lalancette 已提交
1508 1509 1510 1511
        goto cleanup;

    extrastr = virBufferContentAndReset(&extra);
    if (virAsprintf(&cmd, "migrate %s\"%s\"", extrastr ? extrastr : "",
1512
                    safedest) < 0)
1513 1514
        goto cleanup;

1515
    if (qemuMonitorHMPCommand(mon, cmd, &info) < 0)
1516 1517 1518 1519
        goto cleanup;

    /* Now check for "fail" in the output string */
    if (strstr(info, "fail") != NULL) {
1520 1521
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("migration to '%s' failed: %s"), dest, info);
1522 1523 1524 1525 1526
        goto cleanup;
    }
    /* If the command isn't supported then qemu prints:
     * unknown command: migrate" */
    if (strstr(info, "unknown command:")) {
1527 1528
        virReportError(VIR_ERR_OPERATION_INVALID,
                       _("migration to '%s' not supported by this qemu: %s"), dest, info);
1529 1530 1531 1532 1533 1534
        goto cleanup;
    }


    ret = 0;

1535
 cleanup:
C
Chris Lalancette 已提交
1536
    VIR_FREE(extrastr);
1537
    VIR_FREE(safedest);
1538 1539 1540 1541 1542
    VIR_FREE(info);
    VIR_FREE(cmd);
    return ret;
}

1543
int qemuMonitorTextMigrateCancel(qemuMonitorPtr mon)
1544 1545
{
    char *info = NULL;
1546
    int ret;
1547

1548
    ret = qemuMonitorHMPCommand(mon, "migrate_cancel", &info);
1549

1550 1551
    VIR_FREE(info);
    return ret;
1552
}
1553

1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566

int qemuMonitorTextGraphicsRelocate(qemuMonitorPtr mon,
                                    int type,
                                    const char *hostname,
                                    int port,
                                    int tlsPort,
                                    const char *tlsSubject)
{
    char *cmd;
    char *info = NULL;

    if (virAsprintf(&cmd, "client_migrate_info %s %s %d %d %s",
                    type == VIR_DOMAIN_GRAPHICS_TYPE_SPICE ? "spice" : "vnc",
1567
                    hostname, port, tlsPort, tlsSubject ? tlsSubject : "") < 0)
1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580
        return -1;

    if (qemuMonitorHMPCommand(mon, cmd, &info) < 0) {
        VIR_FREE(cmd);
        return -1;
    }
    VIR_FREE(cmd);
    VIR_FREE(info);

    return 0;
}


1581 1582
int qemuMonitorTextAddUSBDisk(qemuMonitorPtr mon,
                              const char *path)
1583 1584 1585 1586 1587 1588
{
    char *cmd = NULL;
    char *safepath;
    int ret = -1;
    char *info = NULL;

1589
    safepath = qemuMonitorEscapeArg(path);
1590
    if (!safepath)
1591 1592
        return -1;

1593
    if (virAsprintf(&cmd, "usb_add disk:%s", safepath) < 0)
1594 1595
        goto cleanup;

1596
    if (qemuMonitorHMPCommand(mon, cmd, &info) < 0)
1597 1598 1599 1600 1601
        goto cleanup;

    /* If the command failed qemu prints:
     * Could not add ... */
    if (strstr(info, "Could not add ")) {
1602 1603
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("unable to add USB disk %s: %s"), path, info);
1604 1605 1606 1607 1608
        goto cleanup;
    }

    ret = 0;

1609
 cleanup:
1610 1611
    VIR_FREE(cmd);
    VIR_FREE(safepath);
1612
    VIR_FREE(info);
1613 1614
    return ret;
}
1615 1616


1617 1618
static int qemuMonitorTextAddUSBDevice(qemuMonitorPtr mon,
                                       const char *addr)
1619 1620 1621 1622 1623
{
    char *cmd;
    char *reply = NULL;
    int ret = -1;

1624
    if (virAsprintf(&cmd, "usb_add %s", addr) < 0)
1625 1626
        return -1;

1627
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
1628 1629 1630 1631 1632
        goto cleanup;

    /* If the command failed qemu prints:
     * Could not add ... */
    if (strstr(reply, "Could not add ")) {
1633 1634
        virReportError(VIR_ERR_OPERATION_FAILED,
                       "%s", _("adding usb device failed"));
1635 1636 1637 1638 1639
        goto cleanup;
    }

    ret = 0;

1640
 cleanup:
1641 1642 1643 1644 1645 1646
    VIR_FREE(cmd);
    VIR_FREE(reply);
    return ret;
}


1647 1648 1649
int qemuMonitorTextAddUSBDeviceExact(qemuMonitorPtr mon,
                                     int bus,
                                     int dev)
1650 1651 1652 1653
{
    int ret;
    char *addr;

1654
    if (virAsprintf(&addr, "host:%.3d.%.3d", bus, dev) < 0)
1655 1656
        return -1;

1657
    ret = qemuMonitorTextAddUSBDevice(mon, addr);
1658 1659 1660 1661 1662

    VIR_FREE(addr);
    return ret;
}

1663 1664 1665
int qemuMonitorTextAddUSBDeviceMatch(qemuMonitorPtr mon,
                                     int vendor,
                                     int product)
1666 1667 1668 1669
{
    int ret;
    char *addr;

1670
    if (virAsprintf(&addr, "host:%.4x:%.4x", vendor, product) < 0)
1671 1672
        return -1;

1673
    ret = qemuMonitorTextAddUSBDevice(mon, addr);
1674 1675 1676 1677

    VIR_FREE(addr);
    return ret;
}
1678 1679 1680


static int
1681
qemuMonitorTextParsePCIAddReply(qemuMonitorPtr mon ATTRIBUTE_UNUSED,
1682
                                const char *reply,
1683
                                virDevicePCIAddress *addr)
1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699
{
    char *s, *e;

    /* If the command succeeds qemu prints:
     * OK bus 0, slot XXX...
     * or
     * OK domain 0, bus 0, slot XXX
     */
    if (!(s = strstr(reply, "OK ")))
        return -1;

    s += 3;

    if (STRPREFIX(s, "domain ")) {
        s += strlen("domain ");

1700
        if (virStrToLong_ui(s, &e, 10, &addr->domain) == -1) {
1701
            VIR_WARN("Unable to parse domain number '%s'", s);
1702 1703 1704 1705
            return -1;
        }

        if (!STRPREFIX(e, ", ")) {
1706
            VIR_WARN("Expected ', ' parsing pci_add reply '%s'", s);
1707 1708 1709 1710 1711 1712
            return -1;
        }
        s = e + 2;
    }

    if (!STRPREFIX(s, "bus ")) {
1713
        VIR_WARN("Expected 'bus ' parsing pci_add reply '%s'", s);
1714 1715 1716 1717
        return -1;
    }
    s += strlen("bus ");

1718
    if (virStrToLong_ui(s, &e, 10, &addr->bus) == -1) {
1719
        VIR_WARN("Unable to parse bus number '%s'", s);
1720 1721 1722 1723
        return -1;
    }

    if (!STRPREFIX(e, ", ")) {
1724
        VIR_WARN("Expected ', ' parsing pci_add reply '%s'", s);
1725 1726 1727 1728 1729
        return -1;
    }
    s = e + 2;

    if (!STRPREFIX(s, "slot ")) {
1730
        VIR_WARN("Expected 'slot ' parsing pci_add reply '%s'", s);
1731 1732 1733 1734
        return -1;
    }
    s += strlen("slot ");

1735
    if (virStrToLong_ui(s, &e, 10, &addr->slot) == -1) {
1736
        VIR_WARN("Unable to parse slot number '%s'", s);
1737 1738 1739 1740 1741 1742 1743
        return -1;
    }

    return 0;
}


1744
int qemuMonitorTextAddPCIHostDevice(qemuMonitorPtr mon,
1745 1746
                                    virDevicePCIAddress *hostAddr,
                                    virDevicePCIAddress *guestAddr)
1747 1748 1749 1750 1751
{
    char *cmd;
    char *reply = NULL;
    int ret = -1;

1752
    memset(guestAddr, 0, sizeof(*guestAddr));
1753

1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767
    if (hostAddr->domain) {
        /* if domain > 0, the caller has already verified that this qemu
         * supports specifying domain in pci_add command
         */
        if (virAsprintf(&cmd,
                        "pci_add pci_addr=auto host host=%.4x:%.2x:%.2x.%.1x",
                        hostAddr->domain, hostAddr->bus,
                        hostAddr->slot, hostAddr->function) < 0)
            goto cleanup;
    } else {
        if (virAsprintf(&cmd, "pci_add pci_addr=auto host host=%.2x:%.2x.%.1x",
                        hostAddr->bus, hostAddr->slot, hostAddr->function) < 0)
            goto cleanup;
    }
1768

1769
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
1770 1771 1772
        goto cleanup;

    if (strstr(reply, "invalid type: host")) {
1773 1774
        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                       _("PCI device assignment is not supported by this version of qemu"));
1775 1776 1777
        goto cleanup;
    }

1778
    if (qemuMonitorTextParsePCIAddReply(mon, reply, guestAddr) < 0) {
1779 1780
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("parsing pci_add reply failed: %s"), reply);
1781 1782 1783 1784 1785
        goto cleanup;
    }

    ret = 0;

1786
 cleanup:
1787 1788 1789 1790 1791
    VIR_FREE(cmd);
    VIR_FREE(reply);
    return ret;
}

1792

1793 1794 1795
int qemuMonitorTextAddPCIDisk(qemuMonitorPtr mon,
                              const char *path,
                              const char *bus,
1796
                              virDevicePCIAddress *guestAddr)
1797
{
1798 1799 1800
    char *cmd = NULL;
    char *reply = NULL;
    char *safe_path = NULL;
1801
    bool tryOldSyntax = false;
1802 1803
    int ret = -1;

1804
    safe_path = qemuMonitorEscapeArg(path);
1805
    if (!safe_path)
1806 1807
        return -1;

1808
 try_command:
1809
    if (virAsprintf(&cmd, "pci_add %s storage file=%s,if=%s",
1810
                    (tryOldSyntax ? "0": "pci_addr=auto"), safe_path, bus) < 0)
1811 1812
        goto cleanup;

1813
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
1814 1815
        goto cleanup;

1816
    if (qemuMonitorTextParsePCIAddReply(mon, reply, guestAddr) < 0) {
1817 1818 1819
        if (!tryOldSyntax && strstr(reply, "invalid char in expression")) {
            VIR_FREE(reply);
            VIR_FREE(cmd);
1820
            tryOldSyntax = true;
1821 1822 1823
            goto try_command;
        }

1824 1825
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("adding %s disk failed %s: %s"), bus, path, reply);
1826 1827 1828 1829 1830
        goto cleanup;
    }

    ret = 0;

1831
 cleanup:
1832 1833 1834 1835 1836 1837 1838
    VIR_FREE(safe_path);
    VIR_FREE(cmd);
    VIR_FREE(reply);
    return ret;
}


1839 1840
int qemuMonitorTextAddPCINetwork(qemuMonitorPtr mon,
                                 const char *nicstr,
1841
                                 virDevicePCIAddress *guestAddr)
1842 1843 1844 1845 1846
{
    char *cmd;
    char *reply = NULL;
    int ret = -1;

1847
    if (virAsprintf(&cmd, "pci_add pci_addr=auto nic %s", nicstr) < 0)
1848 1849
        return -1;

1850
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
1851 1852
        goto cleanup;

1853
    if (qemuMonitorTextParsePCIAddReply(mon, reply, guestAddr) < 0) {
1854 1855
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("parsing pci_add reply failed: %s"), reply);
1856 1857 1858 1859 1860
        goto cleanup;
    }

    ret = 0;

1861
 cleanup:
1862 1863 1864 1865 1866
    VIR_FREE(reply);
    VIR_FREE(cmd);
    return ret;
}

1867

1868
int qemuMonitorTextRemovePCIDevice(qemuMonitorPtr mon,
1869
                                   virDevicePCIAddress *guestAddr)
1870 1871 1872
{
    char *cmd = NULL;
    char *reply = NULL;
1873
    bool tryOldSyntax = false;
1874 1875
    int ret = -1;

1876
 try_command:
1877
    if (tryOldSyntax) {
1878
        if (virAsprintf(&cmd, "pci_del 0 %.2x", guestAddr->slot) < 0)
1879 1880
            goto cleanup;
    } else {
1881
        /* XXX function ? */
1882
        if (virAsprintf(&cmd, "pci_del pci_addr=%.4x:%.2x:%.2x",
1883
                        guestAddr->domain, guestAddr->bus, guestAddr->slot) < 0)
1884 1885 1886
            goto cleanup;
    }

1887
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
1888 1889 1890 1891 1892 1893 1894
        goto cleanup;

    /* Syntax changed when KVM merged PCI hotplug upstream to QEMU,
     * so check for an error message from old KVM indicating the
     * need to try the old syntax */
    if (!tryOldSyntax &&
        strstr(reply, "extraneous characters")) {
1895
        tryOldSyntax = true;
1896 1897 1898 1899 1900 1901 1902 1903
        VIR_FREE(reply);
        VIR_FREE(cmd);
        goto try_command;
    }
    /* If the command fails due to a wrong slot qemu prints: invalid slot,
     * nothing is printed on success */
    if (strstr(reply, "invalid slot") ||
        strstr(reply, "Invalid pci address")) {
1904 1905 1906
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("failed to detach PCI device, invalid address %.4x:%.2x:%.2x: %s"),
                       guestAddr->domain, guestAddr->bus, guestAddr->slot, reply);
1907 1908 1909 1910 1911
        goto cleanup;
    }

    ret = 0;

1912
 cleanup:
1913 1914 1915 1916
    VIR_FREE(cmd);
    VIR_FREE(reply);
    return ret;
}
1917 1918


1919 1920 1921
int qemuMonitorTextSendFileHandle(qemuMonitorPtr mon,
                                  const char *fdname,
                                  int fd)
1922 1923 1924 1925 1926
{
    char *cmd;
    char *reply = NULL;
    int ret = -1;

1927
    if (virAsprintf(&cmd, "getfd %s", fdname) < 0)
1928 1929
        return -1;

1930
    if (qemuMonitorHMPCommandWithFd(mon, cmd, fd, &reply) < 0)
1931 1932 1933 1934 1935
        goto cleanup;

    /* If the command isn't supported then qemu prints:
     * unknown command: getfd" */
    if (strstr(reply, "unknown command:")) {
1936 1937 1938
        virReportError(VIR_ERR_OPERATION_INVALID,
                       _("qemu does not support sending of file handles: %s"),
                       reply);
1939 1940 1941
        goto cleanup;
    }

1942
    if (STRNEQ(reply, "")) {
1943 1944
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("unable to send file handle '%s': %s"),
1945
                        fdname, reply);
1946 1947 1948
        goto cleanup;
    }

1949 1950
    ret = 0;

1951
 cleanup:
1952 1953 1954 1955 1956 1957
    VIR_FREE(cmd);
    VIR_FREE(reply);
    return ret;
}


1958 1959
int qemuMonitorTextCloseFileHandle(qemuMonitorPtr mon,
                                   const char *fdname)
1960 1961 1962 1963 1964
{
    char *cmd;
    char *reply = NULL;
    int ret = -1;

1965
    if (virAsprintf(&cmd, "closefd %s", fdname) < 0)
1966 1967
        return -1;

1968
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
1969 1970 1971 1972 1973
        goto cleanup;

    /* If the command isn't supported then qemu prints:
     * unknown command: getfd" */
    if (strstr(reply, "unknown command:")) {
1974 1975 1976
        virReportError(VIR_ERR_OPERATION_INVALID,
                       _("qemu does not support closing of file handles: %s"),
                       reply);
1977 1978 1979 1980 1981
        goto cleanup;
    }

    ret = 0;

1982
 cleanup:
1983 1984 1985 1986 1987
    VIR_FREE(cmd);
    VIR_FREE(reply);
    return ret;
}

1988

1989 1990
int qemuMonitorTextAddHostNetwork(qemuMonitorPtr mon,
                                  const char *netstr)
1991 1992 1993 1994 1995
{
    char *cmd;
    char *reply = NULL;
    int ret = -1;

1996
    if (virAsprintf(&cmd, "host_net_add %s", netstr) < 0)
1997 1998
        return -1;

1999
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
2000 2001
        goto cleanup;

2002
    if (STRNEQ(reply, "")) {
2003 2004 2005
        virReportError(VIR_ERR_INTERNAL_ERROR,
                       _("unable to add host net: %s"),
                       reply);
2006 2007
        goto cleanup;
    }
2008 2009 2010

    ret = 0;

2011
 cleanup:
2012 2013 2014 2015
    VIR_FREE(cmd);
    VIR_FREE(reply);
    return ret;
}
2016 2017


2018 2019 2020
int qemuMonitorTextRemoveHostNetwork(qemuMonitorPtr mon,
                                     int vlan,
                                     const char *netname)
2021 2022 2023 2024 2025
{
    char *cmd;
    char *reply = NULL;
    int ret = -1;

2026
    if (virAsprintf(&cmd, "host_net_remove %d %s", vlan, netname) < 0)
2027 2028
        return -1;

2029
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
2030 2031 2032 2033 2034 2035
        goto cleanup;

    /* XXX error messages here ? */

    ret = 0;

2036
 cleanup:
2037 2038 2039 2040
    VIR_FREE(cmd);
    VIR_FREE(reply);
    return ret;
}
2041 2042


2043 2044 2045 2046 2047 2048 2049
int qemuMonitorTextAddNetdev(qemuMonitorPtr mon,
                             const char *netdevstr)
{
    char *cmd;
    char *reply = NULL;
    int ret = -1;

2050
    if (virAsprintf(&cmd, "netdev_add %s", netdevstr) < 0)
2051 2052
        return -1;

2053
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
2054 2055 2056 2057 2058 2059
        goto cleanup;

    /* XXX error messages here ? */

    ret = 0;

2060
 cleanup:
2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073
    VIR_FREE(cmd);
    VIR_FREE(reply);
    return ret;
}


int qemuMonitorTextRemoveNetdev(qemuMonitorPtr mon,
                                const char *alias)
{
    char *cmd;
    char *reply = NULL;
    int ret = -1;

2074
    if (virAsprintf(&cmd, "netdev_del %s", alias) < 0)
2075 2076
        return -1;

2077
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
2078 2079 2080 2081 2082 2083
        goto cleanup;

    /* XXX error messages here ? */

    ret = 0;

2084
 cleanup:
2085 2086 2087 2088 2089 2090
    VIR_FREE(cmd);
    VIR_FREE(reply);
    return ret;
}


2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102
/* Parse the output of "info chardev" and return a hash of pty paths.
 *
 * Output is:
 * foo: filename=pty:/dev/pts/7
 * monitor: filename=stdio
 * serial0: filename=vc
 * parallel0: filename=vc
 *
 * Non-pty lines are ignored. In the above example, key is 'foo', value is
 * '/dev/pty/7'. The hash will contain only a single value.
 */

2103 2104
int qemuMonitorTextGetChardevInfo(qemuMonitorPtr mon,
                                  virHashTablePtr info)
2105 2106
{
    char *reply = NULL;
2107
    qemuMonitorChardevInfoPtr entry = NULL;
2108 2109
    int ret = -1;

2110
    if (qemuMonitorHMPCommand(mon, "info chardev", &reply) < 0)
2111
        return -1;
2112

2113 2114
    char *pos;                          /* The current start of searching */
    char *next = reply;                 /* The start of the next line */
2115
    char *eol;                   /* The character which ends the current line */
2116 2117 2118 2119
    char *end = reply + strlen(reply);  /* The end of the reply string */

    while (next) {
        pos = next;
2120 2121 2122

        /* Split the output into lines */
        eol = memchr(pos, '\n', end - pos);
2123
        if (eol == NULL) {
2124
            eol = end;
2125 2126 2127 2128 2129 2130 2131 2132
            next = NULL;
        } else {
            next = eol + 1;
        }

        /* Ignore all whitespace immediately before eol */
        while (eol > pos && c_isspace(*(eol-1)))
            eol -= 1;
2133 2134 2135 2136 2137 2138 2139

        /* Look for 'filename=pty:' */
#define NEEDLE "filename=pty:"
        char *needle = memmem(pos, eol - pos, NEEDLE, strlen(NEEDLE));

        /* If it's not there we can ignore this line */
        if (!needle)
2140
            continue;
2141

J
Ján Tomko 已提交
2142
        /* id is everything from the beginning of the line to the ':'
2143 2144 2145
         * find ':' and turn it into a terminator */
        char *colon = memchr(pos, ':', needle - pos);
        if (colon == NULL)
2146
            continue;
2147 2148 2149 2150 2151
        *colon = '\0';
        char *id = pos;

        /* Path is everything after needle to the end of the line */
        *eol = '\0';
2152 2153 2154 2155 2156

        if (VIR_ALLOC(entry) < 0)
            goto cleanup;

        if (VIR_STRDUP(entry->ptyPath, needle + strlen(NEEDLE)) < 0)
2157
            goto cleanup;
2158

2159
        if (virHashAddEntry(info, id, entry) < 0) {
2160 2161
            virReportError(VIR_ERR_OPERATION_FAILED,
                           _("failed to save chardev path '%s'"),
2162 2163
                           entry->ptyPath);
            VIR_FREE(entry->ptyPath);
2164 2165
            goto cleanup;
        }
2166 2167

        entry = NULL;
2168 2169 2170 2171 2172
#undef NEEDLE
    }

    ret = 0;

2173
 cleanup:
2174
    VIR_FREE(reply);
2175
    VIR_FREE(entry);
2176 2177 2178 2179 2180 2181
    return ret;
}


int qemuMonitorTextAttachPCIDiskController(qemuMonitorPtr mon,
                                           const char *bus,
2182
                                           virDevicePCIAddress *guestAddr)
2183 2184 2185
{
    char *cmd = NULL;
    char *reply = NULL;
2186
    bool tryOldSyntax = false;
2187 2188
    int ret = -1;

2189
 try_command:
2190
    if (virAsprintf(&cmd, "pci_add %s storage if=%s",
2191
                    (tryOldSyntax ? "0": "pci_addr=auto"), bus) < 0)
2192 2193
        goto cleanup;

2194
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
2195 2196
        goto cleanup;

2197
    if (qemuMonitorTextParsePCIAddReply(mon, reply, guestAddr) < 0) {
2198 2199 2200
        if (!tryOldSyntax && strstr(reply, "invalid char in expression")) {
            VIR_FREE(reply);
            VIR_FREE(cmd);
2201
            tryOldSyntax = true;
2202 2203 2204
            goto try_command;
        }

2205 2206
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("adding %s disk controller failed: %s"), bus, reply);
2207 2208 2209 2210 2211
        goto cleanup;
    }

    ret = 0;

2212
 cleanup:
2213
    VIR_FREE(cmd);
2214 2215 2216
    VIR_FREE(reply);
    return ret;
}
2217 2218 2219


static int
2220 2221
qemuParseDriveAddReply(const char *reply,
                       virDomainDeviceDriveAddressPtr addr)
2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237
{
    char *s, *e;

    /* If the command succeeds qemu prints:
     * OK bus X, unit Y
     */

    if (!(s = strstr(reply, "OK ")))
        return -1;

    s += 3;

    if (STRPREFIX(s, "bus ")) {
        s += strlen("bus ");

        if (virStrToLong_ui(s, &e, 10, &addr->bus) == -1) {
2238
            VIR_WARN("Unable to parse bus '%s'", s);
2239 2240 2241 2242
            return -1;
        }

        if (!STRPREFIX(e, ", ")) {
2243
            VIR_WARN("Expected ', ' parsing drive_add reply '%s'", s);
2244 2245 2246 2247 2248 2249
            return -1;
        }
        s = e + 2;
    }

    if (!STRPREFIX(s, "unit ")) {
2250
        VIR_WARN("Expected 'unit ' parsing drive_add reply '%s'", s);
2251 2252 2253 2254 2255
        return -1;
    }
    s += strlen("bus ");

    if (virStrToLong_ui(s, &e, 10, &addr->unit) == -1) {
2256
        VIR_WARN("Unable to parse unit number '%s'", s);
2257 2258 2259 2260 2261 2262 2263 2264 2265
        return -1;
    }

    return 0;
}


int qemuMonitorTextAttachDrive(qemuMonitorPtr mon,
                               const char *drivestr,
2266
                               virDevicePCIAddress *controllerAddr,
2267 2268 2269 2270 2271 2272
                               virDomainDeviceDriveAddress *driveAddr)
{
    char *cmd = NULL;
    char *reply = NULL;
    int ret = -1;
    char *safe_str;
2273
    bool tryOldSyntax = false;
2274 2275

    safe_str = qemuMonitorEscapeArg(drivestr);
2276
    if (!safe_str)
2277 2278
        return -1;

2279
 try_command:
2280 2281 2282
    if (virAsprintf(&cmd, "drive_add %s%.2x:%.2x:%.2x %s",
                    (tryOldSyntax ? "" : "pci_addr="),
                    controllerAddr->domain, controllerAddr->bus,
2283
                    controllerAddr->slot, safe_str) < 0)
2284 2285
        goto cleanup;

2286
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
2287 2288
        goto cleanup;

2289
    if (strstr(reply, "unknown command:")) {
2290 2291
        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                       _("drive hotplug is not supported"));
2292 2293 2294
        goto cleanup;
    }

2295
    if (qemuParseDriveAddReply(reply, driveAddr) < 0) {
2296 2297
        if (!tryOldSyntax && strstr(reply, "invalid char in expression")) {
            VIR_FREE(reply);
2298
            VIR_FREE(cmd);
2299
            tryOldSyntax = true;
2300 2301
            goto try_command;
        }
2302 2303
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("adding %s disk failed: %s"), drivestr, reply);
2304
        goto cleanup;
2305 2306 2307 2308
    }

    ret = 0;

2309
 cleanup:
2310 2311 2312 2313 2314 2315 2316
    VIR_FREE(cmd);
    VIR_FREE(reply);
    VIR_FREE(safe_str);
    return ret;
}


2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356
/*
 * The format we're after looks like this
 *
 *   (qemu) info pci
 *   Bus  0, device   0, function 0:
 *     Host bridge: PCI device 8086:1237
 *       id ""
 *   Bus  0, device   1, function 0:
 *     ISA bridge: PCI device 8086:7000
 *       id ""
 *   Bus  0, device   1, function 1:
 *     IDE controller: PCI device 8086:7010
 *       BAR4: I/O at 0xc000 [0xc00f].
 *       id ""
 *   Bus  0, device   1, function 3:
 *     Bridge: PCI device 8086:7113
 *       IRQ 9.
 *       id ""
 *   Bus  0, device   2, function 0:
 *     VGA controller: PCI device 1013:00b8
 *       BAR0: 32 bit prefetchable memory at 0xf0000000 [0xf1ffffff].
 *       BAR1: 32 bit memory at 0xf2000000 [0xf2000fff].
 *       id ""
 *   Bus  0, device   3, function 0:
 *     Ethernet controller: PCI device 8086:100e
 *      IRQ 11.
 *      BAR0: 32 bit memory at 0xf2020000 [0xf203ffff].
 *      BAR1: I/O at 0xc040 [0xc07f].
 *       id ""
 *
 * Of this, we're interesting in the vendor/product ID
 * and the bus/device/function data.
 */
#define CHECK_END(p) if (!(p)) break;
#define SKIP_TO(p, lbl)                                            \
    (p) = strstr((p), (lbl));                                      \
    if (p)                                                         \
        (p) += strlen(lbl);
#define GET_INT(p, base, val)                                           \
    if (virStrToLong_ui((p), &(p), (base), &(val)) < 0) {               \
2357 2358
        virReportError(VIR_ERR_OPERATION_FAILED,                       \
                       _("cannot parse value for %s"), #val);           \
2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373
        break;                                                          \
    }
#define SKIP_SPACE(p)                           \
    while (*(p) == ' ') (p)++;

int qemuMonitorTextGetAllPCIAddresses(qemuMonitorPtr mon,
                                      qemuMonitorPCIAddress **retaddrs)
{
    char *reply;
    qemuMonitorPCIAddress *addrs = NULL;
    int naddrs = 0;
    char *p;

    *retaddrs = NULL;

2374
    if (qemuMonitorHMPCommand(mon, "info pci", &reply) < 0)
2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411
        return -1;

    p = reply;


    while (p) {
        unsigned int bus, slot, func, vendor, product;

        SKIP_TO(p, "  Bus");
        CHECK_END(p);
        SKIP_SPACE(p);
        GET_INT(p, 10, bus);
        CHECK_END(p);

        SKIP_TO(p, ", device");
        CHECK_END(p);
        SKIP_SPACE(p);
        GET_INT(p, 10, slot);
        CHECK_END(p);

        SKIP_TO(p, ", function");
        CHECK_END(p);
        SKIP_SPACE(p);
        GET_INT(p, 10, func);
        CHECK_END(p);

        SKIP_TO(p, "PCI device");
        CHECK_END(p);
        SKIP_SPACE(p);
        GET_INT(p, 16, vendor);
        CHECK_END(p);

        if (*p != ':')
            break;
        p++;
        GET_INT(p, 16, product);

2412
        if (VIR_REALLOC_N(addrs, naddrs+1) < 0)
2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431
            goto error;

        addrs[naddrs].addr.domain = 0;
        addrs[naddrs].addr.bus = bus;
        addrs[naddrs].addr.slot = slot;
        addrs[naddrs].addr.function = func;
        addrs[naddrs].vendor = vendor;
        addrs[naddrs].product = product;
        naddrs++;

        VIR_DEBUG("Got dev %d:%d:%d   %x:%x", bus, slot, func, vendor, product);
    }

    VIR_FREE(reply);

    *retaddrs = addrs;

    return naddrs;

2432
 error:
2433 2434 2435 2436 2437 2438 2439 2440
    VIR_FREE(addrs);
    VIR_FREE(reply);
    return -1;
}
#undef GET_INT
#undef SKIP_SPACE
#undef CHECK_END
#undef SKIP_TO
2441 2442


2443
int qemuMonitorTextDelDevice(qemuMonitorPtr mon,
2444
                             const char *devalias)
2445 2446 2447 2448 2449 2450
{
    char *cmd = NULL;
    char *reply = NULL;
    char *safedev;
    int ret = -1;

2451
    if (!(safedev = qemuMonitorEscapeArg(devalias)))
2452 2453
        goto cleanup;

2454
    if (virAsprintf(&cmd, "device_del %s", safedev) < 0)
2455 2456
        goto cleanup;

2457
    VIR_DEBUG("TextDelDevice devalias=%s", devalias);
2458
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
2459 2460 2461
        goto cleanup;

    if (STRNEQ(reply, "")) {
2462 2463
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("detaching %s device failed: %s"), devalias, reply);
2464 2465 2466 2467 2468
        goto cleanup;
    }

    ret = 0;

2469
 cleanup:
2470 2471 2472 2473 2474 2475 2476
    VIR_FREE(cmd);
    VIR_FREE(reply);
    VIR_FREE(safedev);
    return ret;
}


2477 2478 2479 2480 2481 2482 2483 2484
int qemuMonitorTextAddDevice(qemuMonitorPtr mon,
                             const char *devicestr)
{
    char *cmd = NULL;
    char *reply = NULL;
    char *safedev;
    int ret = -1;

2485
    if (!(safedev = qemuMonitorEscapeArg(devicestr)))
2486 2487
        goto cleanup;

2488
    if (virAsprintf(&cmd, "device_add %s", safedev) < 0)
2489 2490
        goto cleanup;

2491
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
2492 2493
        goto cleanup;

2494 2495 2496 2497 2498 2499 2500 2501 2502
    /* If the host device is hotpluged first time, qemu will output
     * husb: using %s file-system with %s if the command succeeds.
     */
    if (STRPREFIX(reply, "husb: using")) {
        ret = 0;
        goto cleanup;
    }

    /* Otherwise, if the command succeeds, no output is sent. So
2503 2504
     * any non-empty string shows an error */
    if (STRNEQ(reply, "")) {
2505 2506
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("adding %s device failed: %s"), devicestr, reply);
2507 2508 2509 2510 2511
        goto cleanup;
    }

    ret = 0;

2512
 cleanup:
2513 2514
    VIR_FREE(cmd);
    VIR_FREE(reply);
2515
    VIR_FREE(safedev);
2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528
    return ret;
}


int qemuMonitorTextAddDrive(qemuMonitorPtr mon,
                            const char *drivestr)
{
    char *cmd = NULL;
    char *reply = NULL;
    int ret = -1;
    char *safe_str;

    safe_str = qemuMonitorEscapeArg(drivestr);
2529
    if (!safe_str)
2530 2531 2532 2533
        return -1;

    /* 'dummy' here is just a placeholder since there is no PCI
     * address required when attaching drives to a controller */
2534
    if (virAsprintf(&cmd, "drive_add dummy %s", safe_str) < 0)
2535 2536
        goto cleanup;

2537
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
2538 2539
        goto cleanup;

2540
    if (strstr(reply, "unknown command:")) {
2541 2542
        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                       _("drive hotplug is not supported"));
2543 2544 2545
        goto cleanup;
    }

2546
    if (strstr(reply, "could not open disk image")) {
2547 2548
        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                       _("open disk image file failed"));
2549 2550 2551
        goto cleanup;
    }

2552 2553
    ret = 0;

2554
 cleanup:
2555 2556 2557 2558 2559
    VIR_FREE(cmd);
    VIR_FREE(reply);
    VIR_FREE(safe_str);
    return ret;
}
2560

2561 2562 2563 2564
/* Attempts to remove a host drive.
 * Returns 1 if unsupported, 0 if ok, and -1 on other failure */
int qemuMonitorTextDriveDel(qemuMonitorPtr mon,
                            const char *drivestr)
2565 2566 2567 2568 2569
{
    char *cmd = NULL;
    char *reply = NULL;
    char *safedev;
    int ret = -1;
2570
    VIR_DEBUG("TextDriveDel drivestr=%s", drivestr);
2571

2572
    if (!(safedev = qemuMonitorEscapeArg(drivestr)))
2573 2574
        goto cleanup;

2575
    if (virAsprintf(&cmd, "drive_del %s", safedev) < 0)
2576 2577
        goto cleanup;

2578
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
2579 2580 2581
        goto cleanup;

    if (strstr(reply, "unknown command:")) {
2582
        VIR_ERROR(_("deleting drive is not supported.  "
2583 2584 2585
                    "This may leak data if disk is reassigned"));
        ret = 1;
        goto cleanup;
2586 2587 2588

    /* (qemu) drive_del wark
     * Device 'wark' not found */
2589
    } else if (strstr(reply, "Device '") && strstr(reply, "not found")) {
2590 2591
        /* NB: device not found errors mean the drive was auto-deleted and we
         * ignore the error */
2592
    } else if (STRNEQ(reply, "")) {
2593 2594
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("deleting %s drive failed: %s"), drivestr, reply);
2595 2596 2597 2598 2599
        goto cleanup;
    }

    ret = 0;

2600
 cleanup:
2601 2602 2603 2604 2605
    VIR_FREE(cmd);
    VIR_FREE(reply);
    VIR_FREE(safedev);
    return ret;
}
2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616

int qemuMonitorTextSetDrivePassphrase(qemuMonitorPtr mon,
                                      const char *alias,
                                      const char *passphrase)
{
    char *cmd = NULL;
    char *reply = NULL;
    int ret = -1;
    char *safe_str;

    safe_str = qemuMonitorEscapeArg(passphrase);
2617
    if (!safe_str)
2618 2619
        return -1;

2620
    if (virAsprintf(&cmd, "block_passwd %s%s \"%s\"",
2621
                    QEMU_DRIVE_HOST_PREFIX, alias, safe_str) < 0)
2622 2623
        goto cleanup;

2624
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
2625 2626
        goto cleanup;

2627
    if (strstr(reply, "unknown command:")) {
2628 2629
        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                       _("setting disk password is not supported"));
2630 2631
        goto cleanup;
    } else if (strstr(reply, "The entered password is invalid")) {
2632 2633
        virReportError(VIR_ERR_OPERATION_FAILED, "%s",
                       _("the disk password is incorrect"));
2634 2635 2636 2637 2638
        goto cleanup;
    }

    ret = 0;

2639
 cleanup:
2640 2641 2642 2643 2644
    VIR_FREE(cmd);
    VIR_FREE(reply);
    VIR_FREE(safe_str);
    return ret;
}
C
Chris Lalancette 已提交
2645 2646 2647

int qemuMonitorTextCreateSnapshot(qemuMonitorPtr mon, const char *name)
{
2648
    char *cmd = NULL;
C
Chris Lalancette 已提交
2649 2650
    char *reply = NULL;
    int ret = -1;
2651
    char *safename;
C
Chris Lalancette 已提交
2652

2653
    if (!(safename = qemuMonitorEscapeArg(name)) ||
2654
        virAsprintf(&cmd, "savevm \"%s\"", safename) < 0)
2655
        goto cleanup;
C
Chris Lalancette 已提交
2656

2657
    if (qemuMonitorHMPCommand(mon, cmd, &reply))
C
Chris Lalancette 已提交
2658 2659 2660
        goto cleanup;

    if (strstr(reply, "Error while creating snapshot") != NULL) {
2661 2662
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("Failed to take snapshot: %s"), reply);
C
Chris Lalancette 已提交
2663
        goto cleanup;
2664
    } else if (strstr(reply, "No block device can accept snapshots") != NULL) {
2665 2666
        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                       _("this domain does not have a device to take snapshots"));
C
Chris Lalancette 已提交
2667
        goto cleanup;
2668
    } else if (strstr(reply, "Could not open VM state file") != NULL) {
2669
        virReportError(VIR_ERR_OPERATION_FAILED, "%s", reply);
C
Chris Lalancette 已提交
2670
        goto cleanup;
2671
    } else if (strstr(reply, "Error") != NULL
C
Chris Lalancette 已提交
2672
             && strstr(reply, "while writing VM") != NULL) {
2673
        virReportError(VIR_ERR_OPERATION_FAILED, "%s", reply);
C
Chris Lalancette 已提交
2674 2675 2676 2677 2678
        goto cleanup;
    }

    ret = 0;

2679
 cleanup:
2680
    VIR_FREE(safename);
C
Chris Lalancette 已提交
2681 2682 2683 2684 2685 2686 2687
    VIR_FREE(cmd);
    VIR_FREE(reply);
    return ret;
}

int qemuMonitorTextLoadSnapshot(qemuMonitorPtr mon, const char *name)
{
2688
    char *cmd = NULL;
C
Chris Lalancette 已提交
2689 2690
    char *reply = NULL;
    int ret = -1;
2691
    char *safename;
C
Chris Lalancette 已提交
2692

2693
    if (!(safename = qemuMonitorEscapeArg(name)) ||
2694
        virAsprintf(&cmd, "loadvm \"%s\"", safename) < 0)
2695
        goto cleanup;
C
Chris Lalancette 已提交
2696

2697
    if (qemuMonitorHMPCommand(mon, cmd, &reply))
C
Chris Lalancette 已提交
2698 2699 2700
        goto cleanup;

    if (strstr(reply, "No block device supports snapshots") != NULL) {
2701 2702
        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                       _("this domain does not have a device to load snapshots"));
C
Chris Lalancette 已提交
2703
        goto cleanup;
2704
    } else if (strstr(reply, "Could not find snapshot") != NULL) {
2705 2706 2707
        virReportError(VIR_ERR_OPERATION_INVALID,
                       _("the snapshot '%s' does not exist, and was not loaded"),
                       name);
C
Chris Lalancette 已提交
2708
        goto cleanup;
2709
    } else if (strstr(reply, "Snapshots not supported on device") != NULL) {
2710
        virReportError(VIR_ERR_OPERATION_INVALID, "%s", reply);
C
Chris Lalancette 已提交
2711
        goto cleanup;
2712
    } else if (strstr(reply, "Could not open VM state file") != NULL) {
2713
        virReportError(VIR_ERR_OPERATION_FAILED, "%s", reply);
C
Chris Lalancette 已提交
2714
        goto cleanup;
2715
    } else if (strstr(reply, "Error") != NULL
C
Chris Lalancette 已提交
2716
             && strstr(reply, "while loading VM state") != NULL) {
2717
        virReportError(VIR_ERR_OPERATION_FAILED, "%s", reply);
C
Chris Lalancette 已提交
2718
        goto cleanup;
2719
    } else if (strstr(reply, "Error") != NULL
C
Chris Lalancette 已提交
2720
             && strstr(reply, "while activating snapshot on") != NULL) {
2721
        virReportError(VIR_ERR_OPERATION_FAILED, "%s", reply);
C
Chris Lalancette 已提交
2722 2723 2724 2725 2726
        goto cleanup;
    }

    ret = 0;

2727
 cleanup:
2728
    VIR_FREE(safename);
C
Chris Lalancette 已提交
2729 2730 2731 2732 2733 2734 2735
    VIR_FREE(cmd);
    VIR_FREE(reply);
    return ret;
}

int qemuMonitorTextDeleteSnapshot(qemuMonitorPtr mon, const char *name)
{
2736
    char *cmd = NULL;
C
Chris Lalancette 已提交
2737 2738
    char *reply = NULL;
    int ret = -1;
2739
    char *safename;
C
Chris Lalancette 已提交
2740

2741
    if (!(safename = qemuMonitorEscapeArg(name)) ||
2742
        virAsprintf(&cmd, "delvm \"%s\"", safename) < 0)
2743
        goto cleanup;
2744
    if (qemuMonitorHMPCommand(mon, cmd, &reply))
C
Chris Lalancette 已提交
2745 2746 2747
        goto cleanup;

    if (strstr(reply, "No block device supports snapshots") != NULL) {
2748 2749
        virReportError(VIR_ERR_OPERATION_INVALID, "%s",
                       _("this domain does not have a device to delete snapshots"));
C
Chris Lalancette 已提交
2750
        goto cleanup;
2751
    } else if (strstr(reply, "Snapshots not supported on device") != NULL) {
2752
        virReportError(VIR_ERR_OPERATION_INVALID, "%s", reply);
C
Chris Lalancette 已提交
2753
        goto cleanup;
2754
    } else if (strstr(reply, "Error") != NULL
C
Chris Lalancette 已提交
2755
             && strstr(reply, "while deleting snapshot") != NULL) {
2756
        virReportError(VIR_ERR_OPERATION_FAILED, "%s", reply);
C
Chris Lalancette 已提交
2757 2758 2759 2760 2761
        goto cleanup;
    }

    ret = 0;

2762
 cleanup:
2763
    VIR_FREE(safename);
C
Chris Lalancette 已提交
2764 2765 2766 2767
    VIR_FREE(cmd);
    VIR_FREE(reply);
    return ret;
}
2768

2769

2770 2771 2772 2773 2774 2775
int qemuMonitorTextArbitraryCommand(qemuMonitorPtr mon, const char *cmd,
                                    char **reply)
{
    char *safecmd = NULL;
    int ret;

2776
    if (!(safecmd = qemuMonitorEscapeArg(cmd)))
2777 2778
        return -1;

2779
    ret = qemuMonitorHMPCommand(mon, safecmd, reply);
2780 2781 2782 2783 2784

    VIR_FREE(safecmd);

    return ret;
}
2785 2786 2787 2788 2789

int qemuMonitorTextInjectNMI(qemuMonitorPtr mon)
{
    char *reply = NULL;

2790 2791
    if (qemuMonitorHMPCommand(mon, "inject-nmi", &reply) < 0)
        return -1;
2792 2793 2794 2795 2796

    if (strstr(reply, "unknown command") != NULL) {
        VIR_FREE(reply);

        /* fallback to 'nmi' if qemu has not supported "inject-nmi" yet. */
2797 2798
        if (qemuMonitorHMPCommand(mon, "nmi 0", &reply) < 0)
            return -1;
2799 2800 2801 2802 2803
    }

    VIR_FREE(reply);
    return 0;
}
2804

2805 2806 2807 2808 2809
int qemuMonitorTextSendKey(qemuMonitorPtr mon,
                           unsigned int holdtime,
                           unsigned int *keycodes,
                           unsigned int nkeycodes)
{
2810
    size_t i;
2811 2812
    virBuffer buf = VIR_BUFFER_INITIALIZER;
    char *cmd, *reply = NULL;
2813
    int ret = -1;
2814 2815 2816 2817 2818 2819 2820

    if (nkeycodes > VIR_DOMAIN_SEND_KEY_MAX_KEYS || nkeycodes == 0)
        return -1;

    virBufferAddLit(&buf, "sendkey ");
    for (i = 0; i < nkeycodes; i++) {
        if (keycodes[i] > 0xffff) {
2821
            virReportError(VIR_ERR_OPERATION_FAILED,
2822
                           _("keycode %zu is invalid: 0x%X"),
2823
                           i, keycodes[i]);
2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835
            virBufferFreeAndReset(&buf);
            return -1;
        }

        if (i)
            virBufferAddChar(&buf, '-');
        virBufferAsprintf(&buf, "0x%02X", keycodes[i]);
    }

    if (holdtime)
        virBufferAsprintf(&buf, " %u", holdtime);

2836
    if (virBufferCheckError(&buf) < 0)
2837 2838 2839
        return -1;

    cmd = virBufferContentAndReset(&buf);
2840
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
2841 2842 2843
        goto cleanup;

    if (STRNEQ(reply, "")) {
2844 2845
        virReportError(VIR_ERR_OPERATION_FAILED,
                       _("failed to send key '%s'"), reply);
2846
        goto cleanup;
2847 2848
    }

2849 2850
    ret = 0;

2851
 cleanup:
2852 2853
    VIR_FREE(cmd);
    VIR_FREE(reply);
2854
    return ret;
2855 2856
}

2857 2858 2859 2860 2861 2862 2863
/* Returns -1 on error, -2 if not supported */
int qemuMonitorTextScreendump(qemuMonitorPtr mon, const char *file)
{
    char *cmd = NULL;
    char *reply = NULL;
    int ret = -1;

2864
    if (virAsprintf(&cmd, "screendump %s", file) < 0)
2865 2866
        goto cleanup;

2867
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
2868 2869 2870 2871 2872 2873 2874 2875 2876
        goto cleanup;

    if (strstr(reply, "unknown command:")) {
        ret = -2;
        goto cleanup;
    }

    ret = 0;

2877
 cleanup:
2878 2879 2880 2881
    VIR_FREE(reply);
    VIR_FREE(cmd);
    return ret;
}
2882

2883 2884 2885 2886 2887 2888 2889 2890 2891 2892

int qemuMonitorTextOpenGraphics(qemuMonitorPtr mon,
                                const char *protocol,
                                const char *fdname,
                                bool skipauth)
{
    char *cmd = NULL;
    char *reply = NULL;
    int ret = -1;

2893
    if (virAsprintf(&cmd, "add_client %s %s %d", protocol, fdname, skipauth ? 0 : 1) < 0)
2894 2895
        goto cleanup;

2896
    if (qemuMonitorHMPCommand(mon, cmd, &reply) < 0)
2897 2898 2899 2900 2901 2902 2903
        goto cleanup;

    if (STRNEQ(reply, ""))
        goto cleanup;

    ret = 0;

2904
 cleanup:
2905 2906 2907 2908
    VIR_FREE(reply);
    VIR_FREE(cmd);
    return ret;
}
2909 2910 2911 2912 2913 2914 2915 2916


int qemuMonitorTextSetBlockIoThrottle(qemuMonitorPtr mon,
                                      const char *device,
                                      virDomainBlockIoTuneInfoPtr info)
{
    char *cmd = NULL;
    char *result = NULL;
2917
    int ret = -1;
2918 2919 2920 2921
    const char *cmd_name = NULL;

    /* For the not specified fields, 0 by default */
    cmd_name = "block_set_io_throttle";
2922 2923 2924
    if (virAsprintf(&cmd, "%s %s %llu %llu %llu %llu %llu %llu", cmd_name,
                    device, info->total_bytes_sec, info->read_bytes_sec,
                    info->write_bytes_sec, info->total_iops_sec,
2925
                    info->read_iops_sec, info->write_iops_sec) < 0)
2926
        goto cleanup;
2927

2928
    if (qemuMonitorHMPCommand(mon, cmd, &result) < 0)
2929 2930 2931
        goto cleanup;

    if (qemuMonitorTextCommandNotFound(cmd_name, result)) {
2932 2933
        virReportError(VIR_ERR_OPERATION_INVALID,
                       _("Command '%s' is not found"), cmd_name);
2934 2935
        goto cleanup;
    }
2936
    ret = 0;
2937

2938
 cleanup:
2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995
    VIR_FREE(cmd);
    VIR_FREE(result);
    return ret;
}

static int
qemuMonitorTextParseBlockIoThrottle(const char *result,
                                    const char *device,
                                    virDomainBlockIoTuneInfoPtr reply)
{
    char *dummy = NULL;
    int ret = -1;
    const char *p, *eol;
    int devnamelen = strlen(device);

    p = result;

    while (*p) {
        if (STREQLEN(p, device, devnamelen) &&
            p[devnamelen] == ':' && p[devnamelen+1] == ' ') {

            eol = strchr(p, '\n');
            if (!eol)
                eol = p + strlen(p);

            p += devnamelen + 2; /* Skip to first label. */

            while (*p) {
                if (STRPREFIX(p, "bps=")) {
                    p += strlen("bps=");
                    if (virStrToLong_ull(p, &dummy, 10, &reply->total_bytes_sec) == -1)
                        VIR_DEBUG("error reading total_bytes_sec: %s", p);
                } else if (STRPREFIX(p, "bps_rd=")) {
                    p += strlen("bps_rd=");
                    if (virStrToLong_ull(p, &dummy, 10, &reply->read_bytes_sec)  == -1)
                        VIR_DEBUG("error reading read_bytes_sec: %s", p);
                } else if (STRPREFIX(p, "bps_wr=")) {
                    p += strlen("bps_wr=");
                    if (virStrToLong_ull(p, &dummy, 10, &reply->write_bytes_sec) == -1)
                        VIR_DEBUG("error reading write_bytes_sec: %s", p);
                } else if (STRPREFIX(p, "iops=")) {
                    p += strlen("iops=");
                    if (virStrToLong_ull(p, &dummy, 10, &reply->total_iops_sec) == -1)
                        VIR_DEBUG("error reading total_iops_sec: %s", p);
                } else if (STRPREFIX(p, "iops_rd=")) {
                    p += strlen("iops_rd=");
                    if (virStrToLong_ull(p, &dummy, 10, &reply->read_iops_sec) == -1)
                        VIR_DEBUG("error reading read_iops_sec: %s", p);
                } else if (STRPREFIX(p, "iops_wr=")) {
                    p += strlen("iops_wr=");
                    if (virStrToLong_ull(p, &dummy, 10, &reply->write_iops_sec) == -1)
                        VIR_DEBUG("error reading write_iops_sec: %s", p);
                } else {
                    VIR_DEBUG(" unknown block info %s", p);
                }

                /* Skip to next label. */
2996
                p = strchr(p, ' ');
2997 2998 2999 3000 3001 3002 3003 3004 3005
                if (!p || p >= eol)
                    break;
                p++;
            }
            ret = 0;
            goto cleanup;
        }

        /* Skip to next line. */
3006
        p = strchr(p, '\n');
3007 3008 3009 3010 3011
        if (!p)
            break;
        p++;
    }

3012 3013
    virReportError(VIR_ERR_INVALID_ARG,
                   _("No info for device '%s'"), device);
3014

3015
 cleanup:
3016 3017 3018 3019 3020 3021 3022 3023
    return ret;
}

int qemuMonitorTextGetBlockIoThrottle(qemuMonitorPtr mon,
                                      const char *device,
                                      virDomainBlockIoTuneInfoPtr reply)
{
    char *result = NULL;
3024
    int ret = -1;
3025 3026
    const char *cmd_name = "info block";

3027
    if (qemuMonitorHMPCommand(mon, cmd_name, &result) < 0)
3028 3029 3030
        goto cleanup;

    if (qemuMonitorTextCommandNotFound(cmd_name, result)) {
3031 3032
        virReportError(VIR_ERR_OPERATION_INVALID,
                       _("Command '%s' is not found"), cmd_name);
3033 3034 3035 3036 3037
        goto cleanup;
    }

    ret = qemuMonitorTextParseBlockIoThrottle(result, device, reply);

3038
 cleanup:
3039 3040 3041
    VIR_FREE(result);
    return ret;
}