1 /*
2 * qemu_monitor.c: interaction with QEMU monitor console
3 *
4 * Copyright (C) 2006-2015 Red Hat, Inc.
5 * Copyright (C) 2006 Daniel P. Berrange
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library. If not, see
19 * <http://www.gnu.org/licenses/>.
20 */
21
22 #include <config.h>
23
24 #include <poll.h>
25 #include <unistd.h>
26 #include <fcntl.h>
27 #include <gio/gio.h>
28
29 #include "qemu_alias.h"
30 #include "qemu_monitor.h"
31 #include "qemu_monitor_text.h"
32 #include "qemu_monitor_json.h"
33 #include "qemu_domain.h"
34 #include "qemu_process.h"
35 #include "qemu_capabilities.h"
36 #include "virerror.h"
37 #include "viralloc.h"
38 #include "virlog.h"
39 #include "virfile.h"
40 #include "virprocess.h"
41 #include "virobject.h"
42 #include "virprobe.h"
43 #include "virstring.h"
44 #include "virtime.h"
45 #include "virsocket.h"
46 #include "virutil.h"
47
48 #ifdef WITH_DTRACE_PROBES
49 # include "libvirt_qemu_probes.h"
50 #endif
51
52 #define LIBVIRT_QEMU_MONITOR_PRIV_H_ALLOW
53 #include "qemu_monitor_priv.h"
54
55 #define VIR_FROM_THIS VIR_FROM_QEMU
56
57 VIR_LOG_INIT("qemu.qemu_monitor");
58
59 #define DEBUG_IO 0
60 #define DEBUG_RAW_IO 0
61
62 /* We read from QEMU until seeing a \r\n pair to indicate a
63 * completed reply or event. To avoid memory denial-of-service
64 * though, we must have a size limit on amount of data we
65 * buffer. 10 MB is large enough that it ought to cope with
66 * normal QEMU replies, and small enough that we're not
67 * consuming unreasonable mem.
68 */
69 #define QEMU_MONITOR_MAX_RESPONSE (10 * 1024 * 1024)
70
71 struct _qemuMonitor {
72 virObjectLockable parent;
73
74 virCond notify;
75
76 int fd;
77
78 GMainContext *context;
79 GSocket *socket;
80 GSource *watch;
81
82 virDomainObj *vm;
83
84 qemuMonitorCallbacks *cb;
85 void *callbackOpaque;
86
87 /* If there's a command being processed this will be
88 * non-NULL */
89 qemuMonitorMessage *msg;
90
91 /* Buffer incoming data ready for Text/QMP monitor
92 * code to process & find message boundaries */
93 size_t bufferOffset;
94 size_t bufferLength;
95 char *buffer;
96
97 /* If anything went wrong, this will be fed back
98 * the next monitor msg */
99 virError lastError;
100
101 /* Set to true when EOF is detected on the monitor */
102 bool goteof;
103
104 int nextSerial;
105
106 bool waitGreeting;
107
108 /* If found, path to the virtio memballoon driver */
109 char *balloonpath;
110 bool ballooninit;
111
112 /* Log file context of the qemu process to dig for usable info */
113 qemuMonitorReportDomainLogError logFunc;
114 void *logOpaque;
115 virFreeCallback logDestroy;
116
117 /* true if qemu no longer wants 'props' sub-object of object-add */
118 bool objectAddNoWrap;
119 };
120
121 /**
122 * QEMU_CHECK_MONITOR_FULL:
123 * @mon: monitor pointer variable to check, evaluated multiple times, no parentheses
124 * @exit: statement that is used to exit the function
125 *
126 * This macro checks that the monitor is valid for given operation and exits
127 * the function if not. The macro also adds a debug statement regarding the
128 * monitor.
129 */
130 #define QEMU_CHECK_MONITOR_FULL(mon, exit) \
131 do { \
132 if (!mon) { \
133 virReportError(VIR_ERR_INVALID_ARG, "%s", \
134 _("monitor must not be NULL")); \
135 exit; \
136 } \
137 VIR_DEBUG("mon:%p vm:%p fd:%d", mon, mon->vm, mon->fd); \
138 } while (0)
139
140 /* Check monitor and return NULL on error */
141 #define QEMU_CHECK_MONITOR_NULL(mon) \
142 QEMU_CHECK_MONITOR_FULL(mon, return NULL)
143
144 /* Check monitor and return -1 on error */
145 #define QEMU_CHECK_MONITOR(mon) \
146 QEMU_CHECK_MONITOR_FULL(mon, return -1)
147
148 /* Check monitor and jump to the provided label */
149 #define QEMU_CHECK_MONITOR_GOTO(mon, label) \
150 QEMU_CHECK_MONITOR_FULL(mon, goto label)
151
152 static virClass *qemuMonitorClass;
153 static __thread bool qemuMonitorDisposed;
154 static void qemuMonitorDispose(void *obj);
155
qemuMonitorOnceInit(void)156 static int qemuMonitorOnceInit(void)
157 {
158 if (!VIR_CLASS_NEW(qemuMonitor, virClassForObjectLockable()))
159 return -1;
160
161 return 0;
162 }
163
164 VIR_ONCE_GLOBAL_INIT(qemuMonitor);
165
166
167 VIR_ENUM_IMPL(qemuMonitorMigrationStatus,
168 QEMU_MONITOR_MIGRATION_STATUS_LAST,
169 "inactive", "setup",
170 "active", "pre-switchover",
171 "device", "postcopy-active",
172 "completed", "failed",
173 "cancelling", "cancelled",
174 "wait-unplug",
175 );
176
177 VIR_ENUM_IMPL(qemuMonitorVMStatus,
178 QEMU_MONITOR_VM_STATUS_LAST,
179 "debug", "inmigrate", "internal-error", "io-error", "paused",
180 "postmigrate", "prelaunch", "finish-migrate", "restore-vm",
181 "running", "save-vm", "shutdown", "watchdog", "guest-panicked",
182 );
183
184 typedef enum {
185 QEMU_MONITOR_BLOCK_IO_STATUS_OK,
186 QEMU_MONITOR_BLOCK_IO_STATUS_FAILED,
187 QEMU_MONITOR_BLOCK_IO_STATUS_NOSPACE,
188
189 QEMU_MONITOR_BLOCK_IO_STATUS_LAST
190 } qemuMonitorBlockIOStatus;
191
192 VIR_ENUM_DECL(qemuMonitorBlockIOStatus);
193
194 VIR_ENUM_IMPL(qemuMonitorBlockIOStatus,
195 QEMU_MONITOR_BLOCK_IO_STATUS_LAST,
196 "ok", "failed", "nospace",
197 );
198
199 VIR_ENUM_IMPL(qemuMonitorDumpStatus,
200 QEMU_MONITOR_DUMP_STATUS_LAST,
201 "none", "active", "completed", "failed",
202 );
203
204 VIR_ENUM_IMPL(qemuMonitorMemoryFailureRecipient,
205 QEMU_MONITOR_MEMORY_FAILURE_RECIPIENT_LAST,
206 "hypervisor", "guest");
207
208 VIR_ENUM_IMPL(qemuMonitorMemoryFailureAction,
209 QEMU_MONITOR_MEMORY_FAILURE_ACTION_LAST,
210 "ignore", "inject",
211 "fatal", "reset");
212
213 #if DEBUG_RAW_IO
214 static char *
qemuMonitorEscapeNonPrintable(const char * text)215 qemuMonitorEscapeNonPrintable(const char *text)
216 {
217 size_t i;
218 g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
219 for (i = 0; text[i] != '\0'; i++) {
220 if (g_ascii_isprint(text[i]) ||
221 text[i] == '\n' ||
222 (text[i] == '\r' && text[i + 1] == '\n'))
223 virBufferAddChar(&buf, text[i]);
224 else
225 virBufferAsprintf(&buf, "0x%02x", text[i]);
226 }
227 return virBufferContentAndReset(&buf);
228 }
229 #endif
230
231
232 static void
qemuMonitorDispose(void * obj)233 qemuMonitorDispose(void *obj)
234 {
235 qemuMonitor *mon = obj;
236
237 VIR_DEBUG("mon=%p", mon);
238 qemuMonitorDisposed = true;
239 virObjectUnref(mon->vm);
240
241 g_main_context_unref(mon->context);
242 virResetError(&mon->lastError);
243 virCondDestroy(&mon->notify);
244 g_free(mon->buffer);
245 g_free(mon->balloonpath);
246 }
247
248
249 static int
qemuMonitorOpenUnix(const char * monitor,pid_t cpid,bool retry,unsigned long long timeout)250 qemuMonitorOpenUnix(const char *monitor,
251 pid_t cpid,
252 bool retry,
253 unsigned long long timeout)
254 {
255 struct sockaddr_un addr;
256 int monfd;
257 virTimeBackOffVar timebackoff;
258 int ret = -1;
259
260 if ((monfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
261 virReportSystemError(errno,
262 "%s", _("failed to create socket"));
263 return -1;
264 }
265
266 memset(&addr, 0, sizeof(addr));
267 addr.sun_family = AF_UNIX;
268 if (virStrcpyStatic(addr.sun_path, monitor) < 0) {
269 virReportError(VIR_ERR_INTERNAL_ERROR,
270 _("Monitor path %s too big for destination"), monitor);
271 goto error;
272 }
273
274 if (retry) {
275 if (virTimeBackOffStart(&timebackoff, 1, timeout * 1000) < 0)
276 goto error;
277 while (virTimeBackOffWait(&timebackoff)) {
278 ret = connect(monfd, (struct sockaddr *)&addr, sizeof(addr));
279
280 if (ret == 0)
281 break;
282
283 if ((errno == ENOENT || errno == ECONNREFUSED) &&
284 (!cpid || virProcessKill(cpid, 0) == 0)) {
285 /* ENOENT : Socket may not have shown up yet
286 * ECONNREFUSED : Leftover socket hasn't been removed yet */
287 continue;
288 }
289
290 virReportSystemError(errno, "%s",
291 _("failed to connect to monitor socket"));
292 goto error;
293 }
294
295 if (ret != 0) {
296 virReportSystemError(errno, "%s",
297 _("monitor socket did not show up"));
298 goto error;
299 }
300 } else {
301 ret = connect(monfd, (struct sockaddr *) &addr, sizeof(addr));
302 if (ret < 0) {
303 virReportSystemError(errno, "%s",
304 _("failed to connect to monitor socket"));
305 goto error;
306 }
307 }
308
309 return monfd;
310
311 error:
312 VIR_FORCE_CLOSE(monfd);
313 return -1;
314 }
315
316
317 /* This method processes data that has been received
318 * from the monitor. Looking for async events and
319 * replies/errors.
320 */
321 static int
qemuMonitorIOProcess(qemuMonitor * mon)322 qemuMonitorIOProcess(qemuMonitor *mon)
323 {
324 int len;
325 qemuMonitorMessage *msg = NULL;
326
327 /* See if there's a message & whether its ready for its reply
328 * ie whether its completed writing all its data */
329 if (mon->msg && mon->msg->txOffset == mon->msg->txLength)
330 msg = mon->msg;
331
332 #if DEBUG_IO
333 # if DEBUG_RAW_IO
334 char *str1 = qemuMonitorEscapeNonPrintable(msg ? msg->txBuffer : "");
335 char *str2 = qemuMonitorEscapeNonPrintable(mon->buffer);
336 VIR_ERROR(_("Process %d %p %p [[[[%s]]][[[%s]]]"), (int)mon->bufferOffset, mon->msg, msg, str1, str2);
337 VIR_FREE(str1);
338 VIR_FREE(str2);
339 # else
340 VIR_DEBUG("Process %d", (int)mon->bufferOffset);
341 # endif
342 #endif
343
344 PROBE_QUIET(QEMU_MONITOR_IO_PROCESS, "mon=%p buf=%s len=%zu",
345 mon, mon->buffer, mon->bufferOffset);
346
347 len = qemuMonitorJSONIOProcess(mon,
348 mon->buffer, mon->bufferOffset,
349 msg);
350 if (len < 0)
351 return -1;
352
353 if (len && mon->waitGreeting)
354 mon->waitGreeting = false;
355
356 if (len < mon->bufferOffset) {
357 memmove(mon->buffer, mon->buffer + len, mon->bufferOffset - len);
358 mon->bufferOffset -= len;
359 } else {
360 VIR_FREE(mon->buffer);
361 mon->bufferOffset = mon->bufferLength = 0;
362 }
363 #if DEBUG_IO
364 VIR_DEBUG("Process done %d used %d", (int)mon->bufferOffset, len);
365 #endif
366
367 /* As the monitor mutex was unlocked in qemuMonitorJSONIOProcess()
368 * while dealing with qemu event, mon->msg could be changed which
369 * means the above 'msg' may be invalid, thus we use 'mon->msg' here */
370 if (mon->msg && mon->msg->finished)
371 virCondBroadcast(&mon->notify);
372 return len;
373 }
374
375
376 /* Call this function while holding the monitor lock. */
377 static int
qemuMonitorIOWriteWithFD(qemuMonitor * mon,const char * data,size_t len,int fd)378 qemuMonitorIOWriteWithFD(qemuMonitor *mon,
379 const char *data,
380 size_t len,
381 int fd)
382 {
383 struct msghdr msg;
384 struct iovec iov[1];
385 int ret;
386 char control[CMSG_SPACE(sizeof(int))];
387 struct cmsghdr *cmsg;
388
389 memset(&msg, 0, sizeof(msg));
390 memset(control, 0, sizeof(control));
391
392 iov[0].iov_base = (void *)data;
393 iov[0].iov_len = len;
394
395 msg.msg_iov = iov;
396 msg.msg_iovlen = 1;
397
398 msg.msg_control = control;
399 msg.msg_controllen = sizeof(control);
400
401 cmsg = CMSG_FIRSTHDR(&msg);
402 cmsg->cmsg_len = CMSG_LEN(sizeof(int));
403 cmsg->cmsg_level = SOL_SOCKET;
404 cmsg->cmsg_type = SCM_RIGHTS;
405 memcpy(CMSG_DATA(cmsg), &fd, sizeof(int));
406
407 do {
408 ret = sendmsg(mon->fd, &msg, 0);
409 } while (ret < 0 && errno == EINTR);
410
411 return ret;
412 }
413
414
415 /*
416 * Called when the monitor is able to write data
417 * Call this function while holding the monitor lock.
418 */
419 static int
qemuMonitorIOWrite(qemuMonitor * mon)420 qemuMonitorIOWrite(qemuMonitor *mon)
421 {
422 int done;
423 const char *buf;
424 size_t len;
425
426 /* If no active message, or fully transmitted, the no-op */
427 if (!mon->msg || mon->msg->txOffset == mon->msg->txLength)
428 return 0;
429
430 buf = mon->msg->txBuffer + mon->msg->txOffset;
431 len = mon->msg->txLength - mon->msg->txOffset;
432 if (mon->msg->txFD == -1)
433 done = write(mon->fd, buf, len);
434 else
435 done = qemuMonitorIOWriteWithFD(mon, buf, len, mon->msg->txFD);
436
437 PROBE(QEMU_MONITOR_IO_WRITE,
438 "mon=%p buf=%s len=%zu ret=%d errno=%d",
439 mon, buf, len, done, done < 0 ? errno : 0);
440
441 if (mon->msg->txFD != -1) {
442 PROBE(QEMU_MONITOR_IO_SEND_FD,
443 "mon=%p fd=%d ret=%d errno=%d",
444 mon, mon->msg->txFD, done, done < 0 ? errno : 0);
445 }
446
447 if (done < 0) {
448 if (errno == EAGAIN)
449 return 0;
450
451 virReportSystemError(errno, "%s",
452 _("Unable to write to monitor"));
453 return -1;
454 }
455 mon->msg->txOffset += done;
456 return done;
457 }
458
459
460 /*
461 * Called when the monitor has incoming data to read
462 * Call this function while holding the monitor lock.
463 *
464 * Returns -1 on error, or number of bytes read
465 */
466 static int
qemuMonitorIORead(qemuMonitor * mon)467 qemuMonitorIORead(qemuMonitor *mon)
468 {
469 size_t avail = mon->bufferLength - mon->bufferOffset;
470 int ret = 0;
471
472 if (avail < 1024) {
473 if (mon->bufferLength >= QEMU_MONITOR_MAX_RESPONSE) {
474 virReportError(VIR_ERR_INTERNAL_ERROR,
475 _("QEMU monitor reply exceeds buffer size (%d bytes)"),
476 QEMU_MONITOR_MAX_RESPONSE);
477 return -1;
478 }
479 VIR_REALLOC_N(mon->buffer, mon->bufferLength + 1024);
480 mon->bufferLength += 1024;
481 avail += 1024;
482 }
483
484 /* Read as much as we can get into our buffer,
485 until we block on EAGAIN, or hit EOF */
486 while (avail > 1) {
487 int got;
488 got = read(mon->fd,
489 mon->buffer + mon->bufferOffset,
490 avail - 1);
491 if (got < 0) {
492 if (errno == EAGAIN)
493 break;
494 virReportSystemError(errno, "%s",
495 _("Unable to read from monitor"));
496 ret = -1;
497 break;
498 }
499 if (got == 0)
500 break;
501
502 ret += got;
503 avail -= got;
504 mon->bufferOffset += got;
505 mon->buffer[mon->bufferOffset] = '\0';
506 }
507
508 #if DEBUG_IO
509 VIR_DEBUG("Now read %d bytes of data", (int)mon->bufferOffset);
510 #endif
511
512 return ret;
513 }
514
515
516 static void
qemuMonitorUpdateWatch(qemuMonitor * mon)517 qemuMonitorUpdateWatch(qemuMonitor *mon)
518 {
519 qemuMonitorUnregister(mon);
520 if (mon->socket)
521 qemuMonitorRegister(mon);
522 }
523
524
525 static gboolean
qemuMonitorIO(GSocket * socket G_GNUC_UNUSED,GIOCondition cond,gpointer opaque)526 qemuMonitorIO(GSocket *socket G_GNUC_UNUSED,
527 GIOCondition cond,
528 gpointer opaque)
529 {
530 qemuMonitor *mon = opaque;
531 bool error = false;
532 bool hangup = false;
533
534 virObjectRef(mon);
535
536 /* lock access to the monitor and protect fd */
537 virObjectLock(mon);
538 #if DEBUG_IO
539 VIR_DEBUG("Monitor %p I/O on socket %p cond %d", mon, socket, cond);
540 #endif
541 if (mon->fd == -1 || !mon->watch) {
542 virObjectUnlock(mon);
543 virObjectUnref(mon);
544 return G_SOURCE_REMOVE;
545 }
546
547 if (mon->lastError.code != VIR_ERR_OK) {
548 if (cond & (G_IO_HUP | G_IO_ERR))
549 mon->goteof = true;
550 error = true;
551 } else {
552 if (cond & G_IO_OUT) {
553 if (qemuMonitorIOWrite(mon) < 0) {
554 error = true;
555 if (errno == ECONNRESET)
556 hangup = true;
557 }
558 }
559
560 if (!error && cond & G_IO_IN) {
561 int got = qemuMonitorIORead(mon);
562 if (got < 0) {
563 error = true;
564 if (errno == ECONNRESET)
565 hangup = true;
566 } else if (got == 0) {
567 mon->goteof = true;
568 } else {
569 /* Ignore hangup/error cond if we read some data, to
570 * give time for that data to be consumed */
571 cond = 0;
572
573 if (qemuMonitorIOProcess(mon) < 0)
574 error = true;
575 }
576 }
577
578 if (cond & G_IO_HUP) {
579 hangup = true;
580 if (!error)
581 mon->goteof = true;
582 }
583
584 if (!error && !mon->goteof &&
585 cond & G_IO_ERR) {
586 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
587 _("Invalid file descriptor while waiting for monitor"));
588 mon->goteof = true;
589 }
590 }
591
592 if (error || mon->goteof) {
593 if (hangup && mon->logFunc != NULL) {
594 /* Check if an error message from qemu is available and if so, use
595 * it to overwrite the actual message. It's done only in early
596 * startup phases or during incoming migration when the message
597 * from qemu is certainly more interesting than a
598 * "connection reset by peer" message.
599 */
600 mon->logFunc(mon,
601 _("qemu unexpectedly closed the monitor"),
602 mon->logOpaque);
603 virCopyLastError(&mon->lastError);
604 virResetLastError();
605 }
606
607 if (mon->lastError.code != VIR_ERR_OK) {
608 /* Already have an error, so clear any new error */
609 virResetLastError();
610 } else {
611 if (virGetLastErrorCode() == VIR_ERR_OK && !mon->goteof)
612 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
613 _("Error while processing monitor IO"));
614 virCopyLastError(&mon->lastError);
615 virResetLastError();
616 }
617
618 VIR_DEBUG("Error on monitor %s", NULLSTR(mon->lastError.message));
619 /* If IO process resulted in an error & we have a message,
620 * then wakeup that waiter */
621 if (mon->msg && !mon->msg->finished) {
622 mon->msg->finished = true;
623 virCondSignal(&mon->notify);
624 }
625 }
626
627 qemuMonitorUpdateWatch(mon);
628
629 /* We have to unlock to avoid deadlock against command thread,
630 * but is this safe ? I think it is, because the callback
631 * will try to acquire the virDomainObj *mutex next */
632 if (mon->goteof) {
633 qemuMonitorEofNotifyCallback eofNotify = mon->cb->eofNotify;
634 virDomainObj *vm = mon->vm;
635
636 /* Make sure anyone waiting wakes up now */
637 virCondSignal(&mon->notify);
638 virObjectUnlock(mon);
639 VIR_DEBUG("Triggering EOF callback");
640 (eofNotify)(mon, vm, mon->callbackOpaque);
641 virObjectUnref(mon);
642 } else if (error) {
643 qemuMonitorErrorNotifyCallback errorNotify = mon->cb->errorNotify;
644 virDomainObj *vm = mon->vm;
645
646 /* Make sure anyone waiting wakes up now */
647 virCondSignal(&mon->notify);
648 virObjectUnlock(mon);
649 VIR_DEBUG("Triggering error callback");
650 (errorNotify)(mon, vm, mon->callbackOpaque);
651 virObjectUnref(mon);
652 } else {
653 virObjectUnlock(mon);
654 virObjectUnref(mon);
655 }
656
657 return G_SOURCE_REMOVE;
658 }
659
660
661 static qemuMonitor *
qemuMonitorOpenInternal(virDomainObj * vm,int fd,GMainContext * context,qemuMonitorCallbacks * cb,void * opaque)662 qemuMonitorOpenInternal(virDomainObj *vm,
663 int fd,
664 GMainContext *context,
665 qemuMonitorCallbacks *cb,
666 void *opaque)
667 {
668 qemuDomainObjPrivate *priv = vm->privateData;
669 qemuMonitor *mon;
670 g_autoptr(GError) gerr = NULL;
671
672 if (!cb->eofNotify) {
673 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
674 _("EOF notify callback must be supplied"));
675 return NULL;
676 }
677 if (!cb->errorNotify) {
678 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
679 _("Error notify callback must be supplied"));
680 return NULL;
681 }
682
683 if (qemuMonitorInitialize() < 0)
684 return NULL;
685
686 if (!(mon = virObjectLockableNew(qemuMonitorClass)))
687 return NULL;
688
689 if (virCondInit(&mon->notify) < 0) {
690 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
691 _("cannot initialize monitor condition"));
692 goto cleanup;
693 }
694 mon->fd = fd;
695 mon->context = g_main_context_ref(context);
696 mon->vm = virObjectRef(vm);
697 mon->waitGreeting = true;
698 mon->cb = cb;
699 mon->callbackOpaque = opaque;
700
701 if (priv)
702 mon->objectAddNoWrap = virQEMUCapsGet(priv->qemuCaps, QEMU_CAPS_OBJECT_JSON);
703
704 if (virSetCloseExec(mon->fd) < 0) {
705 virReportError(VIR_ERR_INTERNAL_ERROR,
706 "%s", _("Unable to set monitor close-on-exec flag"));
707 goto cleanup;
708 }
709
710 mon->socket = g_socket_new_from_fd(fd, &gerr);
711 if (!mon->socket) {
712 virReportError(VIR_ERR_INTERNAL_ERROR,
713 _("Unable to create socket object: %s"),
714 gerr->message);
715 goto cleanup;
716 }
717
718 virObjectLock(mon);
719 qemuMonitorRegister(mon);
720
721 PROBE(QEMU_MONITOR_NEW, "mon=%p fd=%d", mon, mon->fd);
722 virObjectUnlock(mon);
723
724 return mon;
725
726 cleanup:
727 /* We don't want the 'destroy' callback invoked during
728 * cleanup from construction failure, because that can
729 * give a double-unref on virDomainObj *in the caller,
730 * so kill the callbacks now.
731 */
732 mon->cb = NULL;
733 /* The caller owns 'fd' on failure */
734 mon->fd = -1;
735 qemuMonitorClose(mon);
736 return NULL;
737 }
738
739
740 #define QEMU_DEFAULT_MONITOR_WAIT 30
741
742 /**
743 * qemuMonitorOpen:
744 * @vm: domain object
745 * @config: monitor configuration
746 * @timeout: number of seconds to add to default timeout
747 * @cb: monitor event handles
748 * @opaque: opaque data for @cb
749 *
750 * Opens the monitor for running qemu. It may happen that it
751 * takes some time for qemu to create the monitor socket (e.g.
752 * because kernel is zeroing configured hugepages), therefore we
753 * wait up to default + timeout seconds for the monitor to show
754 * up after which a failure is claimed.
755 *
756 * Returns monitor object, NULL on error.
757 */
758 qemuMonitor *
qemuMonitorOpen(virDomainObj * vm,virDomainChrSourceDef * config,bool retry,unsigned long long timeout,GMainContext * context,qemuMonitorCallbacks * cb,void * opaque)759 qemuMonitorOpen(virDomainObj *vm,
760 virDomainChrSourceDef *config,
761 bool retry,
762 unsigned long long timeout,
763 GMainContext *context,
764 qemuMonitorCallbacks *cb,
765 void *opaque)
766 {
767 int fd = -1;
768 qemuMonitor *ret = NULL;
769
770 timeout += QEMU_DEFAULT_MONITOR_WAIT;
771
772 if (config->type != VIR_DOMAIN_CHR_TYPE_UNIX) {
773 virReportError(VIR_ERR_INTERNAL_ERROR,
774 _("unable to handle monitor type: %s"),
775 virDomainChrTypeToString(config->type));
776 goto cleanup;
777 }
778
779 virObjectUnlock(vm);
780 fd = qemuMonitorOpenUnix(config->data.nix.path,
781 vm->pid, retry, timeout);
782 virObjectLock(vm);
783
784 if (fd < 0)
785 goto cleanup;
786
787 if (!virDomainObjIsActive(vm)) {
788 virReportError(VIR_ERR_OPERATION_FAILED, "%s",
789 _("domain is not running"));
790 goto cleanup;
791 }
792
793 ret = qemuMonitorOpenInternal(vm, fd, context, cb, opaque);
794 cleanup:
795 if (!ret)
796 VIR_FORCE_CLOSE(fd);
797 return ret;
798 }
799
800
qemuMonitorWatchDispose(void)801 void qemuMonitorWatchDispose(void)
802 {
803 qemuMonitorDisposed = false;
804 }
805
806
qemuMonitorWasDisposed(void)807 bool qemuMonitorWasDisposed(void)
808 {
809 return qemuMonitorDisposed;
810 }
811
812
813 /**
814 * qemuMonitorRegister:
815 * @mon: QEMU monitor
816 *
817 * Registers the monitor in the event loop. The caller has to hold the
818 * lock for @mon.
819 */
820 void
qemuMonitorRegister(qemuMonitor * mon)821 qemuMonitorRegister(qemuMonitor *mon)
822 {
823 GIOCondition cond = 0;
824
825 if (mon->lastError.code == VIR_ERR_OK) {
826 cond |= G_IO_IN;
827
828 if ((mon->msg && mon->msg->txOffset < mon->msg->txLength) &&
829 !mon->waitGreeting)
830 cond |= G_IO_OUT;
831 }
832
833 mon->watch = g_socket_create_source(mon->socket,
834 cond,
835 NULL);
836
837 virObjectRef(mon);
838 g_source_set_callback(mon->watch,
839 (GSourceFunc)qemuMonitorIO,
840 mon,
841 (GDestroyNotify)virObjectUnref);
842
843 g_source_attach(mon->watch,
844 mon->context);
845 }
846
847
848 /**
849 * qemuMonitorUnregister:
850 * @mon: monitor object
851 *
852 * Unregister monitor from the event loop. The monitor object
853 * must be locked before calling this function.
854 */
855 void
qemuMonitorUnregister(qemuMonitor * mon)856 qemuMonitorUnregister(qemuMonitor *mon)
857 {
858 if (mon->watch) {
859 g_source_destroy(mon->watch);
860 vir_g_source_unref(mon->watch, mon->context);
861 mon->watch = NULL;
862 }
863 }
864
865 void
qemuMonitorClose(qemuMonitor * mon)866 qemuMonitorClose(qemuMonitor *mon)
867 {
868 if (!mon)
869 return;
870
871 virObjectLock(mon);
872 PROBE(QEMU_MONITOR_CLOSE, "mon=%p", mon);
873
874 qemuMonitorSetDomainLogLocked(mon, NULL, NULL, NULL);
875
876 if (mon->socket) {
877 qemuMonitorUnregister(mon);
878 g_object_unref(mon->socket);
879 mon->socket = NULL;
880 mon->fd = -1;
881 }
882
883 /* In case another thread is waiting for its monitor command to be
884 * processed, we need to wake it up with appropriate error set.
885 */
886 if (mon->msg) {
887 if (mon->lastError.code == VIR_ERR_OK) {
888 virErrorPtr err;
889
890 virErrorPreserveLast(&err);
891
892 virReportError(VIR_ERR_OPERATION_FAILED, "%s",
893 _("QEMU monitor was closed"));
894 virCopyLastError(&mon->lastError);
895 if (err)
896 virErrorRestore(&err);
897 else
898 virResetLastError();
899 }
900 mon->msg->finished = true;
901 virCondSignal(&mon->notify);
902 }
903
904 /* Propagate existing monitor error in case the current thread has no
905 * error set.
906 */
907 if (mon->lastError.code != VIR_ERR_OK && virGetLastErrorCode() == VIR_ERR_OK)
908 virSetError(&mon->lastError);
909
910 virObjectUnlock(mon);
911 virObjectUnref(mon);
912 }
913
914
915 char *
qemuMonitorNextCommandID(qemuMonitor * mon)916 qemuMonitorNextCommandID(qemuMonitor *mon)
917 {
918 return g_strdup_printf("libvirt-%d", ++mon->nextSerial);
919 }
920
921
922 /* for use only in the test suite */
923 void
qemuMonitorResetCommandID(qemuMonitor * mon)924 qemuMonitorResetCommandID(qemuMonitor *mon)
925 {
926 mon->nextSerial = 0;
927 }
928
929
930 int
qemuMonitorSend(qemuMonitor * mon,qemuMonitorMessage * msg)931 qemuMonitorSend(qemuMonitor *mon,
932 qemuMonitorMessage *msg)
933 {
934 int ret = -1;
935
936 /* Check whether qemu quit unexpectedly */
937 if (mon->lastError.code != VIR_ERR_OK) {
938 VIR_DEBUG("Attempt to send command while error is set %s",
939 NULLSTR(mon->lastError.message));
940 virSetError(&mon->lastError);
941 return -1;
942 }
943 if (mon->goteof) {
944 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
945 _("End of file from qemu monitor"));
946 return -1;
947 }
948
949 mon->msg = msg;
950 qemuMonitorUpdateWatch(mon);
951
952 PROBE(QEMU_MONITOR_SEND_MSG,
953 "mon=%p msg=%s fd=%d",
954 mon, mon->msg->txBuffer, mon->msg->txFD);
955
956 while (!mon->msg->finished) {
957 if (virCondWait(&mon->notify, &mon->parent.lock) < 0) {
958 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
959 _("Unable to wait on monitor condition"));
960 goto cleanup;
961 }
962 }
963
964 if (mon->lastError.code != VIR_ERR_OK) {
965 VIR_DEBUG("Send command resulted in error %s",
966 NULLSTR(mon->lastError.message));
967 virSetError(&mon->lastError);
968 goto cleanup;
969 }
970
971 ret = 0;
972
973 cleanup:
974 mon->msg = NULL;
975 qemuMonitorUpdateWatch(mon);
976
977 return ret;
978 }
979
980
981 /**
982 * This function returns a new virError object; the caller is responsible
983 * for freeing it.
984 */
985 virErrorPtr
qemuMonitorLastError(qemuMonitor * mon)986 qemuMonitorLastError(qemuMonitor *mon)
987 {
988 if (mon->lastError.code == VIR_ERR_OK)
989 return NULL;
990
991 return virErrorCopyNew(&mon->lastError);
992 }
993
994
995 /**
996 * Search the qom objects for the balloon driver object by its known names
997 * of "virtio-balloon-pci" or "virtio-balloon-ccw". The entry for the driver
998 * will be found by using function "qemuMonitorJSONFindLinkPath".
999 *
1000 * Once found, check the entry to ensure it has the correct property listed.
1001 * If it does not, then obtaining statistics from QEMU will not be possible.
1002 * This feature was added to QEMU 1.5.
1003 */
1004 static void
qemuMonitorInitBalloonObjectPath(qemuMonitor * mon,virDomainMemballoonDef * balloon)1005 qemuMonitorInitBalloonObjectPath(qemuMonitor *mon,
1006 virDomainMemballoonDef *balloon)
1007 {
1008 ssize_t i, nprops = 0;
1009 char *path = NULL;
1010 const char *name;
1011 qemuMonitorJSONListPath **bprops = NULL;
1012
1013 if (mon->balloonpath) {
1014 return;
1015 } else if (mon->ballooninit) {
1016 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1017 _("Cannot determine balloon device path"));
1018 return;
1019 }
1020 mon->ballooninit = true;
1021
1022 switch (balloon->info.type) {
1023 case VIR_DOMAIN_DEVICE_ADDRESS_TYPE_PCI:
1024 switch (balloon->model) {
1025 case VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO:
1026 name = "virtio-balloon-pci";
1027 break;
1028 case VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO_TRANSITIONAL:
1029 name = "virtio-balloon-pci-transitional";
1030 break;
1031 case VIR_DOMAIN_MEMBALLOON_MODEL_VIRTIO_NON_TRANSITIONAL:
1032 name = "virtio-balloon-pci-non-transitional";
1033 break;
1034 case VIR_DOMAIN_MEMBALLOON_MODEL_XEN:
1035 case VIR_DOMAIN_MEMBALLOON_MODEL_NONE:
1036 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1037 _("invalid model for virtio-balloon-pci"));
1038 return;
1039 case VIR_DOMAIN_MEMBALLOON_MODEL_LAST:
1040 default:
1041 virReportEnumRangeError(virDomainMemballoonModel,
1042 balloon->model);
1043 return;
1044 }
1045 break;
1046 case VIR_DOMAIN_DEVICE_ADDRESS_TYPE_CCW:
1047 name = "virtio-balloon-ccw";
1048 break;
1049 default:
1050 return;
1051 }
1052
1053 if (qemuMonitorJSONFindLinkPath(mon, name, balloon->info.alias, &path) < 0)
1054 return;
1055
1056 nprops = qemuMonitorJSONGetObjectListPaths(mon, path, &bprops);
1057 if (nprops < 0)
1058 goto cleanup;
1059
1060 for (i = 0; i < nprops; i++) {
1061 if (STREQ(bprops[i]->name, "guest-stats-polling-interval")) {
1062 VIR_DEBUG("Found Balloon Object Path %s", path);
1063 mon->balloonpath = g_steal_pointer(&path);
1064 goto cleanup;
1065 }
1066 }
1067
1068
1069 /* If we get here, we found the path, but not the property */
1070 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
1071 _("Property 'guest-stats-polling-interval' "
1072 "not found on memory balloon driver."));
1073
1074 cleanup:
1075 for (i = 0; i < nprops; i++)
1076 qemuMonitorJSONListPathFree(bprops[i]);
1077 VIR_FREE(bprops);
1078 VIR_FREE(path);
1079 return;
1080 }
1081
1082
1083 /**
1084 * To update video memory size in status XML we need to load correct values from
1085 * QEMU.
1086 *
1087 * Returns 0 on success, -1 on failure and sets proper error message.
1088 */
1089 int
qemuMonitorUpdateVideoMemorySize(qemuMonitor * mon,virDomainVideoDef * video,const char * videoName)1090 qemuMonitorUpdateVideoMemorySize(qemuMonitor *mon,
1091 virDomainVideoDef *video,
1092 const char *videoName)
1093 {
1094 int rc = -1;
1095 g_autofree char *path = NULL;
1096
1097 QEMU_CHECK_MONITOR(mon);
1098
1099 rc = qemuMonitorJSONFindLinkPath(mon, videoName,
1100 video->info.alias, &path);
1101 if (rc < 0) {
1102 if (rc == -2)
1103 virReportError(VIR_ERR_INTERNAL_ERROR,
1104 _("Failed to find QOM Object path for "
1105 "device '%s'"), videoName);
1106 return -1;
1107 }
1108
1109 return qemuMonitorJSONUpdateVideoMemorySize(mon, video, path);
1110 }
1111
1112
1113 /**
1114 * To update video vram64 size in status XML we need to load correct value from
1115 * QEMU.
1116 *
1117 * Returns 0 on success, -1 on failure and sets proper error message.
1118 */
1119 int
qemuMonitorUpdateVideoVram64Size(qemuMonitor * mon,virDomainVideoDef * video,const char * videoName)1120 qemuMonitorUpdateVideoVram64Size(qemuMonitor *mon,
1121 virDomainVideoDef *video,
1122 const char *videoName)
1123 {
1124 int rc = -1;
1125 g_autofree char *path = NULL;
1126
1127 QEMU_CHECK_MONITOR(mon);
1128
1129 rc = qemuMonitorJSONFindLinkPath(mon, videoName,
1130 video->info.alias, &path);
1131 if (rc < 0) {
1132 if (rc == -2)
1133 virReportError(VIR_ERR_INTERNAL_ERROR,
1134 _("Failed to find QOM Object path for "
1135 "device '%s'"), videoName);
1136 return -1;
1137 }
1138
1139 return qemuMonitorJSONUpdateVideoVram64Size(mon, video, path);
1140 }
1141
1142
1143 /* Ensure proper locking around callbacks. */
1144 #define QEMU_MONITOR_CALLBACK(mon, callback, ...) \
1145 do { \
1146 virObjectRef(mon); \
1147 virObjectUnlock(mon); \
1148 if ((mon)->cb && (mon)->cb->callback) \
1149 (mon)->cb->callback(mon, __VA_ARGS__, (mon)->callbackOpaque); \
1150 virObjectLock(mon); \
1151 virObjectUnref(mon); \
1152 } while (0)
1153
1154
1155 void
qemuMonitorEmitEvent(qemuMonitor * mon,const char * event,long long seconds,unsigned int micros,const char * details)1156 qemuMonitorEmitEvent(qemuMonitor *mon, const char *event,
1157 long long seconds, unsigned int micros,
1158 const char *details)
1159 {
1160 VIR_DEBUG("mon=%p event=%s", mon, event);
1161
1162 QEMU_MONITOR_CALLBACK(mon, domainEvent, mon->vm, event, seconds,
1163 micros, details);
1164 }
1165
1166
1167 void
qemuMonitorEmitShutdown(qemuMonitor * mon,virTristateBool guest)1168 qemuMonitorEmitShutdown(qemuMonitor *mon, virTristateBool guest)
1169 {
1170 VIR_DEBUG("mon=%p guest=%u", mon, guest);
1171
1172 QEMU_MONITOR_CALLBACK(mon, domainShutdown, mon->vm, guest);
1173 }
1174
1175
1176 void
qemuMonitorEmitReset(qemuMonitor * mon)1177 qemuMonitorEmitReset(qemuMonitor *mon)
1178 {
1179 VIR_DEBUG("mon=%p", mon);
1180
1181 QEMU_MONITOR_CALLBACK(mon, domainReset, mon->vm);
1182 }
1183
1184
1185 void
qemuMonitorEmitStop(qemuMonitor * mon)1186 qemuMonitorEmitStop(qemuMonitor *mon)
1187 {
1188 VIR_DEBUG("mon=%p", mon);
1189
1190 QEMU_MONITOR_CALLBACK(mon, domainStop, mon->vm);
1191 }
1192
1193
1194 void
qemuMonitorEmitResume(qemuMonitor * mon)1195 qemuMonitorEmitResume(qemuMonitor *mon)
1196 {
1197 VIR_DEBUG("mon=%p", mon);
1198
1199 QEMU_MONITOR_CALLBACK(mon, domainResume, mon->vm);
1200 }
1201
1202
1203 void
qemuMonitorEmitGuestPanic(qemuMonitor * mon,qemuMonitorEventPanicInfo * info)1204 qemuMonitorEmitGuestPanic(qemuMonitor *mon,
1205 qemuMonitorEventPanicInfo *info)
1206 {
1207 VIR_DEBUG("mon=%p", mon);
1208 QEMU_MONITOR_CALLBACK(mon, domainGuestPanic, mon->vm, info);
1209 }
1210
1211
1212 void
qemuMonitorEmitRTCChange(qemuMonitor * mon,long long offset)1213 qemuMonitorEmitRTCChange(qemuMonitor *mon, long long offset)
1214 {
1215 VIR_DEBUG("mon=%p", mon);
1216
1217 QEMU_MONITOR_CALLBACK(mon, domainRTCChange, mon->vm, offset);
1218 }
1219
1220
1221 void
qemuMonitorEmitWatchdog(qemuMonitor * mon,int action)1222 qemuMonitorEmitWatchdog(qemuMonitor *mon, int action)
1223 {
1224 VIR_DEBUG("mon=%p", mon);
1225
1226 QEMU_MONITOR_CALLBACK(mon, domainWatchdog, mon->vm, action);
1227 }
1228
1229
1230 void
qemuMonitorEmitIOError(qemuMonitor * mon,const char * diskAlias,const char * nodename,int action,const char * reason)1231 qemuMonitorEmitIOError(qemuMonitor *mon,
1232 const char *diskAlias,
1233 const char *nodename,
1234 int action,
1235 const char *reason)
1236 {
1237 VIR_DEBUG("mon=%p", mon);
1238
1239 QEMU_MONITOR_CALLBACK(mon, domainIOError, mon->vm,
1240 diskAlias, nodename, action, reason);
1241 }
1242
1243
1244 void
qemuMonitorEmitGraphics(qemuMonitor * mon,int phase,int localFamily,const char * localNode,const char * localService,int remoteFamily,const char * remoteNode,const char * remoteService,const char * authScheme,const char * x509dname,const char * saslUsername)1245 qemuMonitorEmitGraphics(qemuMonitor *mon,
1246 int phase,
1247 int localFamily,
1248 const char *localNode,
1249 const char *localService,
1250 int remoteFamily,
1251 const char *remoteNode,
1252 const char *remoteService,
1253 const char *authScheme,
1254 const char *x509dname,
1255 const char *saslUsername)
1256 {
1257 VIR_DEBUG("mon=%p", mon);
1258
1259 QEMU_MONITOR_CALLBACK(mon, domainGraphics, mon->vm, phase,
1260 localFamily, localNode, localService,
1261 remoteFamily, remoteNode, remoteService,
1262 authScheme, x509dname, saslUsername);
1263 }
1264
1265
1266 void
qemuMonitorEmitTrayChange(qemuMonitor * mon,const char * devAlias,const char * devid,int reason)1267 qemuMonitorEmitTrayChange(qemuMonitor *mon,
1268 const char *devAlias,
1269 const char *devid,
1270 int reason)
1271 {
1272 VIR_DEBUG("mon=%p", mon);
1273
1274 QEMU_MONITOR_CALLBACK(mon, domainTrayChange, mon->vm,
1275 devAlias, devid, reason);
1276 }
1277
1278
1279 void
qemuMonitorEmitPMWakeup(qemuMonitor * mon)1280 qemuMonitorEmitPMWakeup(qemuMonitor *mon)
1281 {
1282 VIR_DEBUG("mon=%p", mon);
1283
1284 QEMU_MONITOR_CALLBACK(mon, domainPMWakeup, mon->vm);
1285 }
1286
1287
1288 void
qemuMonitorEmitPMSuspend(qemuMonitor * mon)1289 qemuMonitorEmitPMSuspend(qemuMonitor *mon)
1290 {
1291 VIR_DEBUG("mon=%p", mon);
1292
1293 QEMU_MONITOR_CALLBACK(mon, domainPMSuspend, mon->vm);
1294 }
1295
1296
1297 void
qemuMonitorEmitPMSuspendDisk(qemuMonitor * mon)1298 qemuMonitorEmitPMSuspendDisk(qemuMonitor *mon)
1299 {
1300 VIR_DEBUG("mon=%p", mon);
1301
1302 QEMU_MONITOR_CALLBACK(mon, domainPMSuspendDisk, mon->vm);
1303 }
1304
1305
1306 void
qemuMonitorEmitBlockJob(qemuMonitor * mon,const char * diskAlias,int type,int status,const char * error)1307 qemuMonitorEmitBlockJob(qemuMonitor *mon,
1308 const char *diskAlias,
1309 int type,
1310 int status,
1311 const char *error)
1312 {
1313 VIR_DEBUG("mon=%p", mon);
1314
1315 QEMU_MONITOR_CALLBACK(mon, domainBlockJob, mon->vm,
1316 diskAlias, type, status, error);
1317 }
1318
1319
1320 void
qemuMonitorEmitJobStatusChange(qemuMonitor * mon,const char * jobname,qemuMonitorJobStatus status)1321 qemuMonitorEmitJobStatusChange(qemuMonitor *mon,
1322 const char *jobname,
1323 qemuMonitorJobStatus status)
1324 {
1325 VIR_DEBUG("mon=%p", mon);
1326
1327 QEMU_MONITOR_CALLBACK(mon, jobStatusChange, mon->vm, jobname, status);
1328 }
1329
1330
1331 void
qemuMonitorEmitBalloonChange(qemuMonitor * mon,unsigned long long actual)1332 qemuMonitorEmitBalloonChange(qemuMonitor *mon,
1333 unsigned long long actual)
1334 {
1335 VIR_DEBUG("mon=%p", mon);
1336
1337 QEMU_MONITOR_CALLBACK(mon, domainBalloonChange, mon->vm, actual);
1338 }
1339
1340
1341 void
qemuMonitorEmitDeviceDeleted(qemuMonitor * mon,const char * devAlias)1342 qemuMonitorEmitDeviceDeleted(qemuMonitor *mon,
1343 const char *devAlias)
1344 {
1345 VIR_DEBUG("mon=%p", mon);
1346
1347 QEMU_MONITOR_CALLBACK(mon, domainDeviceDeleted, mon->vm, devAlias);
1348 }
1349
1350
1351 void
qemuMonitorEmitDeviceUnplugErr(qemuMonitor * mon,const char * devPath,const char * devAlias)1352 qemuMonitorEmitDeviceUnplugErr(qemuMonitor *mon,
1353 const char *devPath,
1354 const char *devAlias)
1355 {
1356 VIR_DEBUG("mon=%p", mon);
1357
1358 QEMU_MONITOR_CALLBACK(mon, domainDeviceUnplugError, mon->vm,
1359 devPath, devAlias);
1360 }
1361
1362
1363 void
qemuMonitorEmitNicRxFilterChanged(qemuMonitor * mon,const char * devAlias)1364 qemuMonitorEmitNicRxFilterChanged(qemuMonitor *mon,
1365 const char *devAlias)
1366 {
1367 VIR_DEBUG("mon=%p", mon);
1368
1369 QEMU_MONITOR_CALLBACK(mon, domainNicRxFilterChanged, mon->vm, devAlias);
1370 }
1371
1372
1373 void
qemuMonitorEmitSerialChange(qemuMonitor * mon,const char * devAlias,bool connected)1374 qemuMonitorEmitSerialChange(qemuMonitor *mon,
1375 const char *devAlias,
1376 bool connected)
1377 {
1378 VIR_DEBUG("mon=%p, devAlias='%s', connected=%d", mon, devAlias, connected);
1379
1380 QEMU_MONITOR_CALLBACK(mon, domainSerialChange, mon->vm, devAlias, connected);
1381 }
1382
1383
1384 void
qemuMonitorEmitSpiceMigrated(qemuMonitor * mon)1385 qemuMonitorEmitSpiceMigrated(qemuMonitor *mon)
1386 {
1387 VIR_DEBUG("mon=%p", mon);
1388
1389 QEMU_MONITOR_CALLBACK(mon, domainSpiceMigrated, mon->vm);
1390 }
1391
1392
1393 void
qemuMonitorEmitMemoryDeviceSizeChange(qemuMonitor * mon,const char * devAlias,unsigned long long size)1394 qemuMonitorEmitMemoryDeviceSizeChange(qemuMonitor *mon,
1395 const char *devAlias,
1396 unsigned long long size)
1397 {
1398 VIR_DEBUG("mon=%p, devAlias='%s', size=%llu", mon, devAlias, size);
1399
1400 QEMU_MONITOR_CALLBACK(mon, domainMemoryDeviceSizeChange, mon->vm, devAlias, size);
1401 }
1402
1403
1404 void
qemuMonitorEmitMemoryFailure(qemuMonitor * mon,qemuMonitorEventMemoryFailure * mfp)1405 qemuMonitorEmitMemoryFailure(qemuMonitor *mon,
1406 qemuMonitorEventMemoryFailure *mfp)
1407 {
1408 QEMU_MONITOR_CALLBACK(mon, domainMemoryFailure, mon->vm, mfp);
1409 }
1410
1411
1412 void
qemuMonitorEmitMigrationStatus(qemuMonitor * mon,int status)1413 qemuMonitorEmitMigrationStatus(qemuMonitor *mon,
1414 int status)
1415 {
1416 VIR_DEBUG("mon=%p, status=%s",
1417 mon, NULLSTR(qemuMonitorMigrationStatusTypeToString(status)));
1418
1419 QEMU_MONITOR_CALLBACK(mon, domainMigrationStatus, mon->vm, status);
1420 }
1421
1422
1423 void
qemuMonitorEmitMigrationPass(qemuMonitor * mon,int pass)1424 qemuMonitorEmitMigrationPass(qemuMonitor *mon,
1425 int pass)
1426 {
1427 VIR_DEBUG("mon=%p, pass=%d", mon, pass);
1428
1429 QEMU_MONITOR_CALLBACK(mon, domainMigrationPass, mon->vm, pass);
1430 }
1431
1432
1433 void
qemuMonitorEmitAcpiOstInfo(qemuMonitor * mon,const char * alias,const char * slotType,const char * slot,unsigned int source,unsigned int status)1434 qemuMonitorEmitAcpiOstInfo(qemuMonitor *mon,
1435 const char *alias,
1436 const char *slotType,
1437 const char *slot,
1438 unsigned int source,
1439 unsigned int status)
1440 {
1441 VIR_DEBUG("mon=%p, alias='%s', slotType='%s', slot='%s', source='%u' status=%u",
1442 mon, NULLSTR(alias), slotType, slot, source, status);
1443
1444 QEMU_MONITOR_CALLBACK(mon, domainAcpiOstInfo, mon->vm,
1445 alias, slotType, slot, source, status);
1446 }
1447
1448
1449 void
qemuMonitorEmitBlockThreshold(qemuMonitor * mon,const char * nodename,unsigned long long threshold,unsigned long long excess)1450 qemuMonitorEmitBlockThreshold(qemuMonitor *mon,
1451 const char *nodename,
1452 unsigned long long threshold,
1453 unsigned long long excess)
1454 {
1455 VIR_DEBUG("mon=%p, node-name='%s', threshold='%llu', excess='%llu'",
1456 mon, nodename, threshold, excess);
1457
1458 QEMU_MONITOR_CALLBACK(mon, domainBlockThreshold, mon->vm,
1459 nodename, threshold, excess);
1460 }
1461
1462
1463 void
qemuMonitorEmitDumpCompleted(qemuMonitor * mon,int status,qemuMonitorDumpStats * stats,const char * error)1464 qemuMonitorEmitDumpCompleted(qemuMonitor *mon,
1465 int status,
1466 qemuMonitorDumpStats *stats,
1467 const char *error)
1468 {
1469 VIR_DEBUG("mon=%p", mon);
1470
1471 QEMU_MONITOR_CALLBACK(mon, domainDumpCompleted, mon->vm,
1472 status, stats, error);
1473 }
1474
1475
1476 void
qemuMonitorEmitPRManagerStatusChanged(qemuMonitor * mon,const char * prManager,bool connected)1477 qemuMonitorEmitPRManagerStatusChanged(qemuMonitor *mon,
1478 const char *prManager,
1479 bool connected)
1480 {
1481 VIR_DEBUG("mon=%p, prManager='%s', connected=%d", mon, prManager, connected);
1482
1483 QEMU_MONITOR_CALLBACK(mon, domainPRManagerStatusChanged,
1484 mon->vm, prManager, connected);
1485 }
1486
1487
1488 void
qemuMonitorEmitRdmaGidStatusChanged(qemuMonitor * mon,const char * netdev,bool gid_status,unsigned long long subnet_prefix,unsigned long long interface_id)1489 qemuMonitorEmitRdmaGidStatusChanged(qemuMonitor *mon,
1490 const char *netdev,
1491 bool gid_status,
1492 unsigned long long subnet_prefix,
1493 unsigned long long interface_id)
1494 {
1495 VIR_DEBUG("netdev=%s, gid_status=%d, subnet_prefix=0x%llx, interface_id=0x%llx",
1496 netdev, gid_status, subnet_prefix, interface_id);
1497
1498 QEMU_MONITOR_CALLBACK(mon, domainRdmaGidStatusChanged, mon->vm,
1499 netdev, gid_status, subnet_prefix, interface_id);
1500 }
1501
1502
1503 void
qemuMonitorEmitGuestCrashloaded(qemuMonitor * mon)1504 qemuMonitorEmitGuestCrashloaded(qemuMonitor *mon)
1505 {
1506 VIR_DEBUG("mon=%p", mon);
1507 QEMU_MONITOR_CALLBACK(mon, domainGuestCrashloaded, mon->vm);
1508 }
1509
1510
1511 int
qemuMonitorSetCapabilities(qemuMonitor * mon)1512 qemuMonitorSetCapabilities(qemuMonitor *mon)
1513 {
1514 QEMU_CHECK_MONITOR(mon);
1515
1516 return qemuMonitorJSONSetCapabilities(mon);
1517 }
1518
1519
1520 int
qemuMonitorStartCPUs(qemuMonitor * mon)1521 qemuMonitorStartCPUs(qemuMonitor *mon)
1522 {
1523 QEMU_CHECK_MONITOR(mon);
1524
1525 return qemuMonitorJSONStartCPUs(mon);
1526 }
1527
1528
1529 int
qemuMonitorStopCPUs(qemuMonitor * mon)1530 qemuMonitorStopCPUs(qemuMonitor *mon)
1531 {
1532 QEMU_CHECK_MONITOR(mon);
1533
1534 return qemuMonitorJSONStopCPUs(mon);
1535 }
1536
1537
1538 int
qemuMonitorCheck(qemuMonitor * mon)1539 qemuMonitorCheck(qemuMonitor *mon)
1540 {
1541 bool running;
1542 return qemuMonitorGetStatus(mon, &running, NULL);
1543 }
1544
1545
1546 int
qemuMonitorGetStatus(qemuMonitor * mon,bool * running,virDomainPausedReason * reason)1547 qemuMonitorGetStatus(qemuMonitor *mon,
1548 bool *running,
1549 virDomainPausedReason *reason)
1550 {
1551 VIR_DEBUG("running=%p, reason=%p", running, reason);
1552
1553 QEMU_CHECK_MONITOR(mon);
1554
1555 return qemuMonitorJSONGetStatus(mon, running, reason);
1556 }
1557
1558
1559 int
qemuMonitorSystemPowerdown(qemuMonitor * mon)1560 qemuMonitorSystemPowerdown(qemuMonitor *mon)
1561 {
1562 QEMU_CHECK_MONITOR(mon);
1563
1564 return qemuMonitorJSONSystemPowerdown(mon);
1565 }
1566
1567
1568 int
qemuMonitorSystemReset(qemuMonitor * mon)1569 qemuMonitorSystemReset(qemuMonitor *mon)
1570 {
1571 QEMU_CHECK_MONITOR(mon);
1572
1573 return qemuMonitorJSONSystemReset(mon);
1574 }
1575
1576
1577 static void
qemuMonitorCPUInfoClear(qemuMonitorCPUInfo * cpus,size_t ncpus)1578 qemuMonitorCPUInfoClear(qemuMonitorCPUInfo *cpus,
1579 size_t ncpus)
1580 {
1581 size_t i;
1582
1583 for (i = 0; i < ncpus; i++) {
1584 cpus[i].id = 0;
1585 cpus[i].qemu_id = -1;
1586 cpus[i].socket_id = -1;
1587 cpus[i].die_id = -1;
1588 cpus[i].core_id = -1;
1589 cpus[i].thread_id = -1;
1590 cpus[i].node_id = -1;
1591 cpus[i].vcpus = 0;
1592 cpus[i].tid = 0;
1593 cpus[i].halted = false;
1594
1595 VIR_FREE(cpus[i].qom_path);
1596 VIR_FREE(cpus[i].alias);
1597 VIR_FREE(cpus[i].type);
1598 virJSONValueFree(cpus[i].props);
1599 cpus[i].props = NULL;
1600 }
1601 }
1602
1603
1604 void
qemuMonitorCPUInfoFree(qemuMonitorCPUInfo * cpus,size_t ncpus)1605 qemuMonitorCPUInfoFree(qemuMonitorCPUInfo *cpus,
1606 size_t ncpus)
1607 {
1608 if (!cpus)
1609 return;
1610
1611 qemuMonitorCPUInfoClear(cpus, ncpus);
1612
1613 g_free(cpus);
1614 }
1615
1616 void
qemuMonitorQueryCpusFree(struct qemuMonitorQueryCpusEntry * entries,size_t nentries)1617 qemuMonitorQueryCpusFree(struct qemuMonitorQueryCpusEntry *entries,
1618 size_t nentries)
1619 {
1620 size_t i;
1621
1622 if (!entries)
1623 return;
1624
1625 for (i = 0; i < nentries; i++)
1626 g_free(entries[i].qom_path);
1627
1628 g_free(entries);
1629 }
1630
1631
1632 /**
1633 * Legacy approach doesn't allow out of order cpus, thus no complex matching
1634 * algorithm is necessary */
1635 static void
qemuMonitorGetCPUInfoLegacy(struct qemuMonitorQueryCpusEntry * cpuentries,size_t ncpuentries,qemuMonitorCPUInfo * vcpus,size_t maxvcpus)1636 qemuMonitorGetCPUInfoLegacy(struct qemuMonitorQueryCpusEntry *cpuentries,
1637 size_t ncpuentries,
1638 qemuMonitorCPUInfo *vcpus,
1639 size_t maxvcpus)
1640 {
1641 size_t i;
1642
1643 for (i = 0; i < maxvcpus; i++) {
1644 if (i < ncpuentries) {
1645 vcpus[i].tid = cpuentries[i].tid;
1646 vcpus[i].halted = cpuentries[i].halted;
1647 vcpus[i].qemu_id = cpuentries[i].qemu_id;
1648 }
1649
1650 /* for legacy hotplug to work we need to fake the vcpu count added by
1651 * enabling a given vcpu */
1652 vcpus[i].vcpus = 1;
1653 }
1654 }
1655
1656
1657 /**
1658 * qemuMonitorGetCPUInfoHotplug:
1659 *
1660 * This function stitches together data retrieved via query-hotpluggable-cpus
1661 * which returns entities on the hotpluggable level (which may describe more
1662 * than one guest logical vcpu) with the output of query-cpus (or
1663 * query-cpus-fast), having an entry per enabled guest logical vcpu.
1664 *
1665 * query-hotpluggable-cpus conveys following information:
1666 * - topology information and number of logical vcpus this entry creates
1667 * - device type name of the entry that needs to be used when hotplugging
1668 * - qom path in qemu which can be used to map the entry against
1669 * query-cpus[-fast]
1670 *
1671 * query-cpus[-fast] conveys following information:
1672 * - thread id of a given guest logical vcpu
1673 * - order in which the vcpus were inserted
1674 * - qom path to allow mapping the two together
1675 *
1676 * The libvirt's internal structure has an entry for each possible (even
1677 * disabled) guest vcpu. The purpose is to map the data together so that we are
1678 * certain of the thread id mapping and the information required for vcpu
1679 * hotplug.
1680 *
1681 * This function returns 0 on success and -1 on error, but does not report
1682 * libvirt errors so that fallback approach can be used.
1683 */
1684 static int
qemuMonitorGetCPUInfoHotplug(struct qemuMonitorQueryHotpluggableCpusEntry * hotplugvcpus,size_t nhotplugvcpus,struct qemuMonitorQueryCpusEntry * cpuentries,size_t ncpuentries,qemuMonitorCPUInfo * vcpus,size_t maxvcpus)1685 qemuMonitorGetCPUInfoHotplug(struct qemuMonitorQueryHotpluggableCpusEntry *hotplugvcpus,
1686 size_t nhotplugvcpus,
1687 struct qemuMonitorQueryCpusEntry *cpuentries,
1688 size_t ncpuentries,
1689 qemuMonitorCPUInfo *vcpus,
1690 size_t maxvcpus)
1691 {
1692 char *tmp;
1693 int order = 1;
1694 size_t totalvcpus = 0;
1695 size_t mainvcpu; /* this iterator is used for iterating hotpluggable entities */
1696 size_t subvcpu; /* this corresponds to subentries of a hotpluggable entry */
1697 size_t anyvcpu; /* this iterator is used for any vcpu entry in the result */
1698 size_t i;
1699 size_t j;
1700
1701 /* ensure that the total vcpu count reported by query-hotpluggable-cpus equals
1702 * to the libvirt maximum cpu count */
1703 for (i = 0; i < nhotplugvcpus; i++)
1704 totalvcpus += hotplugvcpus[i].vcpus;
1705
1706 /* trim '/thread...' suffix from the data returned by query-cpus[-fast] */
1707 for (i = 0; i < ncpuentries; i++) {
1708 if (cpuentries[i].qom_path &&
1709 (tmp = strstr(cpuentries[i].qom_path, "/thread")))
1710 *tmp = '\0';
1711 }
1712
1713 if (totalvcpus != maxvcpus) {
1714 VIR_DEBUG("expected '%zu' total vcpus got '%zu'", maxvcpus, totalvcpus);
1715 return -1;
1716 }
1717
1718 /* Note the order in which the hotpluggable entities are inserted by
1719 * matching them to the query-cpus[-fast] entries */
1720 for (i = 0; i < ncpuentries; i++) {
1721 for (j = 0; j < nhotplugvcpus; j++) {
1722 if (!cpuentries[i].qom_path ||
1723 !hotplugvcpus[j].qom_path ||
1724 STRNEQ(cpuentries[i].qom_path, hotplugvcpus[j].qom_path))
1725 continue;
1726
1727 /* add ordering info for hotpluggable entries */
1728 if (hotplugvcpus[j].enable_id == 0)
1729 hotplugvcpus[j].enable_id = order++;
1730
1731 break;
1732 }
1733 }
1734
1735 /* transfer appropriate data from the hotpluggable list to corresponding
1736 * entries. the entries returned by qemu may in fact describe multiple
1737 * logical vcpus in the guest */
1738 mainvcpu = 0;
1739 for (i = 0; i < nhotplugvcpus; i++) {
1740 vcpus[mainvcpu].online = !!hotplugvcpus[i].qom_path;
1741 vcpus[mainvcpu].hotpluggable = !!hotplugvcpus[i].alias ||
1742 !vcpus[mainvcpu].online;
1743 vcpus[mainvcpu].socket_id = hotplugvcpus[i].socket_id;
1744 vcpus[mainvcpu].die_id = hotplugvcpus[i].die_id;
1745 vcpus[mainvcpu].core_id = hotplugvcpus[i].core_id;
1746 vcpus[mainvcpu].thread_id = hotplugvcpus[i].thread_id;
1747 vcpus[mainvcpu].node_id = hotplugvcpus[i].node_id;
1748 vcpus[mainvcpu].vcpus = hotplugvcpus[i].vcpus;
1749 vcpus[mainvcpu].qom_path = g_steal_pointer(&hotplugvcpus[i].qom_path);
1750 vcpus[mainvcpu].alias = g_steal_pointer(&hotplugvcpus[i].alias);
1751 vcpus[mainvcpu].type = g_steal_pointer(&hotplugvcpus[i].type);
1752 vcpus[mainvcpu].props = g_steal_pointer(&hotplugvcpus[i].props);
1753 vcpus[mainvcpu].id = hotplugvcpus[i].enable_id;
1754
1755 /* copy state information to sub vcpus */
1756 for (subvcpu = mainvcpu + 1; subvcpu < mainvcpu + hotplugvcpus[i].vcpus; subvcpu++) {
1757 vcpus[subvcpu].online = vcpus[mainvcpu].online;
1758 vcpus[subvcpu].hotpluggable = vcpus[mainvcpu].hotpluggable;
1759 }
1760
1761 /* calculate next master vcpu (hotpluggable unit) entry */
1762 mainvcpu += hotplugvcpus[i].vcpus;
1763 }
1764
1765 /* match entries from query cpus to the output array taking into account
1766 * multi-vcpu objects */
1767 for (j = 0; j < ncpuentries; j++) {
1768 /* find the correct entry or beginning of group of entries */
1769 for (anyvcpu = 0; anyvcpu < maxvcpus; anyvcpu++) {
1770 if (cpuentries[j].qom_path && vcpus[anyvcpu].qom_path &&
1771 STREQ(cpuentries[j].qom_path, vcpus[anyvcpu].qom_path))
1772 break;
1773 }
1774
1775 if (anyvcpu == maxvcpus) {
1776 VIR_DEBUG("too many query-cpus[-fast] entries for a given "
1777 "query-hotpluggable-cpus entry");
1778 return -1;
1779 }
1780
1781 if (vcpus[anyvcpu].vcpus != 1) {
1782 /* find a possibly empty vcpu thread for core granularity systems */
1783 for (; anyvcpu < maxvcpus; anyvcpu++) {
1784 if (vcpus[anyvcpu].tid == 0)
1785 break;
1786 }
1787 }
1788
1789 vcpus[anyvcpu].qemu_id = cpuentries[j].qemu_id;
1790 vcpus[anyvcpu].tid = cpuentries[j].tid;
1791 vcpus[anyvcpu].halted = cpuentries[j].halted;
1792 }
1793
1794 return 0;
1795 }
1796
1797
1798 /**
1799 * qemuMonitorGetCPUInfo:
1800 * @mon: monitor
1801 * @vcpus: pointer filled by array of qemuMonitorCPUInfo structures
1802 * @maxvcpus: total possible number of vcpus
1803 * @hotplug: query data relevant for hotplug support
1804 * @fast: use QMP query-cpus-fast if supported
1805 *
1806 * Detects VCPU information. If qemu doesn't support or fails reporting
1807 * information this function will return success as other parts of libvirt
1808 * are able to cope with that.
1809 *
1810 * Returns 0 on success (including if qemu didn't report any data) and
1811 * -1 on error (reports libvirt error).
1812 */
1813 int
qemuMonitorGetCPUInfo(qemuMonitor * mon,qemuMonitorCPUInfo ** vcpus,size_t maxvcpus,bool hotplug,bool fast)1814 qemuMonitorGetCPUInfo(qemuMonitor *mon,
1815 qemuMonitorCPUInfo **vcpus,
1816 size_t maxvcpus,
1817 bool hotplug,
1818 bool fast)
1819 {
1820 struct qemuMonitorQueryHotpluggableCpusEntry *hotplugcpus = NULL;
1821 size_t nhotplugcpus = 0;
1822 struct qemuMonitorQueryCpusEntry *cpuentries = NULL;
1823 size_t ncpuentries = 0;
1824 int ret = -1;
1825 int rc;
1826 qemuMonitorCPUInfo *info = NULL;
1827
1828 QEMU_CHECK_MONITOR(mon);
1829
1830 info = g_new0(qemuMonitorCPUInfo, maxvcpus);
1831
1832 /* initialize a few non-zero defaults */
1833 qemuMonitorCPUInfoClear(info, maxvcpus);
1834
1835 if (hotplug &&
1836 (qemuMonitorJSONGetHotpluggableCPUs(mon, &hotplugcpus, &nhotplugcpus)) < 0)
1837 goto cleanup;
1838
1839 rc = qemuMonitorJSONQueryCPUs(mon, &cpuentries, &ncpuentries, hotplug,
1840 fast);
1841
1842 if (rc < 0) {
1843 if (!hotplug && rc == -2) {
1844 *vcpus = g_steal_pointer(&info);
1845 ret = 0;
1846 }
1847
1848 goto cleanup;
1849 }
1850
1851 if (!hotplugcpus ||
1852 qemuMonitorGetCPUInfoHotplug(hotplugcpus, nhotplugcpus,
1853 cpuentries, ncpuentries,
1854 info, maxvcpus) < 0) {
1855 /* Fallback to the legacy algorithm. Hotplug paths will make sure that
1856 * the appropriate data is present */
1857 qemuMonitorCPUInfoClear(info, maxvcpus);
1858 qemuMonitorGetCPUInfoLegacy(cpuentries, ncpuentries, info, maxvcpus);
1859 }
1860
1861 *vcpus = g_steal_pointer(&info);
1862 ret = 0;
1863
1864 cleanup:
1865 qemuMonitorQueryHotpluggableCpusFree(hotplugcpus, nhotplugcpus);
1866 qemuMonitorQueryCpusFree(cpuentries, ncpuentries);
1867 qemuMonitorCPUInfoFree(info, maxvcpus);
1868 return ret;
1869 }
1870
1871
1872 /**
1873 * qemuMonitorGetCpuHalted:
1874 *
1875 * Returns a bitmap of vcpu id's that are halted. The id's correspond to the
1876 * 'CPU' field as reported by query-cpus[-fast]'.
1877 */
1878 virBitmap *
qemuMonitorGetCpuHalted(qemuMonitor * mon,size_t maxvcpus,bool fast)1879 qemuMonitorGetCpuHalted(qemuMonitor *mon,
1880 size_t maxvcpus,
1881 bool fast)
1882 {
1883 struct qemuMonitorQueryCpusEntry *cpuentries = NULL;
1884 size_t ncpuentries = 0;
1885 size_t i;
1886 int rc;
1887 virBitmap *ret = NULL;
1888
1889 QEMU_CHECK_MONITOR_NULL(mon);
1890
1891 rc = qemuMonitorJSONQueryCPUs(mon, &cpuentries, &ncpuentries, false,
1892 fast);
1893
1894 if (rc < 0)
1895 goto cleanup;
1896
1897 ret = virBitmapNew(maxvcpus);
1898
1899 for (i = 0; i < ncpuentries; i++) {
1900 if (cpuentries[i].halted)
1901 ignore_value(virBitmapSetBit(ret, cpuentries[i].qemu_id));
1902 }
1903
1904 cleanup:
1905 qemuMonitorQueryCpusFree(cpuentries, ncpuentries);
1906 return ret;
1907 }
1908
1909
1910 int
qemuMonitorSetLink(qemuMonitor * mon,const char * name,virDomainNetInterfaceLinkState state)1911 qemuMonitorSetLink(qemuMonitor *mon,
1912 const char *name,
1913 virDomainNetInterfaceLinkState state)
1914 {
1915 VIR_DEBUG("name=%s, state=%u", name, state);
1916
1917 QEMU_CHECK_MONITOR(mon);
1918
1919 return qemuMonitorJSONSetLink(mon, name, state);
1920 }
1921
1922
1923 /**
1924 * Returns: 0 if balloon not supported, +1 if balloon query worked
1925 * or -1 on failure
1926 */
1927 int
qemuMonitorGetBalloonInfo(qemuMonitor * mon,unsigned long long * currmem)1928 qemuMonitorGetBalloonInfo(qemuMonitor *mon,
1929 unsigned long long *currmem)
1930 {
1931 QEMU_CHECK_MONITOR(mon);
1932
1933 return qemuMonitorJSONGetBalloonInfo(mon, currmem);
1934 }
1935
1936
1937 int
qemuMonitorGetMemoryStats(qemuMonitor * mon,virDomainMemballoonDef * balloon,virDomainMemoryStatPtr stats,unsigned int nr_stats)1938 qemuMonitorGetMemoryStats(qemuMonitor *mon,
1939 virDomainMemballoonDef *balloon,
1940 virDomainMemoryStatPtr stats,
1941 unsigned int nr_stats)
1942 {
1943 VIR_DEBUG("stats=%p nstats=%u", stats, nr_stats);
1944
1945 QEMU_CHECK_MONITOR(mon);
1946
1947 qemuMonitorInitBalloonObjectPath(mon, balloon);
1948 return qemuMonitorJSONGetMemoryStats(mon, mon->balloonpath,
1949 stats, nr_stats);
1950 }
1951
1952
1953 /**
1954 * qemuMonitorSetMemoryStatsPeriod:
1955 *
1956 * This function sets balloon stats update period.
1957 *
1958 * Returns 0 on success and -1 on error, but does *not* set an error.
1959 */
1960 int
qemuMonitorSetMemoryStatsPeriod(qemuMonitor * mon,virDomainMemballoonDef * balloon,int period)1961 qemuMonitorSetMemoryStatsPeriod(qemuMonitor *mon,
1962 virDomainMemballoonDef *balloon,
1963 int period)
1964 {
1965 int ret = -1;
1966 VIR_DEBUG("mon=%p period=%d", mon, period);
1967
1968 if (!mon)
1969 return -1;
1970
1971 if (period < 0)
1972 return -1;
1973
1974 qemuMonitorInitBalloonObjectPath(mon, balloon);
1975 if (mon->balloonpath) {
1976 ret = qemuMonitorJSONSetMemoryStatsPeriod(mon, mon->balloonpath,
1977 period);
1978
1979 /*
1980 * Most of the calls to this function are supposed to be
1981 * non-fatal and the only one that should be fatal wants its
1982 * own error message. More details for debugging will be in
1983 * the log file.
1984 */
1985 if (ret < 0)
1986 virResetLastError();
1987 }
1988 return ret;
1989 }
1990
1991
1992 int
qemuMonitorBlockIOStatusToError(const char * status)1993 qemuMonitorBlockIOStatusToError(const char *status)
1994 {
1995 int st = qemuMonitorBlockIOStatusTypeFromString(status);
1996
1997 if (st < 0) {
1998 virReportError(VIR_ERR_INTERNAL_ERROR,
1999 _("unknown block IO status: %s"), status);
2000 return -1;
2001 }
2002
2003 switch ((qemuMonitorBlockIOStatus) st) {
2004 case QEMU_MONITOR_BLOCK_IO_STATUS_OK:
2005 return VIR_DOMAIN_DISK_ERROR_NONE;
2006 case QEMU_MONITOR_BLOCK_IO_STATUS_FAILED:
2007 return VIR_DOMAIN_DISK_ERROR_UNSPEC;
2008 case QEMU_MONITOR_BLOCK_IO_STATUS_NOSPACE:
2009 return VIR_DOMAIN_DISK_ERROR_NO_SPACE;
2010
2011 /* unreachable */
2012 case QEMU_MONITOR_BLOCK_IO_STATUS_LAST:
2013 break;
2014 }
2015 return -1;
2016 }
2017
2018
2019 static void
qemuDomainDiskInfoFree(void * value)2020 qemuDomainDiskInfoFree(void *value)
2021 {
2022 struct qemuDomainDiskInfo *info = value;
2023
2024 g_free(info->nodename);
2025 g_free(info);
2026 }
2027
2028
2029 GHashTable *
qemuMonitorGetBlockInfo(qemuMonitor * mon)2030 qemuMonitorGetBlockInfo(qemuMonitor *mon)
2031 {
2032 g_autoptr(GHashTable) table = virHashNew(qemuDomainDiskInfoFree);
2033
2034 QEMU_CHECK_MONITOR_NULL(mon);
2035
2036 if (qemuMonitorJSONGetBlockInfo(mon, table) < 0) {
2037 return NULL;
2038 }
2039
2040 return g_steal_pointer(&table);
2041 }
2042
2043
2044 /**
2045 * qemuMonitorQueryBlockstats:
2046 * @mon: monitor object
2047 *
2048 * Returns data from a call to 'query-blockstats' without using 'query-nodes'
2049 */
2050 virJSONValue *
qemuMonitorQueryBlockstats(qemuMonitor * mon)2051 qemuMonitorQueryBlockstats(qemuMonitor *mon)
2052 {
2053 QEMU_CHECK_MONITOR_NULL(mon);
2054
2055 return qemuMonitorJSONQueryBlockstats(mon, false);
2056 }
2057
2058
2059 /**
2060 * qemuMonitorGetAllBlockStatsInfo:
2061 * @mon: monitor object
2062 * @ret_stats: pointer that is filled with a hash table containing the stats
2063 *
2064 * Creates a hash table in @ret_stats with block stats of all devices and the
2065 * backing chains for the block devices.
2066 *
2067 * Returns < 0 on error, count of supported block stats fields on success.
2068 */
2069 int
qemuMonitorGetAllBlockStatsInfo(qemuMonitor * mon,GHashTable ** ret_stats)2070 qemuMonitorGetAllBlockStatsInfo(qemuMonitor *mon,
2071 GHashTable **ret_stats)
2072 {
2073 int ret;
2074 g_autoptr(GHashTable) stats = virHashNew(g_free);
2075
2076 QEMU_CHECK_MONITOR(mon);
2077
2078 ret = qemuMonitorJSONGetAllBlockStatsInfo(mon, stats);
2079
2080 if (ret < 0)
2081 return -1;
2082
2083 *ret_stats = g_steal_pointer(&stats);
2084 return ret;
2085 }
2086
2087
2088 /* Updates "stats" to fill virtual and physical size of the image */
2089 int
qemuMonitorBlockStatsUpdateCapacity(qemuMonitor * mon,GHashTable * stats)2090 qemuMonitorBlockStatsUpdateCapacity(qemuMonitor *mon,
2091 GHashTable *stats)
2092 {
2093 QEMU_CHECK_MONITOR(mon);
2094
2095 return qemuMonitorJSONBlockStatsUpdateCapacity(mon, stats);
2096 }
2097
2098
2099 int
qemuMonitorBlockStatsUpdateCapacityBlockdev(qemuMonitor * mon,GHashTable * stats)2100 qemuMonitorBlockStatsUpdateCapacityBlockdev(qemuMonitor *mon,
2101 GHashTable *stats)
2102 {
2103 VIR_DEBUG("stats=%p", stats);
2104
2105 QEMU_CHECK_MONITOR(mon);
2106
2107 return qemuMonitorJSONBlockStatsUpdateCapacityBlockdev(mon, stats);
2108 }
2109
2110
2111 /**
2112 * qemuMonitorBlockGetNamedNodeData:
2113 * @mon: monitor object
2114 * @supports_flat: don't query data for backing store
2115 *
2116 * Uses 'query-named-block-nodes' to retrieve information about individual
2117 * storage nodes and returns them in a hash table of qemuBlockNamedNodeData *s
2118 * filled with the data. The hash table keys are node names.
2119 */
2120 GHashTable *
qemuMonitorBlockGetNamedNodeData(qemuMonitor * mon,bool supports_flat)2121 qemuMonitorBlockGetNamedNodeData(qemuMonitor *mon,
2122 bool supports_flat)
2123 {
2124 QEMU_CHECK_MONITOR_NULL(mon);
2125 VIR_DEBUG("supports_flat=%d", supports_flat);
2126
2127 return qemuMonitorJSONBlockGetNamedNodeData(mon, supports_flat);
2128 }
2129
2130
2131 int
qemuMonitorBlockResize(qemuMonitor * mon,const char * device,const char * nodename,unsigned long long size)2132 qemuMonitorBlockResize(qemuMonitor *mon,
2133 const char *device,
2134 const char *nodename,
2135 unsigned long long size)
2136 {
2137 VIR_DEBUG("device=%s nodename=%s size=%llu",
2138 NULLSTR(device), NULLSTR(nodename), size);
2139
2140 QEMU_CHECK_MONITOR(mon);
2141
2142 if ((!device && !nodename) || (device && nodename)) {
2143 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
2144 _("exactly one of 'device' and 'nodename' need to be specified"));
2145 return -1;
2146 }
2147
2148 return qemuMonitorJSONBlockResize(mon, device, nodename, size);
2149 }
2150
2151
2152 static const char *
qemuMonitorTypeToProtocol(int type)2153 qemuMonitorTypeToProtocol(int type)
2154 {
2155 switch (type) {
2156 case VIR_DOMAIN_GRAPHICS_TYPE_VNC:
2157 return "vnc";
2158 case VIR_DOMAIN_GRAPHICS_TYPE_SPICE:
2159 return "spice";
2160 default:
2161 virReportError(VIR_ERR_INVALID_ARG,
2162 _("unsupported protocol type %s"),
2163 virDomainGraphicsTypeToString(type));
2164 return NULL;
2165 }
2166 }
2167
2168
2169 int
qemuMonitorSetPassword(qemuMonitor * mon,int type,const char * password,const char * action_if_connected)2170 qemuMonitorSetPassword(qemuMonitor *mon,
2171 int type,
2172 const char *password,
2173 const char *action_if_connected)
2174 {
2175 const char *protocol = qemuMonitorTypeToProtocol(type);
2176
2177 if (!protocol)
2178 return -1;
2179
2180 VIR_DEBUG("protocol=%s, password=%p, action_if_connected=%s",
2181 protocol, password, action_if_connected);
2182
2183 QEMU_CHECK_MONITOR(mon);
2184
2185 if (!password)
2186 password = "";
2187
2188 if (!action_if_connected)
2189 action_if_connected = "keep";
2190
2191 return qemuMonitorJSONSetPassword(mon, protocol, password, action_if_connected);
2192 }
2193
2194
2195 int
qemuMonitorExpirePassword(qemuMonitor * mon,int type,const char * expire_time)2196 qemuMonitorExpirePassword(qemuMonitor *mon,
2197 int type,
2198 const char *expire_time)
2199 {
2200 const char *protocol = qemuMonitorTypeToProtocol(type);
2201
2202 if (!protocol)
2203 return -1;
2204
2205 VIR_DEBUG("protocol=%s, expire_time=%s", protocol, expire_time);
2206
2207 QEMU_CHECK_MONITOR(mon);
2208
2209 if (!expire_time)
2210 expire_time = "now";
2211
2212 return qemuMonitorJSONExpirePassword(mon, protocol, expire_time);
2213 }
2214
2215
2216 /*
2217 * Returns: 0 if balloon not supported, +1 if balloon adjust worked
2218 * or -1 on failure
2219 */
2220 int
qemuMonitorSetBalloon(qemuMonitor * mon,unsigned long long newmem)2221 qemuMonitorSetBalloon(qemuMonitor *mon,
2222 unsigned long long newmem)
2223 {
2224 VIR_DEBUG("newmem=%llu", newmem);
2225
2226 QEMU_CHECK_MONITOR(mon);
2227
2228 return qemuMonitorJSONSetBalloon(mon, newmem);
2229 }
2230
2231
2232 int
qemuMonitorEjectMedia(qemuMonitor * mon,const char * dev_name,bool force)2233 qemuMonitorEjectMedia(qemuMonitor *mon,
2234 const char *dev_name,
2235 bool force)
2236 {
2237 VIR_DEBUG("dev_name=%s force=%d", dev_name, force);
2238
2239 QEMU_CHECK_MONITOR(mon);
2240
2241 return qemuMonitorJSONEjectMedia(mon, dev_name, force);
2242 }
2243
2244
2245 int
qemuMonitorChangeMedia(qemuMonitor * mon,const char * dev_name,const char * newmedia,const char * format)2246 qemuMonitorChangeMedia(qemuMonitor *mon,
2247 const char *dev_name,
2248 const char *newmedia,
2249 const char *format)
2250 {
2251 VIR_DEBUG("dev_name=%s newmedia=%s format=%s", dev_name, newmedia, format);
2252
2253 QEMU_CHECK_MONITOR(mon);
2254
2255 return qemuMonitorJSONChangeMedia(mon, dev_name, newmedia, format);
2256 }
2257
2258
2259 int
qemuMonitorSaveVirtualMemory(qemuMonitor * mon,unsigned long long offset,unsigned long long length,const char * path)2260 qemuMonitorSaveVirtualMemory(qemuMonitor *mon,
2261 unsigned long long offset,
2262 unsigned long long length,
2263 const char *path)
2264 {
2265 VIR_DEBUG("offset=%llu length=%llu path=%s", offset, length, path);
2266
2267 QEMU_CHECK_MONITOR(mon);
2268
2269 return qemuMonitorJSONSaveVirtualMemory(mon, offset, length, path);
2270 }
2271
2272
2273 int
qemuMonitorSavePhysicalMemory(qemuMonitor * mon,unsigned long long offset,unsigned long long length,const char * path)2274 qemuMonitorSavePhysicalMemory(qemuMonitor *mon,
2275 unsigned long long offset,
2276 unsigned long long length,
2277 const char *path)
2278 {
2279 VIR_DEBUG("offset=%llu length=%llu path=%s", offset, length, path);
2280
2281 QEMU_CHECK_MONITOR(mon);
2282
2283 return qemuMonitorJSONSavePhysicalMemory(mon, offset, length, path);
2284 }
2285
2286
2287 int
qemuMonitorSetDBusVMStateIdList(qemuMonitor * mon,GSList * list)2288 qemuMonitorSetDBusVMStateIdList(qemuMonitor *mon,
2289 GSList *list)
2290 {
2291 g_autofree char *path = NULL;
2292 g_auto(virBuffer) buf = VIR_BUFFER_INITIALIZER;
2293 GSList *next;
2294
2295 VIR_DEBUG("list=%p", list);
2296
2297 QEMU_CHECK_MONITOR(mon);
2298
2299 if (!list)
2300 return 0;
2301
2302 for (next = list; next; next = next->next)
2303 virBufferAsprintf(&buf, "%s,", (const char *) next->data);
2304
2305 virBufferTrim(&buf, ",");
2306
2307 path = g_strdup_printf("/objects/%s", qemuDomainGetDBusVMStateAlias());
2308
2309 return qemuMonitorJSONSetDBusVMStateIdList(mon, path,
2310 virBufferCurrentContent(&buf));
2311 }
2312
2313
2314 int
qemuMonitorSetMigrationSpeed(qemuMonitor * mon,unsigned long bandwidth)2315 qemuMonitorSetMigrationSpeed(qemuMonitor *mon,
2316 unsigned long bandwidth)
2317 {
2318 VIR_DEBUG("bandwidth=%lu", bandwidth);
2319
2320 QEMU_CHECK_MONITOR(mon);
2321
2322 if (bandwidth > QEMU_DOMAIN_MIG_BANDWIDTH_MAX) {
2323 virReportError(VIR_ERR_OVERFLOW,
2324 _("bandwidth must be less than %llu"),
2325 QEMU_DOMAIN_MIG_BANDWIDTH_MAX + 1ULL);
2326 return -1;
2327 }
2328
2329 return qemuMonitorJSONSetMigrationSpeed(mon, bandwidth);
2330 }
2331
2332
2333 int
qemuMonitorSetMigrationDowntime(qemuMonitor * mon,unsigned long long downtime)2334 qemuMonitorSetMigrationDowntime(qemuMonitor *mon,
2335 unsigned long long downtime)
2336 {
2337 VIR_DEBUG("downtime=%llu", downtime);
2338
2339 QEMU_CHECK_MONITOR(mon);
2340
2341 return qemuMonitorJSONSetMigrationDowntime(mon, downtime);
2342 }
2343
2344
2345 int
qemuMonitorGetMigrationCacheSize(qemuMonitor * mon,unsigned long long * cacheSize)2346 qemuMonitorGetMigrationCacheSize(qemuMonitor *mon,
2347 unsigned long long *cacheSize)
2348 {
2349 VIR_DEBUG("cacheSize=%p", cacheSize);
2350
2351 QEMU_CHECK_MONITOR(mon);
2352
2353 return qemuMonitorJSONGetMigrationCacheSize(mon, cacheSize);
2354 }
2355
2356
2357 int
qemuMonitorSetMigrationCacheSize(qemuMonitor * mon,unsigned long long cacheSize)2358 qemuMonitorSetMigrationCacheSize(qemuMonitor *mon,
2359 unsigned long long cacheSize)
2360 {
2361 VIR_DEBUG("cacheSize=%llu", cacheSize);
2362
2363 QEMU_CHECK_MONITOR(mon);
2364
2365 return qemuMonitorJSONSetMigrationCacheSize(mon, cacheSize);
2366 }
2367
2368
2369 /**
2370 * qemuMonitorGetMigrationParams:
2371 * @mon: Pointer to the monitor object.
2372 * @params: Where to store migration parameters.
2373 *
2374 * The caller is responsible for freeing @params.
2375 *
2376 * Returns 0 on success, -1 on error.
2377 */
2378 int
qemuMonitorGetMigrationParams(qemuMonitor * mon,virJSONValue ** params)2379 qemuMonitorGetMigrationParams(qemuMonitor *mon,
2380 virJSONValue **params)
2381 {
2382 QEMU_CHECK_MONITOR(mon);
2383
2384 return qemuMonitorJSONGetMigrationParams(mon, params);
2385 }
2386
2387
2388 /**
2389 * qemuMonitorSetMigrationParams:
2390 * @mon: Pointer to the monitor object.
2391 * @params: Migration parameters.
2392 *
2393 * The @params object is consumed and cleared on success and some errors.
2394 *
2395 * Returns 0 on success, -1 on error.
2396 */
2397 int
qemuMonitorSetMigrationParams(qemuMonitor * mon,virJSONValue ** params)2398 qemuMonitorSetMigrationParams(qemuMonitor *mon,
2399 virJSONValue **params)
2400 {
2401 QEMU_CHECK_MONITOR(mon);
2402
2403 return qemuMonitorJSONSetMigrationParams(mon, params);
2404 }
2405
2406
2407 int
qemuMonitorGetMigrationStats(qemuMonitor * mon,qemuMonitorMigrationStats * stats,char ** error)2408 qemuMonitorGetMigrationStats(qemuMonitor *mon,
2409 qemuMonitorMigrationStats *stats,
2410 char **error)
2411 {
2412 QEMU_CHECK_MONITOR(mon);
2413
2414 if (error)
2415 *error = NULL;
2416
2417 return qemuMonitorJSONGetMigrationStats(mon, stats, error);
2418 }
2419
2420
2421 int
qemuMonitorMigrateToFd(qemuMonitor * mon,unsigned int flags,int fd)2422 qemuMonitorMigrateToFd(qemuMonitor *mon,
2423 unsigned int flags,
2424 int fd)
2425 {
2426 int ret;
2427 VIR_DEBUG("fd=%d flags=0x%x", fd, flags);
2428
2429 QEMU_CHECK_MONITOR(mon);
2430
2431 if (qemuMonitorSendFileHandle(mon, "migrate", fd) < 0)
2432 return -1;
2433
2434 ret = qemuMonitorJSONMigrate(mon, flags, "fd:migrate");
2435
2436 if (ret < 0) {
2437 if (qemuMonitorCloseFileHandle(mon, "migrate") < 0)
2438 VIR_WARN("failed to close migration handle");
2439 }
2440
2441 return ret;
2442 }
2443
2444
2445 int
qemuMonitorMigrateToHost(qemuMonitor * mon,unsigned int flags,const char * protocol,const char * hostname,int port)2446 qemuMonitorMigrateToHost(qemuMonitor *mon,
2447 unsigned int flags,
2448 const char *protocol,
2449 const char *hostname,
2450 int port)
2451 {
2452 int ret;
2453 char *uri = NULL;
2454 VIR_DEBUG("hostname=%s port=%d flags=0x%x", hostname, port, flags);
2455
2456 QEMU_CHECK_MONITOR(mon);
2457
2458 if (strchr(hostname, ':')) {
2459 uri = g_strdup_printf("%s:[%s]:%d", protocol, hostname, port);
2460 } else uri = g_strdup_printf("%s:%s:%d", protocol, hostname, port);
2461
2462 ret = qemuMonitorJSONMigrate(mon, flags, uri);
2463
2464 VIR_FREE(uri);
2465 return ret;
2466 }
2467
2468
2469 int
qemuMonitorMigrateToSocket(qemuMonitor * mon,unsigned int flags,const char * socketPath)2470 qemuMonitorMigrateToSocket(qemuMonitor *mon,
2471 unsigned int flags,
2472 const char *socketPath)
2473 {
2474 g_autofree char *uri = g_strdup_printf("unix:%s", socketPath);
2475
2476 VIR_DEBUG("socketPath=%s flags=0x%x", socketPath, flags);
2477
2478 QEMU_CHECK_MONITOR(mon);
2479
2480 return qemuMonitorJSONMigrate(mon, flags, uri);
2481 }
2482
2483
2484 int
qemuMonitorMigrateCancel(qemuMonitor * mon)2485 qemuMonitorMigrateCancel(qemuMonitor *mon)
2486 {
2487 QEMU_CHECK_MONITOR(mon);
2488
2489 return qemuMonitorJSONMigrateCancel(mon);
2490 }
2491
2492
2493 int
qemuMonitorQueryDump(qemuMonitor * mon,qemuMonitorDumpStats * stats)2494 qemuMonitorQueryDump(qemuMonitor *mon,
2495 qemuMonitorDumpStats *stats)
2496 {
2497 QEMU_CHECK_MONITOR(mon);
2498
2499 return qemuMonitorJSONQueryDump(mon, stats);
2500 }
2501
2502
2503 /**
2504 * Returns 1 if @capability is supported, 0 if it's not, or -1 on error.
2505 */
2506 int
qemuMonitorGetDumpGuestMemoryCapability(qemuMonitor * mon,const char * capability)2507 qemuMonitorGetDumpGuestMemoryCapability(qemuMonitor *mon,
2508 const char *capability)
2509 {
2510 VIR_DEBUG("capability=%s", capability);
2511
2512 QEMU_CHECK_MONITOR(mon);
2513
2514 return qemuMonitorJSONGetDumpGuestMemoryCapability(mon, capability);
2515 }
2516
2517
2518 int
qemuMonitorDumpToFd(qemuMonitor * mon,int fd,const char * dumpformat,bool detach)2519 qemuMonitorDumpToFd(qemuMonitor *mon,
2520 int fd,
2521 const char *dumpformat,
2522 bool detach)
2523 {
2524 int ret;
2525 VIR_DEBUG("fd=%d dumpformat=%s", fd, dumpformat);
2526
2527 QEMU_CHECK_MONITOR(mon);
2528
2529 if (qemuMonitorSendFileHandle(mon, "dump", fd) < 0)
2530 return -1;
2531
2532 ret = qemuMonitorJSONDump(mon, "fd:dump", dumpformat, detach);
2533
2534 if (ret < 0) {
2535 if (qemuMonitorCloseFileHandle(mon, "dump") < 0)
2536 VIR_WARN("failed to close dumping handle");
2537 }
2538
2539 return ret;
2540 }
2541
2542
2543 int
qemuMonitorGraphicsRelocate(qemuMonitor * mon,int type,const char * hostname,int port,int tlsPort,const char * tlsSubject)2544 qemuMonitorGraphicsRelocate(qemuMonitor *mon,
2545 int type,
2546 const char *hostname,
2547 int port,
2548 int tlsPort,
2549 const char *tlsSubject)
2550 {
2551 VIR_DEBUG("type=%d hostname=%s port=%d tlsPort=%d tlsSubject=%s",
2552 type, hostname, port, tlsPort, NULLSTR(tlsSubject));
2553
2554 QEMU_CHECK_MONITOR(mon);
2555
2556 return qemuMonitorJSONGraphicsRelocate(mon,
2557 type,
2558 hostname,
2559 port,
2560 tlsPort,
2561 tlsSubject);
2562 }
2563
2564
2565 /**
2566 * qemuMonitorAddFileHandleToSet:
2567 * @mon: monitor object
2568 * @fd: file descriptor to pass to qemu
2569 * @fdset: the fdset to register this fd with, -1 to create a new fdset
2570 * @opaque: opaque data to associated with this fd
2571 * @info: structure that will be updated with the fd and fdset returned by qemu
2572 *
2573 * Attempts to register a file descriptor with qemu that can then be referenced
2574 * via the file path /dev/fdset/$FDSETID
2575 * Returns 0 if ok, and -1 on failure */
2576 int
qemuMonitorAddFileHandleToSet(qemuMonitor * mon,int fd,int fdset,const char * opaque,qemuMonitorAddFdInfo * info)2577 qemuMonitorAddFileHandleToSet(qemuMonitor *mon,
2578 int fd,
2579 int fdset,
2580 const char *opaque,
2581 qemuMonitorAddFdInfo *info)
2582 {
2583 VIR_DEBUG("fd=%d,fdset=%i,opaque=%s", fd, fdset, opaque);
2584
2585 QEMU_CHECK_MONITOR(mon);
2586
2587 if (fd < 0) {
2588 virReportError(VIR_ERR_INVALID_ARG, "%s",
2589 _("fd must be valid"));
2590 return -1;
2591 }
2592
2593 return qemuMonitorJSONAddFileHandleToSet(mon, fd, fdset, opaque, info);
2594 }
2595
2596
2597 /**
2598 * qemuMonitorRemoveFdset:
2599 * @mon: monitor object
2600 * @fdset: the fdset to remove
2601 *
2602 * Attempts to remove a fdset from qemu and close associated file descriptors
2603 * Returns 0 if ok, and -1 on failure */
2604 int
qemuMonitorRemoveFdset(qemuMonitor * mon,int fdset)2605 qemuMonitorRemoveFdset(qemuMonitor *mon,
2606 int fdset)
2607 {
2608 VIR_DEBUG("fdset=%d", fdset);
2609
2610 QEMU_CHECK_MONITOR(mon);
2611
2612 if (fdset < 0) {
2613 virReportError(VIR_ERR_INVALID_ARG, "%s",
2614 _("fdset must be valid"));
2615 return -1;
2616 }
2617
2618 return qemuMonitorJSONRemoveFdset(mon, fdset);
2619 }
2620
2621
qemuMonitorFdsetsFree(qemuMonitorFdsets * fdsets)2622 void qemuMonitorFdsetsFree(qemuMonitorFdsets *fdsets)
2623 {
2624 size_t i;
2625
2626 for (i = 0; i < fdsets->nfdsets; i++) {
2627 size_t j;
2628 qemuMonitorFdsetInfo *set = &fdsets->fdsets[i];
2629
2630 for (j = 0; j < set->nfds; j++)
2631 g_free(set->fds[j].opaque);
2632
2633 g_free(set->fds);
2634 }
2635 g_free(fdsets->fdsets);
2636 g_free(fdsets);
2637 }
2638
2639
2640 /**
2641 * qemuMonitorQueryFdsets:
2642 * @mon: monitor object
2643 * @fdsets: a pointer that is filled with a new qemuMonitorFdsets struct
2644 *
2645 * Queries qemu for the fdsets that are registered with that instance, and
2646 * returns a structure describing those fdsets. The returned struct should be
2647 * freed with qemuMonitorFdsetsFree();
2648 *
2649 * Returns 0 if ok, and -1 on failure */
2650 int
qemuMonitorQueryFdsets(qemuMonitor * mon,qemuMonitorFdsets ** fdsets)2651 qemuMonitorQueryFdsets(qemuMonitor *mon,
2652 qemuMonitorFdsets **fdsets)
2653 {
2654 QEMU_CHECK_MONITOR(mon);
2655
2656 return qemuMonitorJSONQueryFdsets(mon, fdsets);
2657 }
2658
2659
2660 int
qemuMonitorSendFileHandle(qemuMonitor * mon,const char * fdname,int fd)2661 qemuMonitorSendFileHandle(qemuMonitor *mon,
2662 const char *fdname,
2663 int fd)
2664 {
2665 VIR_DEBUG("fdname=%s fd=%d", fdname, fd);
2666
2667 QEMU_CHECK_MONITOR(mon);
2668
2669 if (fd < 0) {
2670 virReportError(VIR_ERR_INVALID_ARG, "%s",
2671 _("fd must be valid"));
2672 return -1;
2673 }
2674
2675 return qemuMonitorJSONSendFileHandle(mon, fdname, fd);
2676 }
2677
2678
2679 int
qemuMonitorCloseFileHandle(qemuMonitor * mon,const char * fdname)2680 qemuMonitorCloseFileHandle(qemuMonitor *mon,
2681 const char *fdname)
2682 {
2683 int ret = -1;
2684 virErrorPtr error;
2685
2686 VIR_DEBUG("fdname=%s", fdname);
2687
2688 virErrorPreserveLast(&error);
2689
2690 QEMU_CHECK_MONITOR_GOTO(mon, cleanup);
2691
2692 ret = qemuMonitorJSONCloseFileHandle(mon, fdname);
2693
2694 cleanup:
2695 virErrorRestore(&error);
2696 return ret;
2697 }
2698
2699
2700 int
qemuMonitorAddNetdev(qemuMonitor * mon,virJSONValue ** props,int * tapfd,char ** tapfdName,int tapfdSize,int * vhostfd,char ** vhostfdName,int vhostfdSize,int slirpfd,char * slirpfdName)2701 qemuMonitorAddNetdev(qemuMonitor *mon,
2702 virJSONValue **props,
2703 int *tapfd, char **tapfdName, int tapfdSize,
2704 int *vhostfd, char **vhostfdName, int vhostfdSize,
2705 int slirpfd, char *slirpfdName)
2706 {
2707 int ret = -1;
2708 size_t i = 0, j = 0;
2709
2710 VIR_DEBUG("props=%p tapfd=%p tapfdName=%p tapfdSize=%d"
2711 "vhostfd=%p vhostfdName=%p vhostfdSize=%d"
2712 "slirpfd=%d slirpfdName=%s",
2713 props, tapfd, tapfdName, tapfdSize,
2714 vhostfd, vhostfdName, vhostfdSize, slirpfd, slirpfdName);
2715
2716 QEMU_CHECK_MONITOR(mon);
2717
2718 for (i = 0; i < tapfdSize; i++) {
2719 if (qemuMonitorSendFileHandle(mon, tapfdName[i], tapfd[i]) < 0)
2720 goto cleanup;
2721 }
2722 for (j = 0; j < vhostfdSize; j++) {
2723 if (qemuMonitorSendFileHandle(mon, vhostfdName[j], vhostfd[j]) < 0)
2724 goto cleanup;
2725 }
2726
2727 if (slirpfd > 0 &&
2728 qemuMonitorSendFileHandle(mon, slirpfdName, slirpfd) < 0)
2729 goto cleanup;
2730
2731 ret = qemuMonitorJSONAddNetdev(mon, props);
2732
2733 cleanup:
2734 if (ret < 0) {
2735 while (i--) {
2736 if (qemuMonitorCloseFileHandle(mon, tapfdName[i]) < 0)
2737 VIR_WARN("failed to close device handle '%s'", tapfdName[i]);
2738 }
2739 while (j--) {
2740 if (qemuMonitorCloseFileHandle(mon, vhostfdName[j]) < 0)
2741 VIR_WARN("failed to close device handle '%s'", vhostfdName[j]);
2742 }
2743 if (qemuMonitorCloseFileHandle(mon, slirpfdName) < 0)
2744 VIR_WARN("failed to close device handle '%s'", slirpfdName);
2745 }
2746
2747 return ret;
2748 }
2749
2750
2751 int
qemuMonitorRemoveNetdev(qemuMonitor * mon,const char * alias)2752 qemuMonitorRemoveNetdev(qemuMonitor *mon,
2753 const char *alias)
2754 {
2755 VIR_DEBUG("alias=%s", alias);
2756
2757 QEMU_CHECK_MONITOR(mon);
2758
2759 return qemuMonitorJSONRemoveNetdev(mon, alias);
2760 }
2761
2762
2763 int
qemuMonitorQueryRxFilter(qemuMonitor * mon,const char * alias,virNetDevRxFilter ** filter)2764 qemuMonitorQueryRxFilter(qemuMonitor *mon, const char *alias,
2765 virNetDevRxFilter **filter)
2766 {
2767 VIR_DEBUG("alias=%s filter=%p", alias, filter);
2768
2769 QEMU_CHECK_MONITOR(mon);
2770
2771 return qemuMonitorJSONQueryRxFilter(mon, alias, filter);
2772 }
2773
2774
2775 void
qemuMonitorChardevInfoFree(void * data)2776 qemuMonitorChardevInfoFree(void *data)
2777 {
2778 qemuMonitorChardevInfo *info = data;
2779
2780 g_free(info->ptyPath);
2781 g_free(info);
2782 }
2783
2784
2785 int
qemuMonitorGetChardevInfo(qemuMonitor * mon,GHashTable ** retinfo)2786 qemuMonitorGetChardevInfo(qemuMonitor *mon,
2787 GHashTable **retinfo)
2788 {
2789 g_autoptr(GHashTable) info = virHashNew(qemuMonitorChardevInfoFree);
2790
2791 VIR_DEBUG("retinfo=%p", retinfo);
2792
2793 QEMU_CHECK_MONITOR(mon);
2794
2795 if (qemuMonitorJSONGetChardevInfo(mon, info) < 0)
2796 return -1;
2797
2798 *retinfo = g_steal_pointer(&info);
2799 return 0;
2800 }
2801
2802
2803 /**
2804 * qemuMonitorDriveDel:
2805 * @mon: monitor object
2806 * @drivestr: identifier of drive to delete.
2807 *
2808 * Attempts to remove a host drive.
2809 * Returns 1 if unsupported, 0 if ok, and -1 on other failure */
2810 int
qemuMonitorDriveDel(qemuMonitor * mon,const char * drivestr)2811 qemuMonitorDriveDel(qemuMonitor *mon,
2812 const char *drivestr)
2813 {
2814 VIR_DEBUG("drivestr=%s", drivestr);
2815
2816 QEMU_CHECK_MONITOR(mon);
2817
2818 /* there won't be a direct replacement for drive_del in QMP */
2819 return qemuMonitorTextDriveDel(mon, drivestr);
2820 }
2821
2822
2823 /**
2824 * @mon: monitor object
2825 * @devalias: alias of the device to detach
2826 *
2827 * Sends device detach request to qemu.
2828 *
2829 * Returns: 0 on success,
2830 * -2 if DeviceNotFound error encountered (error NOT reported)
2831 * -1 otherwise (error reported)
2832 */
2833 int
qemuMonitorDelDevice(qemuMonitor * mon,const char * devalias)2834 qemuMonitorDelDevice(qemuMonitor *mon,
2835 const char *devalias)
2836 {
2837 VIR_DEBUG("devalias=%s", devalias);
2838
2839 QEMU_CHECK_MONITOR(mon);
2840
2841 return qemuMonitorJSONDelDevice(mon, devalias);
2842 }
2843
2844
2845 /**
2846 * qemuMonitorAddDeviceProps:
2847 * @mon: monitor object
2848 * @props: JSON object describing the device to add, the object is consumed
2849 * and cleared.
2850 *
2851 * Adds a device described by @props.
2852 * Returns 0 on success -1 on error.
2853 */
2854 int
qemuMonitorAddDeviceProps(qemuMonitor * mon,virJSONValue ** props)2855 qemuMonitorAddDeviceProps(qemuMonitor *mon,
2856 virJSONValue **props)
2857 {
2858 QEMU_CHECK_MONITOR(mon);
2859
2860 return qemuMonitorJSONAddDeviceProps(mon, props);
2861 }
2862
2863
2864 /**
2865 * qemuMonitorCreateObjectProps:
2866 * @propsret: returns full object properties
2867 * @type: Type name of object to add
2868 * @objalias: Alias of the new object
2869 * @...: Optional arguments for the given object. See virJSONValueObjectAddVArgs.
2870 *
2871 * Returns a JSONValue containing everything on success and NULL on error.
2872 */
2873 int
qemuMonitorCreateObjectProps(virJSONValue ** propsret,const char * type,const char * alias,...)2874 qemuMonitorCreateObjectProps(virJSONValue **propsret,
2875 const char *type,
2876 const char *alias,
2877 ...)
2878 {
2879 g_autoptr(virJSONValue) props = NULL;
2880 int rc;
2881 va_list args;
2882
2883 if (virJSONValueObjectAdd(&props,
2884 "s:qom-type", type,
2885 "s:id", alias,
2886 NULL) < 0)
2887 return -1;
2888
2889
2890 va_start(args, alias);
2891
2892 rc = virJSONValueObjectAddVArgs(&props, args);
2893
2894 va_end(args);
2895
2896 if (rc < 0)
2897 return -1;
2898
2899 *propsret = g_steal_pointer(&props);
2900 return 0;
2901 }
2902
2903
2904 /**
2905 * qemuMonitorAddObject:
2906 * @mon: Pointer to monitor object
2907 * @props: Pointer to a JSON object holding configuration of the object to add.
2908 * The object must be non-null and contain at least the "qom-type" and
2909 * "id" field. The object is consumed and the pointer is cleared.
2910 * @alias: If not NULL, returns the alias of the added object if it was added
2911 * successfully to qemu. Caller should free the returned pointer.
2912 *
2913 * Returns 0 on success -1 on error.
2914 */
2915 int
qemuMonitorAddObject(qemuMonitor * mon,virJSONValue ** props,char ** alias)2916 qemuMonitorAddObject(qemuMonitor *mon,
2917 virJSONValue **props,
2918 char **alias)
2919 {
2920 g_autoptr(virJSONValue) pr = NULL;
2921 const char *type = NULL;
2922 const char *id = NULL;
2923 g_autofree char *aliasCopy = NULL;
2924
2925 if (!*props) {
2926 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
2927 _("object props can't be NULL"));
2928 return -1;
2929 }
2930
2931 type = virJSONValueObjectGetString(*props, "qom-type");
2932 id = virJSONValueObjectGetString(*props, "id");
2933
2934 VIR_DEBUG("type=%s id=%s", NULLSTR(type), NULLSTR(id));
2935
2936 QEMU_CHECK_MONITOR(mon);
2937
2938 if (!id || !type) {
2939 virReportError(VIR_ERR_INTERNAL_ERROR,
2940 _("missing alias or qom-type for qemu object '%s'"),
2941 NULLSTR(type));
2942 return -1;
2943 }
2944
2945 if (alias)
2946 aliasCopy = g_strdup(id);
2947
2948 if (mon->objectAddNoWrap) {
2949 pr = g_steal_pointer(props);
2950 } else {
2951 /* we need to create a wrapper which has the 'qom-type' and 'id' and
2952 * store everything else under a 'props' sub-object */
2953 g_autoptr(virJSONValue) typeobj = NULL;
2954 g_autoptr(virJSONValue) idobj = NULL;
2955
2956 ignore_value(virJSONValueObjectRemoveKey(*props, "qom-type", &typeobj));
2957 ignore_value(virJSONValueObjectRemoveKey(*props, "id", &idobj));
2958
2959 if (!virJSONValueObjectGetKey(*props, 0)) {
2960 virJSONValueFree(*props);
2961 *props = NULL;
2962 }
2963
2964 if (virJSONValueObjectAdd(&pr,
2965 "s:qom-type", type,
2966 "s:id", id,
2967 "A:props", props,
2968 NULL) < 0)
2969 return -1;
2970 }
2971
2972 if (qemuMonitorJSONAddObject(mon, &pr) < 0)
2973 return -1;
2974
2975 if (alias)
2976 *alias = g_steal_pointer(&aliasCopy);
2977
2978 return 0;
2979 }
2980
2981
2982 int
qemuMonitorDelObject(qemuMonitor * mon,const char * objalias,bool report_error)2983 qemuMonitorDelObject(qemuMonitor *mon,
2984 const char *objalias,
2985 bool report_error)
2986 {
2987 VIR_DEBUG("objalias=%s", objalias);
2988
2989 QEMU_CHECK_MONITOR(mon);
2990
2991 return qemuMonitorJSONDelObject(mon, objalias, report_error);
2992 }
2993
2994
2995 int
qemuMonitorAddDrive(qemuMonitor * mon,const char * drivestr)2996 qemuMonitorAddDrive(qemuMonitor *mon,
2997 const char *drivestr)
2998 {
2999 VIR_DEBUG("drive=%s", drivestr);
3000
3001 QEMU_CHECK_MONITOR(mon);
3002
3003 /* there won't ever be a direct QMP replacement for this function */
3004 return qemuMonitorTextAddDrive(mon, drivestr);
3005 }
3006
3007
3008 int
qemuMonitorCreateSnapshot(qemuMonitor * mon,const char * name)3009 qemuMonitorCreateSnapshot(qemuMonitor *mon, const char *name)
3010 {
3011 VIR_DEBUG("name=%s", name);
3012
3013 QEMU_CHECK_MONITOR(mon);
3014
3015 /* there won't ever be a direct QMP replacement for this function */
3016 return qemuMonitorTextCreateSnapshot(mon, name);
3017 }
3018
3019
3020 int
qemuMonitorDeleteSnapshot(qemuMonitor * mon,const char * name)3021 qemuMonitorDeleteSnapshot(qemuMonitor *mon, const char *name)
3022 {
3023 VIR_DEBUG("name=%s", name);
3024
3025 QEMU_CHECK_MONITOR(mon);
3026
3027 /* there won't ever be a direct QMP replacement for this function */
3028 return qemuMonitorTextDeleteSnapshot(mon, name);
3029 }
3030
3031
3032 /* Start a drive-mirror block job. bandwidth is in bytes/sec. */
3033 int
qemuMonitorDriveMirror(qemuMonitor * mon,const char * device,const char * file,const char * format,unsigned long long bandwidth,unsigned int granularity,unsigned long long buf_size,bool shallow,bool reuse)3034 qemuMonitorDriveMirror(qemuMonitor *mon,
3035 const char *device, const char *file,
3036 const char *format, unsigned long long bandwidth,
3037 unsigned int granularity, unsigned long long buf_size,
3038 bool shallow,
3039 bool reuse)
3040 {
3041 VIR_DEBUG("device=%s, file=%s, format=%s, bandwidth=%lld, "
3042 "granularity=%#x, buf_size=%lld, shallow=%d, reuse=%d",
3043 device, file, NULLSTR(format), bandwidth, granularity,
3044 buf_size, shallow, reuse);
3045
3046 QEMU_CHECK_MONITOR(mon);
3047
3048 return qemuMonitorJSONDriveMirror(mon, device, file, format, bandwidth,
3049 granularity, buf_size, shallow, reuse);
3050 }
3051
3052
3053 int
qemuMonitorBlockdevMirror(qemuMonitor * mon,const char * jobname,bool persistjob,const char * device,const char * target,unsigned long long bandwidth,unsigned int granularity,unsigned long long buf_size,bool shallow)3054 qemuMonitorBlockdevMirror(qemuMonitor *mon,
3055 const char *jobname,
3056 bool persistjob,
3057 const char *device,
3058 const char *target,
3059 unsigned long long bandwidth,
3060 unsigned int granularity,
3061 unsigned long long buf_size,
3062 bool shallow)
3063 {
3064 VIR_DEBUG("jobname=%s, persistjob=%d, device=%s, target=%s, bandwidth=%lld, "
3065 "granularity=%#x, buf_size=%lld, shallow=%d",
3066 NULLSTR(jobname), persistjob, device, target, bandwidth, granularity,
3067 buf_size, shallow);
3068
3069 QEMU_CHECK_MONITOR(mon);
3070
3071 return qemuMonitorJSONBlockdevMirror(mon, jobname, persistjob, device, target,
3072 bandwidth, granularity, buf_size, shallow);
3073 }
3074
3075
3076 /* Use the transaction QMP command to run atomic snapshot commands. */
3077 int
qemuMonitorTransaction(qemuMonitor * mon,virJSONValue ** actions)3078 qemuMonitorTransaction(qemuMonitor *mon, virJSONValue **actions)
3079 {
3080 VIR_DEBUG("actions=%p", *actions);
3081
3082 QEMU_CHECK_MONITOR(mon);
3083
3084 return qemuMonitorJSONTransaction(mon, actions);
3085 }
3086
3087
3088 /* Start a block-commit block job. bandwidth is in bytes/sec. */
3089 int
qemuMonitorBlockCommit(qemuMonitor * mon,const char * device,const char * jobname,bool persistjob,const char * top,const char * topNode,const char * base,const char * baseNode,const char * backingName,unsigned long long bandwidth)3090 qemuMonitorBlockCommit(qemuMonitor *mon,
3091 const char *device,
3092 const char *jobname,
3093 bool persistjob,
3094 const char *top,
3095 const char *topNode,
3096 const char *base,
3097 const char *baseNode,
3098 const char *backingName,
3099 unsigned long long bandwidth)
3100 {
3101 VIR_DEBUG("device=%s, jobname=%s, persistjob=%d, top=%s, topNode=%s, "
3102 "base=%s, baseNode=%s, backingName=%s, bandwidth=%llu",
3103 device, NULLSTR(jobname), persistjob, NULLSTR(top), NULLSTR(topNode),
3104 NULLSTR(base), NULLSTR(baseNode), NULLSTR(backingName), bandwidth);
3105
3106 QEMU_CHECK_MONITOR(mon);
3107
3108 return qemuMonitorJSONBlockCommit(mon, device, jobname, persistjob, top,
3109 topNode, base, baseNode, backingName,
3110 bandwidth);
3111 }
3112
3113
3114 /* Determine the name that qemu is using for tracking the backing
3115 * element TARGET within the chain starting at TOP. */
3116 char *
qemuMonitorDiskNameLookup(qemuMonitor * mon,const char * device,virStorageSource * top,virStorageSource * target)3117 qemuMonitorDiskNameLookup(qemuMonitor *mon,
3118 const char *device,
3119 virStorageSource *top,
3120 virStorageSource *target)
3121 {
3122 QEMU_CHECK_MONITOR_NULL(mon);
3123
3124 return qemuMonitorJSONDiskNameLookup(mon, device, top, target);
3125 }
3126
3127
3128 /* Use the block-job-complete monitor command to pivot a block copy job. */
3129 int
qemuMonitorDrivePivot(qemuMonitor * mon,const char * jobname)3130 qemuMonitorDrivePivot(qemuMonitor *mon,
3131 const char *jobname)
3132 {
3133 VIR_DEBUG("jobname=%s", jobname);
3134
3135 QEMU_CHECK_MONITOR(mon);
3136
3137 return qemuMonitorJSONDrivePivot(mon, jobname);
3138 }
3139
3140
3141 int
qemuMonitorArbitraryCommand(qemuMonitor * mon,const char * cmd,char ** reply,bool hmp)3142 qemuMonitorArbitraryCommand(qemuMonitor *mon,
3143 const char *cmd,
3144 char **reply,
3145 bool hmp)
3146 {
3147 VIR_DEBUG("cmd=%s, reply=%p, hmp=%d", cmd, reply, hmp);
3148
3149 QEMU_CHECK_MONITOR(mon);
3150
3151 if (hmp)
3152 return qemuMonitorJSONHumanCommand(mon, cmd, reply);
3153 else
3154 return qemuMonitorJSONArbitraryCommand(mon, cmd, reply);
3155 }
3156
3157
3158 int
qemuMonitorInjectNMI(qemuMonitor * mon)3159 qemuMonitorInjectNMI(qemuMonitor *mon)
3160 {
3161 QEMU_CHECK_MONITOR(mon);
3162
3163 return qemuMonitorJSONInjectNMI(mon);
3164 }
3165
3166
3167 int
qemuMonitorSendKey(qemuMonitor * mon,unsigned int holdtime,unsigned int * keycodes,unsigned int nkeycodes)3168 qemuMonitorSendKey(qemuMonitor *mon,
3169 unsigned int holdtime,
3170 unsigned int *keycodes,
3171 unsigned int nkeycodes)
3172 {
3173 VIR_DEBUG("holdtime=%u, nkeycodes=%u", holdtime, nkeycodes);
3174
3175 QEMU_CHECK_MONITOR(mon);
3176
3177 return qemuMonitorJSONSendKey(mon, holdtime, keycodes, nkeycodes);
3178 }
3179
3180
3181 int
qemuMonitorScreendump(qemuMonitor * mon,const char * device,unsigned int head,const char * file)3182 qemuMonitorScreendump(qemuMonitor *mon,
3183 const char *device,
3184 unsigned int head,
3185 const char *file)
3186 {
3187 VIR_DEBUG("file=%s", file);
3188
3189 QEMU_CHECK_MONITOR(mon);
3190
3191 return qemuMonitorJSONScreendump(mon, device, head, file);
3192 }
3193
3194
3195 /* bandwidth is in bytes/sec */
3196 int
qemuMonitorBlockStream(qemuMonitor * mon,const char * device,const char * jobname,bool persistjob,const char * base,const char * baseNode,const char * backingName,unsigned long long bandwidth)3197 qemuMonitorBlockStream(qemuMonitor *mon,
3198 const char *device,
3199 const char *jobname,
3200 bool persistjob,
3201 const char *base,
3202 const char *baseNode,
3203 const char *backingName,
3204 unsigned long long bandwidth)
3205 {
3206 VIR_DEBUG("device=%s, jobname=%s, persistjob=%d, base=%s, baseNode=%s, "
3207 "backingName=%s, bandwidth=%lluB",
3208 device, NULLSTR(jobname), persistjob, NULLSTR(base),
3209 NULLSTR(baseNode), NULLSTR(backingName), bandwidth);
3210
3211 QEMU_CHECK_MONITOR(mon);
3212
3213 if (base && baseNode) {
3214 virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
3215 _("'base' and 'baseNode' can't be used together"));
3216 return -1;
3217 }
3218
3219 return qemuMonitorJSONBlockStream(mon, device, jobname, persistjob, base,
3220 baseNode, backingName, bandwidth);
3221 }
3222
3223
3224 int
qemuMonitorBlockJobCancel(qemuMonitor * mon,const char * jobname,bool force)3225 qemuMonitorBlockJobCancel(qemuMonitor *mon,
3226 const char *jobname,
3227 bool force)
3228 {
3229 VIR_DEBUG("jobname=%s force=%d", jobname, force);
3230
3231 QEMU_CHECK_MONITOR(mon);
3232
3233 return qemuMonitorJSONBlockJobCancel(mon, jobname, force);
3234 }
3235
3236
3237 int
qemuMonitorBlockJobSetSpeed(qemuMonitor * mon,const char * jobname,unsigned long long bandwidth)3238 qemuMonitorBlockJobSetSpeed(qemuMonitor *mon,
3239 const char *jobname,
3240 unsigned long long bandwidth)
3241 {
3242 VIR_DEBUG("jobname=%s, bandwidth=%lluB", jobname, bandwidth);
3243
3244 QEMU_CHECK_MONITOR(mon);
3245
3246 return qemuMonitorJSONBlockJobSetSpeed(mon, jobname, bandwidth);
3247 }
3248
3249
3250 GHashTable *
qemuMonitorGetAllBlockJobInfo(qemuMonitor * mon,bool rawjobname)3251 qemuMonitorGetAllBlockJobInfo(qemuMonitor *mon,
3252 bool rawjobname)
3253 {
3254 QEMU_CHECK_MONITOR_NULL(mon);
3255 return qemuMonitorJSONGetAllBlockJobInfo(mon, rawjobname);
3256 }
3257
3258
3259 int
qemuMonitorJobDismiss(qemuMonitor * mon,const char * jobname)3260 qemuMonitorJobDismiss(qemuMonitor *mon,
3261 const char *jobname)
3262 {
3263 VIR_DEBUG("jobname=%s", jobname);
3264
3265 QEMU_CHECK_MONITOR(mon);
3266
3267 return qemuMonitorJSONJobDismiss(mon, jobname);
3268 }
3269
3270
3271 int
qemuMonitorJobComplete(qemuMonitor * mon,const char * jobname)3272 qemuMonitorJobComplete(qemuMonitor *mon,
3273 const char *jobname)
3274 {
3275 VIR_DEBUG("jobname=%s", jobname);
3276
3277 QEMU_CHECK_MONITOR(mon);
3278
3279 return qemuMonitorJSONJobComplete(mon, jobname);
3280 }
3281
3282
3283 int
qemuMonitorSetBlockIoThrottle(qemuMonitor * mon,const char * drivealias,const char * qomid,virDomainBlockIoTuneInfo * info)3284 qemuMonitorSetBlockIoThrottle(qemuMonitor *mon,
3285 const char *drivealias,
3286 const char *qomid,
3287 virDomainBlockIoTuneInfo *info)
3288 {
3289 VIR_DEBUG("drivealias=%s, qomid=%s, info=%p",
3290 NULLSTR(drivealias), NULLSTR(qomid), info);
3291
3292 QEMU_CHECK_MONITOR(mon);
3293
3294 return qemuMonitorJSONSetBlockIoThrottle(mon, drivealias, qomid, info);
3295 }
3296
3297
3298 int
qemuMonitorGetBlockIoThrottle(qemuMonitor * mon,const char * drivealias,const char * qdevid,virDomainBlockIoTuneInfo * reply)3299 qemuMonitorGetBlockIoThrottle(qemuMonitor *mon,
3300 const char *drivealias,
3301 const char *qdevid,
3302 virDomainBlockIoTuneInfo *reply)
3303 {
3304 VIR_DEBUG("drivealias=%s, qdevid=%s, reply=%p",
3305 NULLSTR(drivealias), NULLSTR(qdevid), reply);
3306
3307 QEMU_CHECK_MONITOR(mon);
3308
3309 return qemuMonitorJSONGetBlockIoThrottle(mon, drivealias, qdevid, reply);
3310 }
3311
3312
3313 int
qemuMonitorVMStatusToPausedReason(const char * status)3314 qemuMonitorVMStatusToPausedReason(const char *status)
3315 {
3316 int st;
3317
3318 if (!status)
3319 return VIR_DOMAIN_PAUSED_UNKNOWN;
3320
3321 if ((st = qemuMonitorVMStatusTypeFromString(status)) < 0) {
3322 VIR_WARN("QEMU reported unknown VM status: '%s'", status);
3323 return VIR_DOMAIN_PAUSED_UNKNOWN;
3324 }
3325
3326 switch ((qemuMonitorVMStatus) st) {
3327 case QEMU_MONITOR_VM_STATUS_DEBUG:
3328 case QEMU_MONITOR_VM_STATUS_INTERNAL_ERROR:
3329 case QEMU_MONITOR_VM_STATUS_RESTORE_VM:
3330 return VIR_DOMAIN_PAUSED_UNKNOWN;
3331
3332 case QEMU_MONITOR_VM_STATUS_INMIGRATE:
3333 case QEMU_MONITOR_VM_STATUS_POSTMIGRATE:
3334 case QEMU_MONITOR_VM_STATUS_FINISH_MIGRATE:
3335 return VIR_DOMAIN_PAUSED_MIGRATION;
3336
3337 case QEMU_MONITOR_VM_STATUS_IO_ERROR:
3338 return VIR_DOMAIN_PAUSED_IOERROR;
3339
3340 case QEMU_MONITOR_VM_STATUS_PAUSED:
3341 case QEMU_MONITOR_VM_STATUS_PRELAUNCH:
3342 return VIR_DOMAIN_PAUSED_USER;
3343
3344 case QEMU_MONITOR_VM_STATUS_RUNNING:
3345 VIR_WARN("QEMU reports the guest is paused but status is 'running'");
3346 return VIR_DOMAIN_PAUSED_UNKNOWN;
3347
3348 case QEMU_MONITOR_VM_STATUS_SAVE_VM:
3349 return VIR_DOMAIN_PAUSED_SAVE;
3350
3351 case QEMU_MONITOR_VM_STATUS_SHUTDOWN:
3352 return VIR_DOMAIN_PAUSED_SHUTTING_DOWN;
3353
3354 case QEMU_MONITOR_VM_STATUS_WATCHDOG:
3355 return VIR_DOMAIN_PAUSED_WATCHDOG;
3356
3357 case QEMU_MONITOR_VM_STATUS_GUEST_PANICKED:
3358 return VIR_DOMAIN_PAUSED_CRASHED;
3359
3360 /* unreachable from this point on */
3361 case QEMU_MONITOR_VM_STATUS_LAST:
3362 ;
3363 }
3364 return VIR_DOMAIN_PAUSED_UNKNOWN;
3365 }
3366
3367
3368 int
qemuMonitorOpenGraphics(qemuMonitor * mon,const char * protocol,int fd,const char * fdname,bool skipauth)3369 qemuMonitorOpenGraphics(qemuMonitor *mon,
3370 const char *protocol,
3371 int fd,
3372 const char *fdname,
3373 bool skipauth)
3374 {
3375 int ret;
3376
3377 VIR_DEBUG("protocol=%s fd=%d fdname=%s skipauth=%d",
3378 protocol, fd, NULLSTR(fdname), skipauth);
3379
3380 QEMU_CHECK_MONITOR(mon);
3381
3382 if (qemuMonitorSendFileHandle(mon, fdname, fd) < 0)
3383 return -1;
3384
3385 ret = qemuMonitorJSONOpenGraphics(mon, protocol, fdname, skipauth);
3386
3387 if (ret < 0) {
3388 if (qemuMonitorCloseFileHandle(mon, fdname) < 0)
3389 VIR_WARN("failed to close device handle '%s'", fdname);
3390 }
3391
3392 return ret;
3393 }
3394
3395
3396 int
qemuMonitorSystemWakeup(qemuMonitor * mon)3397 qemuMonitorSystemWakeup(qemuMonitor *mon)
3398 {
3399 QEMU_CHECK_MONITOR(mon);
3400
3401 return qemuMonitorJSONSystemWakeup(mon);
3402 }
3403
3404
3405 int
qemuMonitorGetVersion(qemuMonitor * mon,int * major,int * minor,int * micro,char ** package)3406 qemuMonitorGetVersion(qemuMonitor *mon,
3407 int *major,
3408 int *minor,
3409 int *micro,
3410 char **package)
3411 {
3412 VIR_DEBUG("major=%p minor=%p micro=%p package=%p",
3413 major, minor, micro, package);
3414
3415 QEMU_CHECK_MONITOR(mon);
3416
3417 return qemuMonitorJSONGetVersion(mon, major, minor, micro, package);
3418 }
3419
3420
3421 int
qemuMonitorGetMachines(qemuMonitor * mon,qemuMonitorMachineInfo *** machines)3422 qemuMonitorGetMachines(qemuMonitor *mon,
3423 qemuMonitorMachineInfo ***machines)
3424 {
3425 VIR_DEBUG("machines=%p", machines);
3426
3427 QEMU_CHECK_MONITOR(mon);
3428
3429 return qemuMonitorJSONGetMachines(mon, machines);
3430 }
3431
3432
3433 void
qemuMonitorMachineInfoFree(qemuMonitorMachineInfo * machine)3434 qemuMonitorMachineInfoFree(qemuMonitorMachineInfo *machine)
3435 {
3436 if (!machine)
3437 return;
3438 g_free(machine->name);
3439 g_free(machine->alias);
3440 g_free(machine->defaultCPU);
3441 g_free(machine->defaultRAMid);
3442 g_free(machine);
3443 }
3444
3445
3446 int
qemuMonitorGetCPUDefinitions(qemuMonitor * mon,qemuMonitorCPUDefs ** cpuDefs)3447 qemuMonitorGetCPUDefinitions(qemuMonitor *mon,
3448 qemuMonitorCPUDefs **cpuDefs)
3449 {
3450 VIR_DEBUG("cpuDefs=%p", cpuDefs);
3451
3452 QEMU_CHECK_MONITOR(mon);
3453
3454 return qemuMonitorJSONGetCPUDefinitions(mon, cpuDefs);
3455 }
3456
3457
3458 void
qemuMonitorCPUDefsFree(qemuMonitorCPUDefs * defs)3459 qemuMonitorCPUDefsFree(qemuMonitorCPUDefs *defs)
3460 {
3461 size_t i;
3462
3463 if (!defs)
3464 return;
3465
3466 for (i = 0; i < defs->ncpus; i++) {
3467 g_strfreev(defs->cpus[i].blockers);
3468 g_free(defs->cpus[i].name);
3469 g_free(defs->cpus[i].type);
3470 }
3471
3472 g_free(defs->cpus);
3473 g_free(defs);
3474 }
3475
3476
3477 qemuMonitorCPUDefs *
qemuMonitorCPUDefsNew(size_t count)3478 qemuMonitorCPUDefsNew(size_t count)
3479 {
3480 g_autoptr(qemuMonitorCPUDefs) defs = NULL;
3481
3482 defs = g_new0(qemuMonitorCPUDefs, 1);
3483 defs->cpus = g_new0(qemuMonitorCPUDefInfo, count);
3484 defs->ncpus = count;
3485
3486 return g_steal_pointer(&defs);
3487 }
3488
3489
3490 qemuMonitorCPUDefs *
qemuMonitorCPUDefsCopy(qemuMonitorCPUDefs * src)3491 qemuMonitorCPUDefsCopy(qemuMonitorCPUDefs *src)
3492 {
3493 g_autoptr(qemuMonitorCPUDefs) defs = NULL;
3494 size_t i;
3495
3496 if (!src)
3497 return NULL;
3498
3499 defs = qemuMonitorCPUDefsNew(src->ncpus);
3500 for (i = 0; i < src->ncpus; i++) {
3501 qemuMonitorCPUDefInfo *cpuDst = defs->cpus + i;
3502 qemuMonitorCPUDefInfo *cpuSrc = src->cpus + i;
3503
3504 cpuDst->usable = cpuSrc->usable;
3505 cpuDst->name = g_strdup(cpuSrc->name);
3506 cpuDst->type = g_strdup(cpuSrc->type);
3507 cpuDst->blockers = g_strdupv(cpuSrc->blockers);
3508 cpuDst->deprecated = cpuSrc->deprecated;
3509 }
3510
3511 return g_steal_pointer(&defs);
3512 }
3513
3514
3515 int
qemuMonitorGetCPUModelExpansion(qemuMonitor * mon,qemuMonitorCPUModelExpansionType type,virCPUDef * cpu,bool migratable,bool fail_no_props,qemuMonitorCPUModelInfo ** model_info)3516 qemuMonitorGetCPUModelExpansion(qemuMonitor *mon,
3517 qemuMonitorCPUModelExpansionType type,
3518 virCPUDef *cpu,
3519 bool migratable,
3520 bool fail_no_props,
3521 qemuMonitorCPUModelInfo **model_info)
3522 {
3523 VIR_DEBUG("type=%d cpu=%p migratable=%d", type, cpu, migratable);
3524
3525 QEMU_CHECK_MONITOR(mon);
3526
3527 return qemuMonitorJSONGetCPUModelExpansion(mon, type, cpu,
3528 migratable, fail_no_props,
3529 model_info);
3530 }
3531
3532
3533 int
qemuMonitorGetCPUModelBaseline(qemuMonitor * mon,virCPUDef * cpu_a,virCPUDef * cpu_b,qemuMonitorCPUModelInfo ** baseline)3534 qemuMonitorGetCPUModelBaseline(qemuMonitor *mon,
3535 virCPUDef *cpu_a,
3536 virCPUDef *cpu_b,
3537 qemuMonitorCPUModelInfo **baseline)
3538 {
3539 VIR_DEBUG("cpu_a=%p cpu_b=%p", cpu_a, cpu_b);
3540
3541 QEMU_CHECK_MONITOR(mon);
3542
3543 return qemuMonitorJSONGetCPUModelBaseline(mon, cpu_a, cpu_b, baseline);
3544 }
3545
3546
3547 int
qemuMonitorGetCPUModelComparison(qemuMonitor * mon,virCPUDef * cpu_a,virCPUDef * cpu_b,char ** result)3548 qemuMonitorGetCPUModelComparison(qemuMonitor *mon,
3549 virCPUDef *cpu_a,
3550 virCPUDef *cpu_b,
3551 char **result)
3552 {
3553 VIR_DEBUG("cpu_a=%p cpu_b=%p", cpu_a, cpu_b);
3554
3555 QEMU_CHECK_MONITOR(mon);
3556
3557 return qemuMonitorJSONGetCPUModelComparison(mon, cpu_a, cpu_b, result);
3558 }
3559
3560
3561 void
qemuMonitorCPUModelInfoFree(qemuMonitorCPUModelInfo * model_info)3562 qemuMonitorCPUModelInfoFree(qemuMonitorCPUModelInfo *model_info)
3563 {
3564 size_t i;
3565
3566 if (!model_info)
3567 return;
3568
3569 for (i = 0; i < model_info->nprops; i++) {
3570 g_free(model_info->props[i].name);
3571 if (model_info->props[i].type == QEMU_MONITOR_CPU_PROPERTY_STRING)
3572 g_free(model_info->props[i].value.string);
3573 }
3574
3575 g_free(model_info->props);
3576 g_free(model_info->name);
3577 g_free(model_info);
3578 }
3579
3580
3581 qemuMonitorCPUModelInfo *
qemuMonitorCPUModelInfoCopy(const qemuMonitorCPUModelInfo * orig)3582 qemuMonitorCPUModelInfoCopy(const qemuMonitorCPUModelInfo *orig)
3583 {
3584 qemuMonitorCPUModelInfo *copy;
3585 size_t i;
3586
3587 copy = g_new0(qemuMonitorCPUModelInfo, 1);
3588
3589 copy->props = g_new0(qemuMonitorCPUProperty, orig->nprops);
3590
3591 copy->name = g_strdup(orig->name);
3592
3593 copy->migratability = orig->migratability;
3594 copy->nprops = orig->nprops;
3595
3596 for (i = 0; i < orig->nprops; i++) {
3597 copy->props[i].name = g_strdup(orig->props[i].name);
3598
3599 copy->props[i].migratable = orig->props[i].migratable;
3600 copy->props[i].type = orig->props[i].type;
3601 switch (orig->props[i].type) {
3602 case QEMU_MONITOR_CPU_PROPERTY_BOOLEAN:
3603 copy->props[i].value.boolean = orig->props[i].value.boolean;
3604 break;
3605
3606 case QEMU_MONITOR_CPU_PROPERTY_STRING:
3607 copy->props[i].value.string = g_strdup(orig->props[i].value.string);
3608 break;
3609
3610 case QEMU_MONITOR_CPU_PROPERTY_NUMBER:
3611 copy->props[i].value.number = orig->props[i].value.number;
3612 break;
3613
3614 case QEMU_MONITOR_CPU_PROPERTY_LAST:
3615 break;
3616 }
3617 }
3618
3619 return copy;
3620 }
3621
3622
3623 int
qemuMonitorGetCommands(qemuMonitor * mon,char *** commands)3624 qemuMonitorGetCommands(qemuMonitor *mon,
3625 char ***commands)
3626 {
3627 VIR_DEBUG("commands=%p", commands);
3628
3629 QEMU_CHECK_MONITOR(mon);
3630
3631 return qemuMonitorJSONGetCommands(mon, commands);
3632 }
3633
3634
3635 GHashTable *
qemuMonitorGetCommandLineOptions(qemuMonitor * mon)3636 qemuMonitorGetCommandLineOptions(qemuMonitor *mon)
3637 {
3638 QEMU_CHECK_MONITOR_NULL(mon);
3639
3640 return qemuMonitorJSONGetCommandLineOptions(mon);
3641 }
3642
3643
3644 int
qemuMonitorGetKVMState(qemuMonitor * mon,bool * enabled,bool * present)3645 qemuMonitorGetKVMState(qemuMonitor *mon,
3646 bool *enabled,
3647 bool *present)
3648 {
3649 VIR_DEBUG("enabled=%p present=%p", enabled, present);
3650
3651 QEMU_CHECK_MONITOR(mon);
3652
3653 return qemuMonitorJSONGetKVMState(mon, enabled, present);
3654 }
3655
qemuMonitorGetNVMMState(qemuMonitor * mon,bool * enabled,bool * present)3656 qemuMonitorGetNVMMState(qemuMonitor *mon,
3657 bool *enabled,
3658 bool *present)
3659 {
3660 VIR_DEBUG("enabled=%p present=%p", enabled, present);
3661
3662 QEMU_CHECK_MONITOR(mon);
3663
3664 return qemuMonitorJSONGetNVMMState(mon, enabled, present);
3665 }
3666
3667
3668 int
qemuMonitorGetObjectTypes(qemuMonitor * mon,char *** types)3669 qemuMonitorGetObjectTypes(qemuMonitor *mon,
3670 char ***types)
3671 {
3672 VIR_DEBUG("types=%p", types);
3673
3674 QEMU_CHECK_MONITOR(mon);
3675
3676 return qemuMonitorJSONGetObjectTypes(mon, types);
3677 }
3678
3679
3680 GHashTable *
qemuMonitorGetDeviceProps(qemuMonitor * mon,const char * device)3681 qemuMonitorGetDeviceProps(qemuMonitor *mon,
3682 const char *device)
3683 {
3684 VIR_DEBUG("device=%s", device);
3685
3686 QEMU_CHECK_MONITOR_NULL(mon);
3687
3688 return qemuMonitorJSONGetDeviceProps(mon, device);
3689 }
3690
3691
3692 int
qemuMonitorGetObjectProps(qemuMonitor * mon,const char * object,char *** props)3693 qemuMonitorGetObjectProps(qemuMonitor *mon,
3694 const char *object,
3695 char ***props)
3696 {
3697 VIR_DEBUG("object=%s props=%p", object, props);
3698
3699 QEMU_CHECK_MONITOR(mon);
3700
3701 return qemuMonitorJSONGetObjectProps(mon, object, props);
3702 }
3703
3704
3705 char *
qemuMonitorGetTargetArch(qemuMonitor * mon)3706 qemuMonitorGetTargetArch(qemuMonitor *mon)
3707 {
3708 QEMU_CHECK_MONITOR_NULL(mon);
3709
3710 return qemuMonitorJSONGetTargetArch(mon);
3711 }
3712
3713
3714 int
qemuMonitorGetMigrationCapabilities(qemuMonitor * mon,char *** capabilities)3715 qemuMonitorGetMigrationCapabilities(qemuMonitor *mon,
3716 char ***capabilities)
3717 {
3718 QEMU_CHECK_MONITOR(mon);
3719
3720 return qemuMonitorJSONGetMigrationCapabilities(mon, capabilities);
3721 }
3722
3723
3724 /**
3725 * qemuMonitorSetMigrationCapabilities:
3726 * @mon: Pointer to the monitor object.
3727 * @caps: Migration capabilities.
3728 *
3729 * The @caps object is consumed cleared on success and some errors.
3730 *
3731 * Returns 0 on success, -1 on error.
3732 */
3733 int
qemuMonitorSetMigrationCapabilities(qemuMonitor * mon,virJSONValue ** caps)3734 qemuMonitorSetMigrationCapabilities(qemuMonitor *mon,
3735 virJSONValue **caps)
3736 {
3737 QEMU_CHECK_MONITOR(mon);
3738
3739 return qemuMonitorJSONSetMigrationCapabilities(mon, caps);
3740 }
3741
3742
3743 /**
3744 * qemuMonitorGetGICCapabilities:
3745 * @mon: QEMU monitor
3746 * @capabilities: where to store the GIC capabilities
3747 *
3748 * See qemuMonitorJSONGetGICCapabilities().
3749 */
3750 int
qemuMonitorGetGICCapabilities(qemuMonitor * mon,virGICCapability ** capabilities)3751 qemuMonitorGetGICCapabilities(qemuMonitor *mon,
3752 virGICCapability **capabilities)
3753 {
3754 QEMU_CHECK_MONITOR(mon);
3755
3756 return qemuMonitorJSONGetGICCapabilities(mon, capabilities);
3757 }
3758
3759
3760 int
qemuMonitorGetSEVCapabilities(qemuMonitor * mon,virSEVCapability ** capabilities)3761 qemuMonitorGetSEVCapabilities(qemuMonitor *mon,
3762 virSEVCapability **capabilities)
3763 {
3764 QEMU_CHECK_MONITOR(mon);
3765
3766 return qemuMonitorJSONGetSEVCapabilities(mon, capabilities);
3767 }
3768
3769
3770 int
qemuMonitorNBDServerStart(qemuMonitor * mon,const virStorageNetHostDef * server,const char * tls_alias)3771 qemuMonitorNBDServerStart(qemuMonitor *mon,
3772 const virStorageNetHostDef *server,
3773 const char *tls_alias)
3774 {
3775 /* Peek inside the struct for nicer logging */
3776 if (server->transport == VIR_STORAGE_NET_HOST_TRANS_TCP)
3777 VIR_DEBUG("server={tcp host=%s port=%u} tls_alias=%s",
3778 NULLSTR(server->name), server->port, NULLSTR(tls_alias));
3779 else
3780 VIR_DEBUG("server={unix socket=%s} tls_alias=%s",
3781 NULLSTR(server->socket), NULLSTR(tls_alias));
3782
3783 QEMU_CHECK_MONITOR(mon);
3784
3785 return qemuMonitorJSONNBDServerStart(mon, server, tls_alias);
3786 }
3787
3788
3789 int
qemuMonitorNBDServerAdd(qemuMonitor * mon,const char * deviceID,const char * export,bool writable,const char * bitmap)3790 qemuMonitorNBDServerAdd(qemuMonitor *mon,
3791 const char *deviceID,
3792 const char *export,
3793 bool writable,
3794 const char *bitmap)
3795 {
3796 VIR_DEBUG("deviceID=%s, export=%s, bitmap=%s", deviceID, NULLSTR(export),
3797 NULLSTR(bitmap));
3798
3799 QEMU_CHECK_MONITOR(mon);
3800
3801 return qemuMonitorJSONNBDServerAdd(mon, deviceID, export, writable,
3802 bitmap);
3803 }
3804
3805
3806 int
qemuMonitorNBDServerStop(qemuMonitor * mon)3807 qemuMonitorNBDServerStop(qemuMonitor *mon)
3808 {
3809 QEMU_CHECK_MONITOR(mon);
3810
3811 return qemuMonitorJSONNBDServerStop(mon);
3812 }
3813
3814
3815 int
qemuMonitorBlockExportAdd(qemuMonitor * mon,virJSONValue ** props)3816 qemuMonitorBlockExportAdd(qemuMonitor *mon,
3817 virJSONValue **props)
3818 {
3819 QEMU_CHECK_MONITOR(mon);
3820
3821 return qemuMonitorJSONBlockExportAdd(mon, props);
3822 }
3823
3824
3825 int
qemuMonitorGetTPMModels(qemuMonitor * mon,char *** tpmmodels)3826 qemuMonitorGetTPMModels(qemuMonitor *mon,
3827 char ***tpmmodels)
3828 {
3829 VIR_DEBUG("tpmmodels=%p", tpmmodels);
3830
3831 QEMU_CHECK_MONITOR(mon);
3832
3833 return qemuMonitorJSONGetTPMModels(mon, tpmmodels);
3834 }
3835
3836
3837 int
qemuMonitorGetTPMTypes(qemuMonitor * mon,char *** tpmtypes)3838 qemuMonitorGetTPMTypes(qemuMonitor *mon,
3839 char ***tpmtypes)
3840 {
3841 VIR_DEBUG("tpmtypes=%p", tpmtypes);
3842
3843 QEMU_CHECK_MONITOR(mon);
3844
3845 return qemuMonitorJSONGetTPMTypes(mon, tpmtypes);
3846 }
3847
3848
3849 int
qemuMonitorAttachCharDev(qemuMonitor * mon,const char * chrID,virDomainChrSourceDef * chr)3850 qemuMonitorAttachCharDev(qemuMonitor *mon,
3851 const char *chrID,
3852 virDomainChrSourceDef *chr)
3853 {
3854 VIR_DEBUG("chrID=%s chr=%p", chrID, chr);
3855
3856 QEMU_CHECK_MONITOR(mon);
3857
3858 return qemuMonitorJSONAttachCharDev(mon, chrID, chr);
3859 }
3860
3861
3862 int
qemuMonitorDetachCharDev(qemuMonitor * mon,const char * chrID)3863 qemuMonitorDetachCharDev(qemuMonitor *mon,
3864 const char *chrID)
3865 {
3866 VIR_DEBUG("chrID=%s", chrID);
3867
3868 QEMU_CHECK_MONITOR(mon);
3869
3870 return qemuMonitorJSONDetachCharDev(mon, chrID);
3871 }
3872
3873
3874 int
qemuMonitorGetDeviceAliases(qemuMonitor * mon,char *** aliases)3875 qemuMonitorGetDeviceAliases(qemuMonitor *mon,
3876 char ***aliases)
3877 {
3878 VIR_DEBUG("aliases=%p", aliases);
3879
3880 QEMU_CHECK_MONITOR(mon);
3881
3882 return qemuMonitorJSONGetDeviceAliases(mon, aliases);
3883 }
3884
3885
3886 /**
3887 * qemuMonitorSetDomainLogLocked:
3888 * @mon: Locked monitor object to set the log file reading on
3889 * @func: the callback to report errors
3890 * @opaque: data to pass to @func
3891 * @destroy: optional callback to free @opaque
3892 *
3893 * Set the file descriptor of the open VM log file to report potential
3894 * early startup errors of qemu. This function requires @mon to be
3895 * locked already!
3896 */
3897 void
qemuMonitorSetDomainLogLocked(qemuMonitor * mon,qemuMonitorReportDomainLogError func,void * opaque,virFreeCallback destroy)3898 qemuMonitorSetDomainLogLocked(qemuMonitor *mon,
3899 qemuMonitorReportDomainLogError func,
3900 void *opaque,
3901 virFreeCallback destroy)
3902 {
3903 if (mon->logDestroy && mon->logOpaque)
3904 mon->logDestroy(mon->logOpaque);
3905
3906 mon->logFunc = func;
3907 mon->logOpaque = opaque;
3908 mon->logDestroy = destroy;
3909 }
3910
3911
3912 /**
3913 * qemuMonitorSetDomainLog:
3914 * @mon: Unlocked monitor object to set the log file reading on
3915 * @func: the callback to report errors
3916 * @opaque: data to pass to @func
3917 * @destroy: optional callback to free @opaque
3918 *
3919 * Set the file descriptor of the open VM log file to report potential
3920 * early startup errors of qemu. This functions requires @mon to be
3921 * unlocked.
3922 */
3923 void
qemuMonitorSetDomainLog(qemuMonitor * mon,qemuMonitorReportDomainLogError func,void * opaque,virFreeCallback destroy)3924 qemuMonitorSetDomainLog(qemuMonitor *mon,
3925 qemuMonitorReportDomainLogError func,
3926 void *opaque,
3927 virFreeCallback destroy)
3928 {
3929 virObjectLock(mon);
3930 qemuMonitorSetDomainLogLocked(mon, func, opaque, destroy);
3931 virObjectUnlock(mon);
3932 }
3933
3934
3935 /**
3936 * qemuMonitorJSONGetGuestCPUx86:
3937 * @mon: Pointer to the monitor
3938 * @data: returns the cpu data
3939 * @disabled: returns the CPU data for features which were disabled by QEMU
3940 *
3941 * Retrieve the definition of the guest CPU from a running qemu instance.
3942 *
3943 * Returns 0 on success, -2 if the operation is not supported by the guest,
3944 * -1 on other errors.
3945 */
3946 int
qemuMonitorGetGuestCPUx86(qemuMonitor * mon,virCPUData ** data,virCPUData ** disabled)3947 qemuMonitorGetGuestCPUx86(qemuMonitor *mon,
3948 virCPUData **data,
3949 virCPUData **disabled)
3950 {
3951 VIR_DEBUG("data=%p disabled=%p", data, disabled);
3952
3953 QEMU_CHECK_MONITOR(mon);
3954
3955 *data = NULL;
3956 if (disabled)
3957 *disabled = NULL;
3958
3959 return qemuMonitorJSONGetGuestCPUx86(mon, data, disabled);
3960 }
3961
3962
3963 /**
3964 * qemuMonitorGetGuestCPU:
3965 * @mon: Pointer to the monitor
3966 * @arch: CPU architecture
3967 * @translate: callback for translating CPU feature names from QEMU to libvirt
3968 * @opaque: data for @translate callback
3969 * @enabled: returns the CPU data for all enabled features
3970 * @disabled: returns the CPU data for features which we asked for
3971 * (either explicitly or via a named CPU model) but QEMU disabled them
3972 *
3973 * Retrieve the definition of the guest CPU from a running QEMU instance.
3974 *
3975 * Returns 0 on success, -1 on error.
3976 */
3977 int
qemuMonitorGetGuestCPU(qemuMonitor * mon,virArch arch,qemuMonitorCPUFeatureTranslationCallback translate,void * opaque,virCPUData ** enabled,virCPUData ** disabled)3978 qemuMonitorGetGuestCPU(qemuMonitor *mon,
3979 virArch arch,
3980 qemuMonitorCPUFeatureTranslationCallback translate,
3981 void *opaque,
3982 virCPUData **enabled,
3983 virCPUData **disabled)
3984 {
3985 VIR_DEBUG("arch=%s translate=%p opaque=%p enabled=%p disabled=%p",
3986 virArchToString(arch), translate, opaque, enabled, disabled);
3987
3988 QEMU_CHECK_MONITOR(mon);
3989
3990 *enabled = NULL;
3991 if (disabled)
3992 *disabled = NULL;
3993
3994 return qemuMonitorJSONGetGuestCPU(mon, arch, translate, opaque,
3995 enabled, disabled);
3996 }
3997
3998
3999 /**
4000 * qemuMonitorRTCResetReinjection:
4001 * @mon: Pointer to the monitor
4002 *
4003 * Issue rtc-reset-reinjection command.
4004 * This should be used in cases where guest time is restored via
4005 * guest agent, so RTC injection is not needed (in fact it would
4006 * confuse guest's RTC).
4007 *
4008 * Returns 0 on success
4009 * -1 on error.
4010 */
4011 int
qemuMonitorRTCResetReinjection(qemuMonitor * mon)4012 qemuMonitorRTCResetReinjection(qemuMonitor *mon)
4013 {
4014 QEMU_CHECK_MONITOR(mon);
4015
4016 return qemuMonitorJSONRTCResetReinjection(mon);
4017 }
4018
4019
4020 /**
4021 * qemuMonitorGetIOThreads:
4022 * @mon: Pointer to the monitor
4023 * @iothreads: Location to return array of IOThreadInfo data
4024 * @niothreads: Count of the number of IOThreads in the array
4025 *
4026 * Issue query-iothreads command.
4027 * Retrieve the list of iothreads defined/running for the machine
4028 *
4029 * Returns 0 on success
4030 * -1 on error.
4031 */
4032 int
qemuMonitorGetIOThreads(qemuMonitor * mon,qemuMonitorIOThreadInfo *** iothreads,int * niothreads)4033 qemuMonitorGetIOThreads(qemuMonitor *mon,
4034 qemuMonitorIOThreadInfo ***iothreads,
4035 int *niothreads)
4036 {
4037 VIR_DEBUG("iothreads=%p", iothreads);
4038
4039 QEMU_CHECK_MONITOR(mon);
4040
4041 return qemuMonitorJSONGetIOThreads(mon, iothreads, niothreads);
4042 }
4043
4044
4045 /**
4046 * qemuMonitorSetIOThread:
4047 * @mon: Pointer to the monitor
4048 * @iothreadInfo: filled IOThread info with data
4049 *
4050 * Alter the specified IOThread's IOThreadInfo values.
4051 */
4052 int
qemuMonitorSetIOThread(qemuMonitor * mon,qemuMonitorIOThreadInfo * iothreadInfo)4053 qemuMonitorSetIOThread(qemuMonitor *mon,
4054 qemuMonitorIOThreadInfo *iothreadInfo)
4055 {
4056 VIR_DEBUG("iothread=%p", iothreadInfo);
4057
4058 QEMU_CHECK_MONITOR(mon);
4059
4060 return qemuMonitorJSONSetIOThread(mon, iothreadInfo);
4061 }
4062
4063
4064 /**
4065 * qemuMonitorGetMemoryDeviceInfo:
4066 * @mon: pointer to the monitor
4067 * @info: Location to return the hash of qemuMonitorMemoryDeviceInfo
4068 *
4069 * Retrieve state and addresses of frontend memory devices present in
4070 * the guest.
4071 *
4072 * Returns: 0 on success and fills @info with a newly allocated struct,
4073 * -1 otherwise.
4074 */
4075 int
qemuMonitorGetMemoryDeviceInfo(qemuMonitor * mon,GHashTable ** info)4076 qemuMonitorGetMemoryDeviceInfo(qemuMonitor *mon,
4077 GHashTable **info)
4078 {
4079 g_autoptr(GHashTable) hash = virHashNew(g_free);
4080 int ret;
4081
4082 VIR_DEBUG("info=%p", info);
4083
4084 *info = NULL;
4085
4086 QEMU_CHECK_MONITOR(mon);
4087
4088 if ((ret = qemuMonitorJSONGetMemoryDeviceInfo(mon, hash)) >= 0)
4089 *info = g_steal_pointer(&hash);
4090
4091 return ret;
4092 }
4093
4094
4095 int
qemuMonitorMigrateIncoming(qemuMonitor * mon,const char * uri)4096 qemuMonitorMigrateIncoming(qemuMonitor *mon,
4097 const char *uri)
4098 {
4099 VIR_DEBUG("uri=%s", uri);
4100
4101 QEMU_CHECK_MONITOR(mon);
4102
4103 return qemuMonitorJSONMigrateIncoming(mon, uri);
4104 }
4105
4106
4107 int
qemuMonitorMigrateStartPostCopy(qemuMonitor * mon)4108 qemuMonitorMigrateStartPostCopy(qemuMonitor *mon)
4109 {
4110 QEMU_CHECK_MONITOR(mon);
4111
4112 return qemuMonitorJSONMigrateStartPostCopy(mon);
4113 }
4114
4115
4116 int
qemuMonitorMigrateContinue(qemuMonitor * mon,qemuMonitorMigrationStatus status)4117 qemuMonitorMigrateContinue(qemuMonitor *mon,
4118 qemuMonitorMigrationStatus status)
4119 {
4120 VIR_DEBUG("status=%s", qemuMonitorMigrationStatusTypeToString(status));
4121
4122 QEMU_CHECK_MONITOR(mon);
4123
4124 return qemuMonitorJSONMigrateContinue(mon, status);
4125 }
4126
4127
4128 int
qemuMonitorGetRTCTime(qemuMonitor * mon,struct tm * tm)4129 qemuMonitorGetRTCTime(qemuMonitor *mon,
4130 struct tm *tm)
4131 {
4132 QEMU_CHECK_MONITOR(mon);
4133
4134 return qemuMonitorJSONGetRTCTime(mon, tm);
4135 }
4136
4137
4138 virJSONValue *
qemuMonitorQueryQMPSchema(qemuMonitor * mon)4139 qemuMonitorQueryQMPSchema(qemuMonitor *mon)
4140 {
4141 QEMU_CHECK_MONITOR_NULL(mon);
4142
4143 return qemuMonitorJSONQueryQMPSchema(mon);
4144 }
4145
4146
4147 int
qemuMonitorSetBlockThreshold(qemuMonitor * mon,const char * nodename,unsigned long long threshold)4148 qemuMonitorSetBlockThreshold(qemuMonitor *mon,
4149 const char *nodename,
4150 unsigned long long threshold)
4151 {
4152 VIR_DEBUG("node='%s', threshold=%llu", nodename, threshold);
4153
4154 QEMU_CHECK_MONITOR(mon);
4155
4156 return qemuMonitorJSONSetBlockThreshold(mon, nodename, threshold);
4157 }
4158
4159
4160 virJSONValue *
qemuMonitorQueryNamedBlockNodes(qemuMonitor * mon)4161 qemuMonitorQueryNamedBlockNodes(qemuMonitor *mon)
4162 {
4163 QEMU_CHECK_MONITOR_NULL(mon);
4164
4165 return qemuMonitorJSONQueryNamedBlockNodes(mon, false);
4166 }
4167
4168
4169 char *
qemuMonitorGuestPanicEventInfoFormatMsg(qemuMonitorEventPanicInfo * info)4170 qemuMonitorGuestPanicEventInfoFormatMsg(qemuMonitorEventPanicInfo *info)
4171 {
4172 char *ret = NULL;
4173
4174 switch (info->type) {
4175 case QEMU_MONITOR_EVENT_PANIC_INFO_TYPE_HYPERV:
4176 ret = g_strdup_printf("hyper-v: arg1='0x%llx', arg2='0x%llx', "
4177 "arg3='0x%llx', arg4='0x%llx', arg5='0x%llx'",
4178 info->data.hyperv.arg1, info->data.hyperv.arg2,
4179 info->data.hyperv.arg3, info->data.hyperv.arg4,
4180 info->data.hyperv.arg5);
4181 break;
4182 case QEMU_MONITOR_EVENT_PANIC_INFO_TYPE_S390:
4183 ret = g_strdup_printf("s390: core='%d' psw-mask='0x%016llx' "
4184 "psw-addr='0x%016llx' reason='%s'",
4185 info->data.s390.core,
4186 info->data.s390.psw_mask,
4187 info->data.s390.psw_addr,
4188 info->data.s390.reason);
4189 break;
4190 case QEMU_MONITOR_EVENT_PANIC_INFO_TYPE_NONE:
4191 case QEMU_MONITOR_EVENT_PANIC_INFO_TYPE_LAST:
4192 break;
4193 }
4194
4195 return ret;
4196 }
4197
4198
4199 void
qemuMonitorEventPanicInfoFree(qemuMonitorEventPanicInfo * info)4200 qemuMonitorEventPanicInfoFree(qemuMonitorEventPanicInfo *info)
4201 {
4202 if (!info)
4203 return;
4204
4205 switch (info->type) {
4206 case QEMU_MONITOR_EVENT_PANIC_INFO_TYPE_S390:
4207 g_free(info->data.s390.reason);
4208 break;
4209 case QEMU_MONITOR_EVENT_PANIC_INFO_TYPE_NONE:
4210 case QEMU_MONITOR_EVENT_PANIC_INFO_TYPE_HYPERV:
4211 case QEMU_MONITOR_EVENT_PANIC_INFO_TYPE_LAST:
4212 break;
4213 }
4214
4215 g_free(info);
4216 }
4217
4218
4219 void
qemuMonitorEventRdmaGidStatusFree(qemuMonitorRdmaGidStatus * info)4220 qemuMonitorEventRdmaGidStatusFree(qemuMonitorRdmaGidStatus *info)
4221 {
4222 if (!info)
4223 return;
4224
4225 g_free(info->netdev);
4226 g_free(info);
4227 }
4228
4229
4230 void
qemuMonitorMemoryDeviceSizeChangeFree(qemuMonitorMemoryDeviceSizeChangePtr info)4231 qemuMonitorMemoryDeviceSizeChangeFree(qemuMonitorMemoryDeviceSizeChangePtr info)
4232 {
4233 if (!info)
4234 return;
4235
4236 g_free(info->devAlias);
4237 }
4238
4239
4240 int
qemuMonitorSetWatchdogAction(qemuMonitor * mon,const char * action)4241 qemuMonitorSetWatchdogAction(qemuMonitor *mon,
4242 const char *action)
4243 {
4244 VIR_DEBUG("watchdogAction=%s", action);
4245
4246 QEMU_CHECK_MONITOR(mon);
4247
4248 return qemuMonitorJSONSetWatchdogAction(mon, action);
4249 }
4250
4251
4252 /**
4253 * qemuMonitorBlockdevCreate:
4254 * @mon: monitor object
4255 * @jobname: name of the job
4256 * @props: JSON object describing the blockdev to add
4257 *
4258 * Instructs qemu to create/format a new storage or format layer. Note that
4259 * the job does not add the created/formatted image into qemu and
4260 * qemuMonitorBlockdevAdd needs to be called separately with corresponding
4261 * arguments. Note that the arguments for creating and adding are different.
4262 *
4263 * Note that @props is always consumed by this function and should not be
4264 * accessed after calling this function.
4265 */
4266 int
qemuMonitorBlockdevCreate(qemuMonitor * mon,const char * jobname,virJSONValue * props)4267 qemuMonitorBlockdevCreate(qemuMonitor *mon,
4268 const char *jobname,
4269 virJSONValue *props)
4270 {
4271 VIR_DEBUG("jobname=%s props=%p", jobname, props);
4272
4273 QEMU_CHECK_MONITOR_GOTO(mon, error);
4274
4275 return qemuMonitorJSONBlockdevCreate(mon, jobname, props);
4276
4277 error:
4278 virJSONValueFree(props);
4279 return -1;
4280 }
4281
4282 /**
4283 * qemuMonitorBlockdevAdd:
4284 * @mon: monitor object
4285 * @props: JSON object describing the blockdev to add
4286 *
4287 * Adds a new block device (BDS) to qemu. Note that *@props is consumed
4288 * and set to NULL on success.
4289 */
4290 int
qemuMonitorBlockdevAdd(qemuMonitor * mon,virJSONValue ** props)4291 qemuMonitorBlockdevAdd(qemuMonitor *mon,
4292 virJSONValue **props)
4293 {
4294 VIR_DEBUG("props=%p (node-name=%s)", *props,
4295 NULLSTR(virJSONValueObjectGetString(*props, "node-name")));
4296
4297 QEMU_CHECK_MONITOR(mon);
4298
4299 return qemuMonitorJSONBlockdevAdd(mon, props);
4300 }
4301
4302
4303 int
qemuMonitorBlockdevReopen(qemuMonitor * mon,virJSONValue ** props)4304 qemuMonitorBlockdevReopen(qemuMonitor *mon,
4305 virJSONValue **props)
4306 {
4307 VIR_DEBUG("props=%p (node-name=%s)", *props,
4308 NULLSTR(virJSONValueObjectGetString(*props, "node-name")));
4309
4310 QEMU_CHECK_MONITOR(mon);
4311
4312 return qemuMonitorJSONBlockdevReopen(mon, props);
4313 }
4314
4315
4316 int
qemuMonitorBlockdevDel(qemuMonitor * mon,const char * nodename)4317 qemuMonitorBlockdevDel(qemuMonitor *mon,
4318 const char *nodename)
4319 {
4320 VIR_DEBUG("nodename=%s", nodename);
4321
4322 QEMU_CHECK_MONITOR(mon);
4323
4324 return qemuMonitorJSONBlockdevDel(mon, nodename);
4325 }
4326
4327 int
qemuMonitorBlockdevTrayOpen(qemuMonitor * mon,const char * id,bool force)4328 qemuMonitorBlockdevTrayOpen(qemuMonitor *mon,
4329 const char *id,
4330 bool force)
4331 {
4332 VIR_DEBUG("id=%s force=%d", id, force);
4333
4334 QEMU_CHECK_MONITOR(mon);
4335
4336 return qemuMonitorJSONBlockdevTrayOpen(mon, id, force);
4337 }
4338
4339
4340 int
qemuMonitorBlockdevTrayClose(qemuMonitor * mon,const char * id)4341 qemuMonitorBlockdevTrayClose(qemuMonitor *mon,
4342 const char *id)
4343 {
4344 VIR_DEBUG("id=%s", id);
4345
4346 QEMU_CHECK_MONITOR(mon);
4347
4348 return qemuMonitorJSONBlockdevTrayClose(mon, id);
4349 }
4350
4351
4352 int
qemuMonitorBlockdevMediumRemove(qemuMonitor * mon,const char * id)4353 qemuMonitorBlockdevMediumRemove(qemuMonitor *mon,
4354 const char *id)
4355 {
4356 VIR_DEBUG("id=%s", id);
4357
4358 QEMU_CHECK_MONITOR(mon);
4359
4360 return qemuMonitorJSONBlockdevMediumRemove(mon, id);
4361 }
4362
4363
4364 int
qemuMonitorBlockdevMediumInsert(qemuMonitor * mon,const char * id,const char * nodename)4365 qemuMonitorBlockdevMediumInsert(qemuMonitor *mon,
4366 const char *id,
4367 const char *nodename)
4368 {
4369 VIR_DEBUG("id=%s nodename=%s", id, nodename);
4370
4371 QEMU_CHECK_MONITOR(mon);
4372
4373 return qemuMonitorJSONBlockdevMediumInsert(mon, id, nodename);
4374 }
4375
4376
4377 char *
qemuMonitorGetSEVMeasurement(qemuMonitor * mon)4378 qemuMonitorGetSEVMeasurement(qemuMonitor *mon)
4379 {
4380 QEMU_CHECK_MONITOR_NULL(mon);
4381
4382 return qemuMonitorJSONGetSEVMeasurement(mon);
4383 }
4384
4385
4386 int
qemuMonitorGetPRManagerInfo(qemuMonitor * mon,GHashTable ** retinfo)4387 qemuMonitorGetPRManagerInfo(qemuMonitor *mon,
4388 GHashTable **retinfo)
4389 {
4390 g_autoptr(GHashTable) info = virHashNew(g_free);
4391
4392 *retinfo = NULL;
4393
4394 QEMU_CHECK_MONITOR(mon);
4395
4396 if (qemuMonitorJSONGetPRManagerInfo(mon, info) < 0)
4397 return -1;
4398
4399 *retinfo = g_steal_pointer(&info);
4400 return 0;
4401 }
4402
4403
4404 int
qemuMonitorGetCurrentMachineInfo(qemuMonitor * mon,qemuMonitorCurrentMachineInfo * info)4405 qemuMonitorGetCurrentMachineInfo(qemuMonitor *mon,
4406 qemuMonitorCurrentMachineInfo *info)
4407 {
4408 QEMU_CHECK_MONITOR(mon);
4409
4410 return qemuMonitorJSONGetCurrentMachineInfo(mon, info);
4411 }
4412
4413
4414 void
qemuMonitorJobInfoFree(qemuMonitorJobInfo * job)4415 qemuMonitorJobInfoFree(qemuMonitorJobInfo *job)
4416 {
4417 if (!job)
4418 return;
4419
4420 g_free(job->id);
4421 g_free(job->error);
4422 g_free(job);
4423 }
4424
4425
4426 int
qemuMonitorGetJobInfo(qemuMonitor * mon,qemuMonitorJobInfo *** jobs,size_t * njobs)4427 qemuMonitorGetJobInfo(qemuMonitor *mon,
4428 qemuMonitorJobInfo ***jobs,
4429 size_t *njobs)
4430 {
4431 QEMU_CHECK_MONITOR(mon);
4432
4433 return qemuMonitorJSONGetJobInfo(mon, jobs, njobs);
4434 }
4435
4436
4437 /* qemuMonitorGetCPUMigratable:
4438 *
4439 * Get the migratable property of the CPU object.
4440 *
4441 * Returns -1 on error,
4442 * 1 when the property is not supported,
4443 * 0 on success (@migratable is set accordingly).
4444 */
4445 int
qemuMonitorGetCPUMigratable(qemuMonitor * mon,bool * migratable)4446 qemuMonitorGetCPUMigratable(qemuMonitor *mon,
4447 bool *migratable)
4448 {
4449 QEMU_CHECK_MONITOR(mon);
4450
4451 return qemuMonitorJSONGetCPUMigratable(mon, migratable);
4452 }
4453
4454
4455 int
qemuMonitorTransactionBitmapAdd(virJSONValue * actions,const char * node,const char * name,bool persistent,bool disabled,unsigned long long granularity)4456 qemuMonitorTransactionBitmapAdd(virJSONValue *actions,
4457 const char *node,
4458 const char *name,
4459 bool persistent,
4460 bool disabled,
4461 unsigned long long granularity)
4462 {
4463 return qemuMonitorJSONTransactionBitmapAdd(actions, node, name, persistent,
4464 disabled, granularity);
4465 }
4466
4467
4468 int
qemuMonitorTransactionBitmapRemove(virJSONValue * actions,const char * node,const char * name)4469 qemuMonitorTransactionBitmapRemove(virJSONValue *actions,
4470 const char *node,
4471 const char *name)
4472 {
4473 return qemuMonitorJSONTransactionBitmapRemove(actions, node, name);
4474 }
4475
4476
4477 int
qemuMonitorBitmapRemove(qemuMonitor * mon,const char * node,const char * name)4478 qemuMonitorBitmapRemove(qemuMonitor *mon,
4479 const char *node,
4480 const char *name)
4481 {
4482 VIR_DEBUG("node='%s', name='%s'", node, name);
4483
4484 QEMU_CHECK_MONITOR(mon);
4485
4486 return qemuMonitorJSONBitmapRemove(mon, node, name);
4487 }
4488
4489
4490 int
qemuMonitorTransactionBitmapEnable(virJSONValue * actions,const char * node,const char * name)4491 qemuMonitorTransactionBitmapEnable(virJSONValue *actions,
4492 const char *node,
4493 const char *name)
4494 {
4495 return qemuMonitorJSONTransactionBitmapEnable(actions, node, name);
4496 }
4497
4498
4499 int
qemuMonitorTransactionBitmapDisable(virJSONValue * actions,const char * node,const char * name)4500 qemuMonitorTransactionBitmapDisable(virJSONValue *actions,
4501 const char *node,
4502 const char *name)
4503 {
4504 return qemuMonitorJSONTransactionBitmapDisable(actions, node, name);
4505 }
4506
4507
4508 int
qemuMonitorTransactionBitmapMerge(virJSONValue * actions,const char * node,const char * target,virJSONValue ** sources)4509 qemuMonitorTransactionBitmapMerge(virJSONValue *actions,
4510 const char *node,
4511 const char *target,
4512 virJSONValue **sources)
4513 {
4514 return qemuMonitorJSONTransactionBitmapMerge(actions, node, target, sources);
4515 }
4516
4517
4518 int
qemuMonitorTransactionBitmapMergeSourceAddBitmap(virJSONValue * sources,const char * sourcenode,const char * sourcebitmap)4519 qemuMonitorTransactionBitmapMergeSourceAddBitmap(virJSONValue *sources,
4520 const char *sourcenode,
4521 const char *sourcebitmap)
4522 {
4523 return qemuMonitorJSONTransactionBitmapMergeSourceAddBitmap(sources, sourcenode, sourcebitmap);
4524 }
4525
4526
4527 int
qemuMonitorTransactionSnapshotLegacy(virJSONValue * actions,const char * device,const char * path,const char * format,bool existing)4528 qemuMonitorTransactionSnapshotLegacy(virJSONValue *actions,
4529 const char *device,
4530 const char *path,
4531 const char *format,
4532 bool existing)
4533 {
4534 return qemuMonitorJSONTransactionSnapshotLegacy(actions, device, path,
4535 format, existing);
4536 }
4537
4538
4539 int
qemuMonitorTransactionSnapshotBlockdev(virJSONValue * actions,const char * node,const char * overlay)4540 qemuMonitorTransactionSnapshotBlockdev(virJSONValue *actions,
4541 const char *node,
4542 const char *overlay)
4543 {
4544 return qemuMonitorJSONTransactionSnapshotBlockdev(actions, node, overlay);
4545 }
4546
4547
4548 int
qemuMonitorTransactionBackup(virJSONValue * actions,const char * device,const char * jobname,const char * target,const char * bitmap,qemuMonitorTransactionBackupSyncMode syncmode)4549 qemuMonitorTransactionBackup(virJSONValue *actions,
4550 const char *device,
4551 const char *jobname,
4552 const char *target,
4553 const char *bitmap,
4554 qemuMonitorTransactionBackupSyncMode syncmode)
4555 {
4556 return qemuMonitorJSONTransactionBackup(actions, device, jobname, target,
4557 bitmap, syncmode);
4558 }
4559
4560
4561 int
qemuMonitorStartDirtyRateCalc(qemuMonitor * mon,int seconds)4562 qemuMonitorStartDirtyRateCalc(qemuMonitor *mon,
4563 int seconds)
4564 {
4565 VIR_DEBUG("seconds=%d", seconds);
4566
4567 QEMU_CHECK_MONITOR(mon);
4568
4569 return qemuMonitorJSONStartDirtyRateCalc(mon, seconds);
4570 }
4571
4572
4573 int
qemuMonitorQueryDirtyRate(qemuMonitor * mon,qemuMonitorDirtyRateInfo * info)4574 qemuMonitorQueryDirtyRate(qemuMonitor *mon,
4575 qemuMonitorDirtyRateInfo *info)
4576 {
4577 VIR_DEBUG("info=%p", info);
4578
4579 QEMU_CHECK_MONITOR(mon);
4580
4581 return qemuMonitorJSONQueryDirtyRate(mon, info);
4582 }
4583
4584
4585 int
qemuMonitorSetAction(qemuMonitor * mon,qemuMonitorActionShutdown shutdown,qemuMonitorActionReboot reboot,qemuMonitorActionWatchdog watchdog,qemuMonitorActionPanic panic)4586 qemuMonitorSetAction(qemuMonitor *mon,
4587 qemuMonitorActionShutdown shutdown,
4588 qemuMonitorActionReboot reboot,
4589 qemuMonitorActionWatchdog watchdog,
4590 qemuMonitorActionPanic panic)
4591 {
4592 VIR_DEBUG("shutdown=%u, reboot=%u, watchdog=%u panic=%u",
4593 shutdown, reboot, watchdog, panic);
4594
4595 QEMU_CHECK_MONITOR(mon);
4596
4597 return qemuMonitorJSONSetAction(mon, shutdown, reboot, watchdog, panic);
4598 }
4599
4600
4601 int
qemuMonitorChangeMemoryRequestedSize(qemuMonitor * mon,const char * alias,unsigned long long requestedsize)4602 qemuMonitorChangeMemoryRequestedSize(qemuMonitor *mon,
4603 const char *alias,
4604 unsigned long long requestedsize)
4605 {
4606 VIR_DEBUG("alias=%s requestedsize=%llu", alias, requestedsize);
4607
4608 QEMU_CHECK_MONITOR(mon);
4609
4610 return qemuMonitorJSONChangeMemoryRequestedSize(mon, alias, requestedsize);
4611 }
4612