Fix QEMU memory stats JSON mode
[libvirt.git] / src / qemu / qemu_monitor.c
1 /*
2  * qemu_monitor.c: interaction with QEMU monitor console
3  *
4  * Copyright (C) 2006-2009 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, write to the Free Software
19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
20  *
21  * Author: Daniel P. Berrange <berrange@redhat.com>
22  */
23
24 #include <config.h>
25
26 #include <poll.h>
27 #include <sys/un.h>
28 #include <unistd.h>
29 #include <fcntl.h>
30
31 #include "qemu_monitor.h"
32 #include "qemu_monitor_text.h"
33 #include "qemu_monitor_json.h"
34 #include "qemu_conf.h"
35 #include "event.h"
36 #include "virterror_internal.h"
37 #include "memory.h"
38 #include "logging.h"
39
40 #define VIR_FROM_THIS VIR_FROM_QEMU
41
42 #define DEBUG_IO 0
43 #define DEBUG_RAW_IO 0
44
45 struct _qemuMonitor {
46     virMutex lock;
47     virCond notify;
48
49     int refs;
50
51     int fd;
52     int watch;
53     int hasSendFD;
54
55     virDomainObjPtr vm;
56
57     qemuMonitorCallbacksPtr cb;
58
59     /* If there's a command being processed this will be
60      * non-NULL */
61     qemuMonitorMessagePtr msg;
62
63     /* Buffer incoming data ready for Text/QMP monitor
64      * code to process & find message boundaries */
65     size_t bufferOffset;
66     size_t bufferLength;
67     char *buffer;
68
69     /* If anything went wrong, this will be fed back
70      * the next monitor msg */
71     int lastErrno;
72
73     /* If the monitor EOF callback is currently active (stops more commands being run) */
74     unsigned eofcb: 1;
75     /* If the monitor is in process of shutting down */
76     unsigned closed: 1;
77
78     unsigned json: 1;
79 };
80
81
82 VIR_ENUM_IMPL(qemuMonitorMigrationStatus,
83               QEMU_MONITOR_MIGRATION_STATUS_LAST,
84               "inactive", "active", "completed", "failed", "cancelled")
85
86 static char *qemuMonitorEscape(const char *in, int shell)
87 {
88     int len = 0;
89     int i, j;
90     char *out;
91
92     /* To pass through the QEMU monitor, we need to use escape
93        sequences: \r, \n, \", \\
94
95        To pass through both QEMU + the shell, we need to escape
96        the single character ' as the five characters '\\''
97     */
98
99     for (i = 0; in[i] != '\0'; i++) {
100         switch(in[i]) {
101         case '\r':
102         case '\n':
103         case '"':
104         case '\\':
105             len += 2;
106             break;
107         case '\'':
108             if (shell)
109                 len += 5;
110             else
111                 len += 1;
112             break;
113         default:
114             len += 1;
115             break;
116         }
117     }
118
119     if (VIR_ALLOC_N(out, len + 1) < 0)
120         return NULL;
121
122     for (i = j = 0; in[i] != '\0'; i++) {
123         switch(in[i]) {
124         case '\r':
125             out[j++] = '\\';
126             out[j++] = 'r';
127             break;
128         case '\n':
129             out[j++] = '\\';
130             out[j++] = 'n';
131             break;
132         case '"':
133         case '\\':
134             out[j++] = '\\';
135             out[j++] = in[i];
136             break;
137         case '\'':
138             if (shell) {
139                 out[j++] = '\'';
140                 out[j++] = '\\';
141                 out[j++] = '\\';
142                 out[j++] = '\'';
143                 out[j++] = '\'';
144             } else {
145                 out[j++] = in[i];
146             }
147             break;
148         default:
149             out[j++] = in[i];
150             break;
151         }
152     }
153     out[j] = '\0';
154
155     return out;
156 }
157
158 char *qemuMonitorEscapeArg(const char *in)
159 {
160     return qemuMonitorEscape(in, 0);
161 }
162
163 char *qemuMonitorEscapeShell(const char *in)
164 {
165     return qemuMonitorEscape(in, 1);
166 }
167
168
169 #if QEMU_DEBUG_RAW_IO
170 # include <c-ctype.h>
171 static char * qemuMonitorEscapeNonPrintable(const char *text)
172 {
173     int i;
174     virBuffer buf = VIR_BUFFER_INITIALIZER;
175     for (i = 0 ; text[i] != '\0' ; i++) {
176         if (c_isprint(text[i]) ||
177             text[i] == '\n' ||
178             (text[i] == '\r' && text[i+1] == '\n'))
179             virBufferVSprintf(&buf,"%c", text[i]);
180         else
181             virBufferVSprintf(&buf, "0x%02x", text[i]);
182     }
183     return virBufferContentAndReset(&buf);
184 }
185 #endif
186
187 void qemuMonitorLock(qemuMonitorPtr mon)
188 {
189     virMutexLock(&mon->lock);
190 }
191
192 void qemuMonitorUnlock(qemuMonitorPtr mon)
193 {
194     virMutexUnlock(&mon->lock);
195 }
196
197
198 static void qemuMonitorFree(qemuMonitorPtr mon)
199 {
200     VIR_DEBUG("mon=%p", mon);
201     if (virCondDestroy(&mon->notify) < 0)
202     {}
203     virMutexDestroy(&mon->lock);
204     VIR_FREE(mon);
205 }
206
207 int qemuMonitorRef(qemuMonitorPtr mon)
208 {
209     mon->refs++;
210     return mon->refs;
211 }
212
213 int qemuMonitorUnref(qemuMonitorPtr mon)
214 {
215     mon->refs--;
216
217     if (mon->refs == 0) {
218         qemuMonitorUnlock(mon);
219         qemuMonitorFree(mon);
220         return 0;
221     }
222
223     return mon->refs;
224 }
225
226
227 static int
228 qemuMonitorOpenUnix(const char *monitor)
229 {
230     struct sockaddr_un addr;
231     int monfd;
232     int timeout = 3; /* In seconds */
233     int ret, i = 0;
234
235     if ((monfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
236         virReportSystemError(errno,
237                              "%s", _("failed to create socket"));
238         return -1;
239     }
240
241     memset(&addr, 0, sizeof(addr));
242     addr.sun_family = AF_UNIX;
243     if (virStrcpyStatic(addr.sun_path, monitor) == NULL) {
244         qemuReportError(VIR_ERR_INTERNAL_ERROR,
245                         _("Monitor path %s too big for destination"), monitor);
246         goto error;
247     }
248
249     do {
250         ret = connect(monfd, (struct sockaddr *) &addr, sizeof(addr));
251
252         if (ret == 0)
253             break;
254
255         if (errno == ENOENT || errno == ECONNREFUSED) {
256             /* ENOENT       : Socket may not have shown up yet
257              * ECONNREFUSED : Leftover socket hasn't been removed yet */
258             continue;
259         }
260
261         virReportSystemError(errno, "%s",
262                              _("failed to connect to monitor socket"));
263         goto error;
264
265     } while ((++i <= timeout*5) && (usleep(.2 * 1000000) <= 0));
266
267     if (ret != 0) {
268         virReportSystemError(errno, "%s",
269                              _("monitor socket did not show up."));
270         goto error;
271     }
272
273     return monfd;
274
275 error:
276     close(monfd);
277     return -1;
278 }
279
280 static int
281 qemuMonitorOpenPty(const char *monitor)
282 {
283     int monfd;
284
285     if ((monfd = open(monitor, O_RDWR)) < 0) {
286         qemuReportError(VIR_ERR_INTERNAL_ERROR,
287                         _("Unable to open monitor path %s"), monitor);
288         return -1;
289     }
290
291     return monfd;
292 }
293
294
295 static int
296 qemuMonitorIOProcess(qemuMonitorPtr mon)
297 {
298     int len;
299     qemuMonitorMessagePtr msg = NULL;
300
301     /* See if there's a message & whether its ready for its reply
302      * ie whether its completed writing all its data */
303     if (mon->msg && mon->msg->txOffset == mon->msg->txLength)
304         msg = mon->msg;
305
306 #if DEBUG_IO
307 # if DEBUG_RAW_IO
308     char *str1 = qemuMonitorEscapeNonPrintable(msg ? msg->txBuffer : "");
309     char *str2 = qemuMonitorEscapeNonPrintable(mon->buffer);
310     VIR_ERROR("Process %d %p %p [[[[%s]]][[[%s]]]", (int)mon->bufferOffset, mon->msg, msg, str1, str2);
311     VIR_FREE(str1);
312     VIR_FREE(str2);
313 # else
314     VIR_DEBUG("Process %d", (int)mon->bufferOffset);
315 # endif
316 #endif
317
318     if (mon->json)
319         len = qemuMonitorJSONIOProcess(mon,
320                                        mon->buffer, mon->bufferOffset,
321                                        msg);
322     else
323         len = qemuMonitorTextIOProcess(mon,
324                                        mon->buffer, mon->bufferOffset,
325                                        msg);
326
327     if (len < 0) {
328         mon->lastErrno = errno;
329         return -1;
330     }
331
332     if (len < mon->bufferOffset) {
333         memmove(mon->buffer, mon->buffer + len, mon->bufferOffset - len);
334         mon->bufferOffset -= len;
335     } else {
336         VIR_FREE(mon->buffer);
337         mon->bufferOffset = mon->bufferLength = 0;
338     }
339 #if DEBUG_IO
340     VIR_DEBUG("Process done %d used %d", (int)mon->bufferOffset, len);
341 #endif
342     if (msg && msg->finished)
343         virCondBroadcast(&mon->notify);
344     return len;
345 }
346
347
348 static int
349 qemuMonitorIOWriteWithFD(qemuMonitorPtr mon,
350                          const char *data,
351                          size_t len,
352                          int fd)
353 {
354     struct msghdr msg;
355     struct iovec iov[1];
356     int ret;
357     char control[CMSG_SPACE(sizeof(int))];
358     struct cmsghdr *cmsg;
359
360     if (!mon->hasSendFD) {
361         errno = EINVAL;
362         return -1;
363     }
364
365     memset(&msg, 0, sizeof(msg));
366
367     iov[0].iov_base = (void *)data;
368     iov[0].iov_len = len;
369
370     msg.msg_iov = iov;
371     msg.msg_iovlen = 1;
372
373     msg.msg_control = control;
374     msg.msg_controllen = sizeof(control);
375
376     cmsg = CMSG_FIRSTHDR(&msg);
377     cmsg->cmsg_len = CMSG_LEN(sizeof(int));
378     cmsg->cmsg_level = SOL_SOCKET;
379     cmsg->cmsg_type = SCM_RIGHTS;
380     memcpy(CMSG_DATA(cmsg), &fd, sizeof(int));
381
382     do {
383         ret = sendmsg(mon->fd, &msg, 0);
384     } while (ret < 0 && errno == EINTR);
385
386     return ret;
387 }
388
389 /* Called when the monitor is able to write data */
390 static int
391 qemuMonitorIOWrite(qemuMonitorPtr mon)
392 {
393     int done;
394
395     /* If no active message, or fully transmitted, the no-op */
396     if (!mon->msg || mon->msg->txOffset == mon->msg->txLength)
397         return 0;
398
399     if (mon->msg->txFD == -1)
400         done = write(mon->fd,
401                      mon->msg->txBuffer + mon->msg->txOffset,
402                      mon->msg->txLength - mon->msg->txOffset);
403     else
404         done = qemuMonitorIOWriteWithFD(mon,
405                                         mon->msg->txBuffer + mon->msg->txOffset,
406                                         mon->msg->txLength - mon->msg->txOffset,
407                                         mon->msg->txFD);
408
409     if (done < 0) {
410         if (errno == EAGAIN)
411             return 0;
412
413         mon->lastErrno = errno;
414         return -1;
415     }
416     mon->msg->txOffset += done;
417     return done;
418 }
419
420 /*
421  * Called when the monitor has incoming data to read
422  *
423  * Returns -1 on error, or number of bytes read
424  */
425 static int
426 qemuMonitorIORead(qemuMonitorPtr mon)
427 {
428     size_t avail = mon->bufferLength - mon->bufferOffset;
429     int ret = 0;
430
431     if (avail < 1024) {
432         if (VIR_REALLOC_N(mon->buffer,
433                           mon->bufferLength + 1024) < 0) {
434             errno = ENOMEM;
435             return -1;
436         }
437         mon->bufferLength += 1024;
438         avail += 1024;
439     }
440
441     /* Read as much as we can get into our buffer,
442        until we block on EAGAIN, or hit EOF */
443     while (avail > 1) {
444         int got;
445         got = read(mon->fd,
446                    mon->buffer + mon->bufferOffset,
447                    avail - 1);
448         if (got < 0) {
449             if (errno == EAGAIN)
450                 break;
451             mon->lastErrno = errno;
452             ret = -1;
453             break;
454         }
455         if (got == 0)
456             break;
457
458         ret += got;
459         avail -= got;
460         mon->bufferOffset += got;
461         mon->buffer[mon->bufferOffset] = '\0';
462     }
463
464 #if DEBUG_IO
465     VIR_DEBUG("Now read %d bytes of data", (int)mon->bufferOffset);
466 #endif
467
468     return ret;
469 }
470
471
472 static void qemuMonitorUpdateWatch(qemuMonitorPtr mon)
473 {
474     int events =
475         VIR_EVENT_HANDLE_HANGUP |
476         VIR_EVENT_HANDLE_ERROR;
477
478     if (!mon->lastErrno) {
479         events |= VIR_EVENT_HANDLE_READABLE;
480
481         if (mon->msg && mon->msg->txOffset < mon->msg->txLength)
482             events |= VIR_EVENT_HANDLE_WRITABLE;
483     }
484
485     virEventUpdateHandle(mon->watch, events);
486 }
487
488
489 static void
490 qemuMonitorIO(int watch, int fd, int events, void *opaque) {
491     qemuMonitorPtr mon = opaque;
492     int quit = 0, failed = 0;
493
494     qemuMonitorLock(mon);
495     qemuMonitorRef(mon);
496 #if DEBUG_IO
497     VIR_DEBUG("Monitor %p I/O on watch %d fd %d events %d", mon, watch, fd, events);
498 #endif
499
500     if (mon->fd != fd || mon->watch != watch) {
501         VIR_ERROR("event from unexpected fd %d!=%d / watch %d!=%d", mon->fd, fd, mon->watch, watch);
502         failed = 1;
503     } else {
504         if (!mon->lastErrno &&
505             events & VIR_EVENT_HANDLE_WRITABLE) {
506             int done = qemuMonitorIOWrite(mon);
507             if (done < 0)
508                 failed = 1;
509             events &= ~VIR_EVENT_HANDLE_WRITABLE;
510         }
511         if (!mon->lastErrno &&
512             events & VIR_EVENT_HANDLE_READABLE) {
513             int got = qemuMonitorIORead(mon);
514             if (got < 0)
515                 failed = 1;
516             /* Ignore hangup/error events if we read some data, to
517              * give time for that data to be consumed */
518             if (got > 0) {
519                 events = 0;
520
521                 if (qemuMonitorIOProcess(mon) < 0)
522                     failed = 1;
523             } else
524                 events &= ~VIR_EVENT_HANDLE_READABLE;
525         }
526
527         /* If IO process resulted in an error & we have a message,
528          * then wakeup that waiter */
529         if (mon->lastErrno && mon->msg && !mon->msg->finished) {
530             mon->msg->lastErrno = mon->lastErrno;
531             mon->msg->finished = 1;
532             virCondSignal(&mon->notify);
533         }
534
535         qemuMonitorUpdateWatch(mon);
536
537         if (events & VIR_EVENT_HANDLE_HANGUP) {
538             /* If IO process resulted in EOF & we have a message,
539              * then wakeup that waiter */
540             if (mon->msg && !mon->msg->finished) {
541                 mon->msg->finished = 1;
542                 mon->msg->lastErrno = EIO;
543                 virCondSignal(&mon->notify);
544             }
545             quit = 1;
546         } else if (events) {
547             VIR_ERROR(_("unhandled fd event %d for monitor fd %d"),
548                       events, mon->fd);
549             failed = 1;
550         }
551     }
552
553     /* We have to unlock to avoid deadlock against command thread,
554      * but is this safe ?  I think it is, because the callback
555      * will try to acquire the virDomainObjPtr mutex next */
556     if (failed || quit) {
557         void (*eofNotify)(qemuMonitorPtr, virDomainObjPtr, int)
558             = mon->cb->eofNotify;
559         virDomainObjPtr vm = mon->vm;
560         /* Make sure anyone waiting wakes up now */
561         virCondSignal(&mon->notify);
562         if (qemuMonitorUnref(mon) > 0)
563             qemuMonitorUnlock(mon);
564         VIR_DEBUG("Triggering EOF callback error? %d", failed);
565         (eofNotify)(mon, vm, failed);
566     } else {
567         if (qemuMonitorUnref(mon) > 0)
568             qemuMonitorUnlock(mon);
569     }
570 }
571
572
573 qemuMonitorPtr
574 qemuMonitorOpen(virDomainObjPtr vm,
575                 virDomainChrDefPtr config,
576                 int json,
577                 qemuMonitorCallbacksPtr cb)
578 {
579     qemuMonitorPtr mon;
580
581     if (!cb || !cb->eofNotify) {
582         qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
583                         _("EOF notify callback must be supplied"));
584         return NULL;
585     }
586
587     if (VIR_ALLOC(mon) < 0) {
588         virReportOOMError();
589         return NULL;
590     }
591
592     if (virMutexInit(&mon->lock) < 0) {
593         qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
594                         _("cannot initialize monitor mutex"));
595         VIR_FREE(mon);
596         return NULL;
597     }
598     if (virCondInit(&mon->notify) < 0) {
599         qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
600                         _("cannot initialize monitor condition"));
601         virMutexDestroy(&mon->lock);
602         VIR_FREE(mon);
603         return NULL;
604     }
605     mon->fd = -1;
606     mon->refs = 1;
607     mon->vm = vm;
608     mon->json = json;
609     mon->cb = cb;
610     qemuMonitorLock(mon);
611
612     switch (config->type) {
613     case VIR_DOMAIN_CHR_TYPE_UNIX:
614         mon->hasSendFD = 1;
615         mon->fd = qemuMonitorOpenUnix(config->data.nix.path);
616         break;
617
618     case VIR_DOMAIN_CHR_TYPE_PTY:
619         mon->fd = qemuMonitorOpenPty(config->data.file.path);
620         break;
621
622     default:
623         qemuReportError(VIR_ERR_INTERNAL_ERROR,
624                         _("unable to handle monitor type: %s"),
625                         virDomainChrTypeToString(config->type));
626         goto cleanup;
627     }
628
629     if (mon->fd == -1) goto cleanup;
630
631     if (virSetCloseExec(mon->fd) < 0) {
632         qemuReportError(VIR_ERR_INTERNAL_ERROR,
633                         "%s", _("Unable to set monitor close-on-exec flag"));
634         goto cleanup;
635     }
636     if (virSetNonBlock(mon->fd) < 0) {
637         qemuReportError(VIR_ERR_INTERNAL_ERROR,
638                         "%s", _("Unable to put monitor into non-blocking mode"));
639         goto cleanup;
640     }
641
642
643     if ((mon->watch = virEventAddHandle(mon->fd,
644                                         VIR_EVENT_HANDLE_HANGUP |
645                                         VIR_EVENT_HANDLE_ERROR |
646                                         VIR_EVENT_HANDLE_READABLE,
647                                         qemuMonitorIO,
648                                         mon, NULL)) < 0) {
649         qemuReportError(VIR_ERR_INTERNAL_ERROR, "%s",
650                         _("unable to register monitor events"));
651         goto cleanup;
652     }
653
654     VIR_DEBUG("New mon %p fd =%d watch=%d", mon, mon->fd, mon->watch);
655     qemuMonitorUnlock(mon);
656
657     return mon;
658
659 cleanup:
660     qemuMonitorUnlock(mon);
661     qemuMonitorClose(mon);
662     return NULL;
663 }
664
665
666 int qemuMonitorClose(qemuMonitorPtr mon)
667 {
668     int refs;
669
670     if (!mon)
671         return 0;
672
673     VIR_DEBUG("mon=%p", mon);
674
675     qemuMonitorLock(mon);
676     if (!mon->closed) {
677         if (mon->watch)
678             virEventRemoveHandle(mon->watch);
679         if (mon->fd != -1)
680             close(mon->fd);
681         /* NB: ordinarily one might immediately set mon->watch to -1
682          * and mon->fd to -1, but there may be a callback active
683          * that is still relying on these fields being valid. So
684          * we merely close them, but not clear their values and
685          * use this explicit 'closed' flag to track this state */
686         mon->closed = 1;
687     }
688
689     if ((refs = qemuMonitorUnref(mon)) > 0)
690         qemuMonitorUnlock(mon);
691     return refs;
692 }
693
694
695 int qemuMonitorSend(qemuMonitorPtr mon,
696                     qemuMonitorMessagePtr msg)
697 {
698     int ret = -1;
699
700     if (mon->eofcb) {
701         msg->lastErrno = EIO;
702         return -1;
703     }
704
705     mon->msg = msg;
706     qemuMonitorUpdateWatch(mon);
707
708     while (!mon->msg->finished) {
709         if (virCondWait(&mon->notify, &mon->lock) < 0)
710             goto cleanup;
711     }
712
713     if (mon->lastErrno == 0)
714         ret = 0;
715
716 cleanup:
717     mon->msg = NULL;
718     qemuMonitorUpdateWatch(mon);
719
720     return ret;
721 }
722
723
724 int qemuMonitorGetDiskSecret(qemuMonitorPtr mon,
725                              virConnectPtr conn,
726                              const char *path,
727                              char **secret,
728                              size_t *secretLen)
729 {
730     int ret = -1;
731     *secret = NULL;
732     *secretLen = 0;
733
734     qemuMonitorRef(mon);
735     qemuMonitorUnlock(mon);
736     if (mon->cb && mon->cb->diskSecretLookup)
737         ret = mon->cb->diskSecretLookup(mon, conn, mon->vm, path, secret, secretLen);
738     qemuMonitorLock(mon);
739     qemuMonitorUnref(mon);
740     return ret;
741 }
742
743
744 int qemuMonitorEmitShutdown(qemuMonitorPtr mon)
745 {
746     int ret = -1;
747     VIR_DEBUG("mon=%p", mon);
748
749     qemuMonitorRef(mon);
750     qemuMonitorUnlock(mon);
751     if (mon->cb && mon->cb->domainShutdown)
752         ret = mon->cb->domainShutdown(mon, mon->vm);
753     qemuMonitorLock(mon);
754     qemuMonitorUnref(mon);
755     return ret;
756 }
757
758
759 int qemuMonitorEmitReset(qemuMonitorPtr mon)
760 {
761     int ret = -1;
762     VIR_DEBUG("mon=%p", mon);
763
764     qemuMonitorRef(mon);
765     qemuMonitorUnlock(mon);
766     if (mon->cb && mon->cb->domainReset)
767         ret = mon->cb->domainReset(mon, mon->vm);
768     qemuMonitorLock(mon);
769     qemuMonitorUnref(mon);
770     return ret;
771 }
772
773
774 int qemuMonitorEmitPowerdown(qemuMonitorPtr mon)
775 {
776     int ret = -1;
777     VIR_DEBUG("mon=%p", mon);
778
779     qemuMonitorRef(mon);
780     qemuMonitorUnlock(mon);
781     if (mon->cb && mon->cb->domainPowerdown)
782         ret = mon->cb->domainPowerdown(mon, mon->vm);
783     qemuMonitorLock(mon);
784     qemuMonitorUnref(mon);
785     return ret;
786 }
787
788
789 int qemuMonitorEmitStop(qemuMonitorPtr mon)
790 {
791     int ret = -1;
792     VIR_DEBUG("mon=%p", mon);
793
794     qemuMonitorRef(mon);
795     qemuMonitorUnlock(mon);
796     if (mon->cb && mon->cb->domainStop)
797         ret = mon->cb->domainStop(mon, mon->vm);
798     qemuMonitorLock(mon);
799     qemuMonitorUnref(mon);
800     return ret;
801 }
802
803
804 int qemuMonitorEmitRTCChange(qemuMonitorPtr mon, long long offset)
805 {
806     int ret = -1;
807     VIR_DEBUG("mon=%p", mon);
808
809     qemuMonitorRef(mon);
810     qemuMonitorUnlock(mon);
811     if (mon->cb && mon->cb->domainRTCChange)
812         ret = mon->cb->domainRTCChange(mon, mon->vm, offset);
813     qemuMonitorLock(mon);
814     qemuMonitorUnref(mon);
815     return ret;
816 }
817
818
819 int qemuMonitorEmitWatchdog(qemuMonitorPtr mon, int action)
820 {
821     int ret = -1;
822     VIR_DEBUG("mon=%p", mon);
823
824     qemuMonitorRef(mon);
825     qemuMonitorUnlock(mon);
826     if (mon->cb && mon->cb->domainWatchdog)
827         ret = mon->cb->domainWatchdog(mon, mon->vm, action);
828     qemuMonitorLock(mon);
829     qemuMonitorUnref(mon);
830     return ret;
831 }
832
833
834 int qemuMonitorEmitIOError(qemuMonitorPtr mon,
835                            const char *diskAlias,
836                            int action)
837 {
838     int ret = -1;
839     VIR_DEBUG("mon=%p", mon);
840
841     qemuMonitorRef(mon);
842     qemuMonitorUnlock(mon);
843     if (mon->cb && mon->cb->domainIOError)
844         ret = mon->cb->domainIOError(mon, mon->vm, diskAlias, action);
845     qemuMonitorLock(mon);
846     qemuMonitorUnref(mon);
847     return ret;
848 }
849
850
851 int qemuMonitorEmitGraphics(qemuMonitorPtr mon,
852                             int phase,
853                             int localFamily,
854                             const char *localNode,
855                             const char *localService,
856                             int remoteFamily,
857                             const char *remoteNode,
858                             const char *remoteService,
859                             const char *authScheme,
860                             const char *x509dname,
861                             const char *saslUsername)
862 {
863     int ret = -1;
864     VIR_DEBUG("mon=%p", mon);
865
866     qemuMonitorRef(mon);
867     qemuMonitorUnlock(mon);
868     if (mon->cb && mon->cb->domainGraphics)
869         ret = mon->cb->domainGraphics(mon, mon->vm,
870                                       phase,
871                                       localFamily, localNode, localService,
872                                       remoteFamily, remoteNode, remoteService,
873                                       authScheme, x509dname, saslUsername);
874     qemuMonitorLock(mon);
875     qemuMonitorUnref(mon);
876     return ret;
877 }
878
879
880
881 int qemuMonitorSetCapabilities(qemuMonitorPtr mon)
882 {
883     int ret;
884     DEBUG("mon=%p, fd=%d", mon, mon->fd);
885
886     if (mon->json)
887         ret = qemuMonitorJSONSetCapabilities(mon);
888     else
889         ret = 0;
890     return ret;
891 }
892
893
894 int
895 qemuMonitorStartCPUs(qemuMonitorPtr mon,
896                      virConnectPtr conn)
897 {
898     int ret;
899     DEBUG("mon=%p, fd=%d", mon, mon->fd);
900
901     if (mon->json)
902         ret = qemuMonitorJSONStartCPUs(mon, conn);
903     else
904         ret = qemuMonitorTextStartCPUs(mon, conn);
905     return ret;
906 }
907
908
909 int
910 qemuMonitorStopCPUs(qemuMonitorPtr mon)
911 {
912     int ret;
913     DEBUG("mon=%p, fd=%d", mon, mon->fd);
914
915     if (mon->json)
916         ret = qemuMonitorJSONStopCPUs(mon);
917     else
918         ret = qemuMonitorTextStopCPUs(mon);
919     return ret;
920 }
921
922
923 int qemuMonitorSystemPowerdown(qemuMonitorPtr mon)
924 {
925     int ret;
926     DEBUG("mon=%p, fd=%d", mon, mon->fd);
927
928     if (mon->json)
929         ret = qemuMonitorJSONSystemPowerdown(mon);
930     else
931         ret = qemuMonitorTextSystemPowerdown(mon);
932     return ret;
933 }
934
935
936 int qemuMonitorGetCPUInfo(qemuMonitorPtr mon,
937                           int **pids)
938 {
939     int ret;
940     DEBUG("mon=%p, fd=%d", mon, mon->fd);
941
942     if (mon->json)
943         ret = qemuMonitorJSONGetCPUInfo(mon, pids);
944     else
945         ret = qemuMonitorTextGetCPUInfo(mon, pids);
946     return ret;
947 }
948
949 int qemuMonitorGetBalloonInfo(qemuMonitorPtr mon,
950                               unsigned long *currmem)
951 {
952     int ret;
953     DEBUG("mon=%p, fd=%d", mon, mon->fd);
954
955     if (mon->json)
956         ret = qemuMonitorJSONGetBalloonInfo(mon, currmem);
957     else
958         ret = qemuMonitorTextGetBalloonInfo(mon, currmem);
959     return ret;
960 }
961
962
963 int qemuMonitorGetMemoryStats(qemuMonitorPtr mon,
964                               virDomainMemoryStatPtr stats,
965                               unsigned int nr_stats)
966 {
967     int ret;
968     DEBUG("mon=%p, fd=%d stats=%p nstats=%u", mon, mon->fd, stats, nr_stats);
969
970     if (mon->json)
971         ret = qemuMonitorJSONGetMemoryStats(mon, stats, nr_stats);
972     else
973         ret = qemuMonitorTextGetMemoryStats(mon, stats, nr_stats);
974     return ret;
975 }
976
977
978 int qemuMonitorGetBlockStatsInfo(qemuMonitorPtr mon,
979                                  const char *devname,
980                                  long long *rd_req,
981                                  long long *rd_bytes,
982                                  long long *wr_req,
983                                  long long *wr_bytes,
984                                  long long *errs)
985 {
986     int ret;
987     DEBUG("mon=%p, fd=%d dev=%s", mon, mon->fd, devname);
988
989     if (mon->json)
990         ret = qemuMonitorJSONGetBlockStatsInfo(mon, devname,
991                                                rd_req, rd_bytes,
992                                                wr_req, wr_bytes,
993                                                errs);
994     else
995         ret = qemuMonitorTextGetBlockStatsInfo(mon, devname,
996                                                rd_req, rd_bytes,
997                                                wr_req, wr_bytes,
998                                                errs);
999     return ret;
1000 }
1001
1002
1003 int qemuMonitorSetVNCPassword(qemuMonitorPtr mon,
1004                               const char *password)
1005 {
1006     int ret;
1007     DEBUG("mon=%p, fd=%d", mon, mon->fd);
1008
1009     if (!password)
1010         password = "";
1011
1012     if (mon->json)
1013         ret = qemuMonitorJSONSetVNCPassword(mon, password);
1014     else
1015         ret = qemuMonitorTextSetVNCPassword(mon, password);
1016     return ret;
1017 }
1018
1019
1020 int qemuMonitorSetBalloon(qemuMonitorPtr mon,
1021                           unsigned long newmem)
1022 {
1023     int ret;
1024     DEBUG("mon=%p, fd=%d newmem=%lu", mon, mon->fd, newmem);
1025
1026     if (mon->json)
1027         ret = qemuMonitorJSONSetBalloon(mon, newmem);
1028     else
1029         ret = qemuMonitorTextSetBalloon(mon, newmem);
1030     return ret;
1031 }
1032
1033
1034 int qemuMonitorSetCPU(qemuMonitorPtr mon, int cpu, int online)
1035 {
1036     int ret;
1037     DEBUG("mon=%p, fd=%d cpu=%d online=%d", mon, mon->fd, cpu, online);
1038
1039     if (mon->json)
1040         ret = qemuMonitorJSONSetCPU(mon, cpu, online);
1041     else
1042         ret = qemuMonitorTextSetCPU(mon, cpu, online);
1043     return ret;
1044 }
1045
1046
1047 int qemuMonitorEjectMedia(qemuMonitorPtr mon,
1048                           const char *devname)
1049 {
1050     int ret;
1051     DEBUG("mon=%p, fd=%d devname=%s", mon, mon->fd, devname);
1052
1053     if (mon->json)
1054         ret = qemuMonitorJSONEjectMedia(mon, devname);
1055     else
1056         ret = qemuMonitorTextEjectMedia(mon, devname);
1057     return ret;
1058 }
1059
1060
1061 int qemuMonitorChangeMedia(qemuMonitorPtr mon,
1062                            const char *devname,
1063                            const char *newmedia,
1064                            const char *format)
1065 {
1066     int ret;
1067     DEBUG("mon=%p, fd=%d devname=%s newmedia=%s format=%s",
1068           mon, mon->fd, devname, newmedia, format);
1069
1070     if (mon->json)
1071         ret = qemuMonitorJSONChangeMedia(mon, devname, newmedia, format);
1072     else
1073         ret = qemuMonitorTextChangeMedia(mon, devname, newmedia, format);
1074     return ret;
1075 }
1076
1077
1078 int qemuMonitorSaveVirtualMemory(qemuMonitorPtr mon,
1079                                  unsigned long long offset,
1080                                  size_t length,
1081                                  const char *path)
1082 {
1083     int ret;
1084     DEBUG("mon=%p, fd=%d offset=%llu length=%zu path=%s",
1085           mon, mon->fd, offset, length, path);
1086
1087     if (mon->json)
1088         ret = qemuMonitorJSONSaveVirtualMemory(mon, offset, length, path);
1089     else
1090         ret = qemuMonitorTextSaveVirtualMemory(mon, offset, length, path);
1091     return ret;
1092 }
1093
1094 int qemuMonitorSavePhysicalMemory(qemuMonitorPtr mon,
1095                                   unsigned long long offset,
1096                                   size_t length,
1097                                   const char *path)
1098 {
1099     int ret;
1100     DEBUG("mon=%p, fd=%d offset=%llu length=%zu path=%s",
1101           mon, mon->fd, offset, length, path);
1102
1103     if (mon->json)
1104         ret = qemuMonitorJSONSavePhysicalMemory(mon, offset, length, path);
1105     else
1106         ret = qemuMonitorTextSavePhysicalMemory(mon, offset, length, path);
1107     return ret;
1108 }
1109
1110
1111 int qemuMonitorSetMigrationSpeed(qemuMonitorPtr mon,
1112                                  unsigned long bandwidth)
1113 {
1114     int ret;
1115     DEBUG("mon=%p, fd=%d bandwidth=%lu", mon, mon->fd, bandwidth);
1116
1117     if (mon->json)
1118         ret = qemuMonitorJSONSetMigrationSpeed(mon, bandwidth);
1119     else
1120         ret = qemuMonitorTextSetMigrationSpeed(mon, bandwidth);
1121     return ret;
1122 }
1123
1124
1125 int qemuMonitorSetMigrationDowntime(qemuMonitorPtr mon,
1126                                     unsigned long long downtime)
1127 {
1128     int ret;
1129     DEBUG("mon=%p, fd=%d downtime=%llu", mon, mon->fd, downtime);
1130
1131     if (mon->json)
1132         ret = qemuMonitorJSONSetMigrationDowntime(mon, downtime);
1133     else
1134         ret = qemuMonitorTextSetMigrationDowntime(mon, downtime);
1135     return ret;
1136 }
1137
1138
1139 int qemuMonitorGetMigrationStatus(qemuMonitorPtr mon,
1140                                   int *status,
1141                                   unsigned long long *transferred,
1142                                   unsigned long long *remaining,
1143                                   unsigned long long *total)
1144 {
1145     int ret;
1146     DEBUG("mon=%p, fd=%d", mon, mon->fd);
1147
1148     if (mon->json)
1149         ret = qemuMonitorJSONGetMigrationStatus(mon, status,
1150                                                 transferred,
1151                                                 remaining,
1152                                                 total);
1153     else
1154         ret = qemuMonitorTextGetMigrationStatus(mon, status,
1155                                                 transferred,
1156                                                 remaining,
1157                                                 total);
1158     return ret;
1159 }
1160
1161
1162 int qemuMonitorMigrateToHost(qemuMonitorPtr mon,
1163                              int background,
1164                              const char *hostname,
1165                              int port)
1166 {
1167     int ret;
1168     DEBUG("mon=%p, fd=%d hostname=%s port=%d",
1169           mon, mon->fd, hostname, port);
1170
1171     if (mon->json)
1172         ret = qemuMonitorJSONMigrateToHost(mon, background, hostname, port);
1173     else
1174         ret = qemuMonitorTextMigrateToHost(mon, background, hostname, port);
1175     return ret;
1176 }
1177
1178
1179 int qemuMonitorMigrateToCommand(qemuMonitorPtr mon,
1180                                 int background,
1181                                 const char * const *argv,
1182                                 const char *target)
1183 {
1184     int ret;
1185     DEBUG("mon=%p, fd=%d argv=%p target=%s",
1186           mon, mon->fd, argv, target);
1187
1188     if (mon->json)
1189         ret = qemuMonitorJSONMigrateToCommand(mon, background, argv, target);
1190     else
1191         ret = qemuMonitorTextMigrateToCommand(mon, background, argv, target);
1192     return ret;
1193 }
1194
1195 int qemuMonitorMigrateToUnix(qemuMonitorPtr mon,
1196                              int background,
1197                              const char *unixfile)
1198 {
1199     int ret;
1200     DEBUG("mon=%p fd=%d unixfile=%s",
1201           mon, mon->fd, unixfile);
1202
1203     if (mon->json)
1204         ret = qemuMonitorJSONMigrateToUnix(mon, background, unixfile);
1205     else
1206         ret = qemuMonitorTextMigrateToUnix(mon, background, unixfile);
1207     return ret;
1208 }
1209
1210 int qemuMonitorMigrateCancel(qemuMonitorPtr mon)
1211 {
1212     int ret;
1213     DEBUG("mon=%p fd=%d", mon, mon->fd);
1214
1215     if (mon->json)
1216         ret = qemuMonitorJSONMigrateCancel(mon);
1217     else
1218         ret = qemuMonitorTextMigrateCancel(mon);
1219     return ret;
1220 }
1221
1222 int qemuMonitorAddUSBDisk(qemuMonitorPtr mon,
1223                           const char *path)
1224 {
1225     int ret;
1226     DEBUG("mon=%p, fd=%d path=%s", mon, mon->fd, path);
1227
1228     if (mon->json)
1229         ret = qemuMonitorJSONAddUSBDisk(mon, path);
1230     else
1231         ret = qemuMonitorTextAddUSBDisk(mon, path);
1232     return ret;
1233 }
1234
1235
1236 int qemuMonitorAddUSBDeviceExact(qemuMonitorPtr mon,
1237                                  int bus,
1238                                  int dev)
1239 {
1240     int ret;
1241     DEBUG("mon=%p, fd=%d bus=%d dev=%d", mon, mon->fd, bus, dev);
1242
1243     if (mon->json)
1244         ret = qemuMonitorJSONAddUSBDeviceExact(mon, bus, dev);
1245     else
1246         ret = qemuMonitorTextAddUSBDeviceExact(mon, bus, dev);
1247     return ret;
1248 }
1249
1250 int qemuMonitorAddUSBDeviceMatch(qemuMonitorPtr mon,
1251                                  int vendor,
1252                                  int product)
1253 {
1254     int ret;
1255     DEBUG("mon=%p, fd=%d vendor=%d product=%d",
1256           mon, mon->fd, vendor, product);
1257
1258     if (mon->json)
1259         ret = qemuMonitorJSONAddUSBDeviceMatch(mon, vendor, product);
1260     else
1261         ret = qemuMonitorTextAddUSBDeviceMatch(mon, vendor, product);
1262     return ret;
1263 }
1264
1265
1266 int qemuMonitorAddPCIHostDevice(qemuMonitorPtr mon,
1267                                 virDomainDevicePCIAddress *hostAddr,
1268                                 virDomainDevicePCIAddress *guestAddr)
1269 {
1270     int ret;
1271     DEBUG("mon=%p, fd=%d domain=%d bus=%d slot=%d function=%d",
1272           mon, mon->fd,
1273           hostAddr->domain, hostAddr->bus, hostAddr->slot, hostAddr->function);
1274
1275     if (mon->json)
1276         ret = qemuMonitorJSONAddPCIHostDevice(mon, hostAddr, guestAddr);
1277     else
1278         ret = qemuMonitorTextAddPCIHostDevice(mon, hostAddr, guestAddr);
1279     return ret;
1280 }
1281
1282
1283 int qemuMonitorAddPCIDisk(qemuMonitorPtr mon,
1284                           const char *path,
1285                           const char *bus,
1286                           virDomainDevicePCIAddress *guestAddr)
1287 {
1288     int ret;
1289     DEBUG("mon=%p, fd=%d path=%s bus=%s",
1290           mon, mon->fd, path, bus);
1291
1292     if (mon->json)
1293         ret = qemuMonitorJSONAddPCIDisk(mon, path, bus, guestAddr);
1294     else
1295         ret = qemuMonitorTextAddPCIDisk(mon, path, bus, guestAddr);
1296     return ret;
1297 }
1298
1299
1300 int qemuMonitorAddPCINetwork(qemuMonitorPtr mon,
1301                              const char *nicstr,
1302                              virDomainDevicePCIAddress *guestAddr)
1303 {
1304     int ret;
1305     DEBUG("mon=%p, fd=%d nicstr=%s", mon, mon->fd, nicstr);
1306
1307     if (mon->json)
1308         ret = qemuMonitorJSONAddPCINetwork(mon, nicstr, guestAddr);
1309     else
1310         ret = qemuMonitorTextAddPCINetwork(mon, nicstr, guestAddr);
1311     return ret;
1312 }
1313
1314
1315 int qemuMonitorRemovePCIDevice(qemuMonitorPtr mon,
1316                                virDomainDevicePCIAddress *guestAddr)
1317 {
1318     int ret;
1319     DEBUG("mon=%p, fd=%d domain=%d bus=%d slot=%d function=%d",
1320           mon, mon->fd, guestAddr->domain, guestAddr->bus,
1321           guestAddr->slot, guestAddr->function);
1322
1323     if (mon->json)
1324         ret = qemuMonitorJSONRemovePCIDevice(mon, guestAddr);
1325     else
1326         ret = qemuMonitorTextRemovePCIDevice(mon, guestAddr);
1327     return ret;
1328 }
1329
1330
1331 int qemuMonitorSendFileHandle(qemuMonitorPtr mon,
1332                               const char *fdname,
1333                               int fd)
1334 {
1335     int ret;
1336     DEBUG("mon=%p, fd=%d fdname=%s fd=%d",
1337           mon, mon->fd, fdname, fd);
1338
1339     if (mon->json)
1340         ret = qemuMonitorJSONSendFileHandle(mon, fdname, fd);
1341     else
1342         ret = qemuMonitorTextSendFileHandle(mon, fdname, fd);
1343     return ret;
1344 }
1345
1346
1347 int qemuMonitorCloseFileHandle(qemuMonitorPtr mon,
1348                                const char *fdname)
1349 {
1350     int ret;
1351     DEBUG("mon=%p, fd=%d fdname=%s",
1352           mon, mon->fd, fdname);
1353
1354     if (mon->json)
1355         ret = qemuMonitorJSONCloseFileHandle(mon, fdname);
1356     else
1357         ret = qemuMonitorTextCloseFileHandle(mon, fdname);
1358     return ret;
1359 }
1360
1361
1362 int qemuMonitorAddHostNetwork(qemuMonitorPtr mon,
1363                               const char *netstr)
1364 {
1365     int ret;
1366     DEBUG("mon=%p, fd=%d netstr=%s",
1367           mon, mon->fd, netstr);
1368
1369     if (mon->json)
1370         ret = qemuMonitorJSONAddHostNetwork(mon, netstr);
1371     else
1372         ret = qemuMonitorTextAddHostNetwork(mon, netstr);
1373     return ret;
1374 }
1375
1376
1377 int qemuMonitorRemoveHostNetwork(qemuMonitorPtr mon,
1378                                  int vlan,
1379                                  const char *netname)
1380 {
1381     int ret;
1382     DEBUG("mon=%p, fd=%d netname=%s",
1383           mon, mon->fd, netname);
1384
1385     if (mon->json)
1386         ret = qemuMonitorJSONRemoveHostNetwork(mon, vlan, netname);
1387     else
1388         ret = qemuMonitorTextRemoveHostNetwork(mon, vlan, netname);
1389     return ret;
1390 }
1391
1392 int qemuMonitorGetPtyPaths(qemuMonitorPtr mon,
1393                            virHashTablePtr paths)
1394 {
1395     int ret;
1396     DEBUG("mon=%p, fd=%d",
1397           mon, mon->fd);
1398
1399     if (mon->json)
1400         ret = qemuMonitorJSONGetPtyPaths(mon, paths);
1401     else
1402         ret = qemuMonitorTextGetPtyPaths(mon, paths);
1403     return ret;
1404 }
1405
1406
1407 int qemuMonitorAttachPCIDiskController(qemuMonitorPtr mon,
1408                                        const char *bus,
1409                                        virDomainDevicePCIAddress *guestAddr)
1410 {
1411     DEBUG("mon=%p, fd=%d type=%s", mon, mon->fd, bus);
1412     int ret;
1413
1414     if (mon->json)
1415         ret = qemuMonitorJSONAttachPCIDiskController(mon, bus, guestAddr);
1416     else
1417         ret = qemuMonitorTextAttachPCIDiskController(mon, bus, guestAddr);
1418
1419     return ret;
1420 }
1421
1422
1423 int qemuMonitorAttachDrive(qemuMonitorPtr mon,
1424                            const char *drivestr,
1425                            virDomainDevicePCIAddress *controllerAddr,
1426                            virDomainDeviceDriveAddress *driveAddr)
1427 {
1428     DEBUG("mon=%p, fd=%d drivestr=%s domain=%d bus=%d slot=%d function=%d",
1429           mon, mon->fd, drivestr,
1430           controllerAddr->domain, controllerAddr->bus,
1431           controllerAddr->slot, controllerAddr->function);
1432     int ret;
1433
1434     if (mon->json)
1435         ret = qemuMonitorJSONAttachDrive(mon, drivestr, controllerAddr, driveAddr);
1436     else
1437         ret = qemuMonitorTextAttachDrive(mon, drivestr, controllerAddr, driveAddr);
1438
1439     return ret;
1440 }
1441
1442 int qemuMonitorGetAllPCIAddresses(qemuMonitorPtr mon,
1443                                   qemuMonitorPCIAddress **addrs)
1444 {
1445     DEBUG("mon=%p, fd=%d addrs=%p", mon, mon->fd, addrs);
1446     int ret;
1447
1448     if (mon->json)
1449         ret = qemuMonitorJSONGetAllPCIAddresses(mon, addrs);
1450     else
1451         ret = qemuMonitorTextGetAllPCIAddresses(mon, addrs);
1452     return ret;
1453 }
1454
1455 int qemuMonitorDelDevice(qemuMonitorPtr mon,
1456                          const char *devicestr)
1457 {
1458     DEBUG("mon=%p, fd=%d device(del)=%s", mon, mon->fd, devicestr);
1459     int ret;
1460
1461     if (mon->json)
1462         ret = qemuMonitorJSONDelDevice(mon, devicestr);
1463     else
1464         ret = qemuMonitorTextDelDevice(mon, devicestr);
1465     return ret;
1466 }
1467
1468
1469 int qemuMonitorAddDevice(qemuMonitorPtr mon,
1470                          const char *devicestr)
1471 {
1472     DEBUG("mon=%p, fd=%d device=%s", mon, mon->fd, devicestr);
1473     int ret;
1474
1475     if (mon->json)
1476         ret = qemuMonitorJSONAddDevice(mon, devicestr);
1477     else
1478         ret = qemuMonitorTextAddDevice(mon, devicestr);
1479     return ret;
1480 }
1481
1482 int qemuMonitorAddDrive(qemuMonitorPtr mon,
1483                         const char *drivestr)
1484 {
1485     DEBUG("mon=%p, fd=%d drive=%s", mon, mon->fd, drivestr);
1486     int ret;
1487
1488     if (mon->json)
1489         ret = qemuMonitorJSONAddDrive(mon, drivestr);
1490     else
1491         ret = qemuMonitorTextAddDrive(mon, drivestr);
1492     return ret;
1493 }
1494
1495
1496 int qemuMonitorSetDrivePassphrase(qemuMonitorPtr mon,
1497                                   const char *alias,
1498                                   const char *passphrase)
1499 {
1500     DEBUG("mon=%p, fd=%d alias=%s passphrase=%p(value hidden)", mon, mon->fd, alias, passphrase);
1501     int ret;
1502
1503     if (mon->json)
1504         ret = qemuMonitorJSONSetDrivePassphrase(mon, alias, passphrase);
1505     else
1506         ret = qemuMonitorTextSetDrivePassphrase(mon, alias, passphrase);
1507     return ret;
1508 }
1509
1510 int qemuMonitorCreateSnapshot(qemuMonitorPtr mon, const char *name)
1511 {
1512     int ret;
1513
1514     DEBUG("mon=%p, name=%s",mon,name);
1515
1516     if (mon->json)
1517         ret = qemuMonitorJSONCreateSnapshot(mon, name);
1518     else
1519         ret = qemuMonitorTextCreateSnapshot(mon, name);
1520     return ret;
1521 }
1522
1523 int qemuMonitorLoadSnapshot(qemuMonitorPtr mon, const char *name)
1524 {
1525     int ret;
1526
1527     DEBUG("mon=%p, name=%s",mon,name);
1528
1529     if (mon->json)
1530         ret = qemuMonitorJSONLoadSnapshot(mon, name);
1531     else
1532         ret = qemuMonitorTextLoadSnapshot(mon, name);
1533     return ret;
1534 }
1535
1536 int qemuMonitorDeleteSnapshot(qemuMonitorPtr mon, const char *name)
1537 {
1538     int ret;
1539
1540     DEBUG("mon=%p, name=%s",mon,name);
1541
1542     if (mon->json)
1543         ret = qemuMonitorJSONDeleteSnapshot(mon, name);
1544     else
1545         ret = qemuMonitorTextDeleteSnapshot(mon, name);
1546     return ret;
1547 }