2 * QEMU Guest Agent common/cross-platform command implementations
4 * Copyright IBM Corp. 2012
7 * Michael Roth <mdroth@linux.vnet.ibm.com>
9 * This work is licensed under the terms of the GNU GPL, version 2 or later.
10 * See the COPYING file in the top-level directory.
13 #include "qemu/osdep.h"
14 #include "qemu/units.h"
15 #include "guest-agent-core.h"
16 #include "qga-qapi-commands.h"
17 #include "qapi/error.h"
18 #include "qemu/base64.h"
19 #include "qemu/cutils.h"
20 #include "commands-common.h"
22 /* Maximum captured guest-exec out_data/err_data - 16MB */
23 #define GUEST_EXEC_MAX_OUTPUT (16 * 1024 * 1024)
24 /* Allocation and I/O buffer for reading guest-exec out_data/err_data - 4KB */
25 #define GUEST_EXEC_IO_SIZE (4 * 1024)
27 * Maximum file size to read - 48MB
29 * (48MB + Base64 3:4 overhead = JSON parser 64 MB limit)
31 #define GUEST_FILE_READ_COUNT_MAX (48 * MiB)
33 /* Note: in some situations, like with the fsfreeze, logging may be
34 * temporarily disabled. if it is necessary that a command be able
35 * to log for accounting purposes, check ga_logging_enabled() beforehand.
37 void slog(const gchar
*fmt
, ...)
42 g_logv("syslog", G_LOG_LEVEL_INFO
, fmt
, ap
);
46 int64_t qmp_guest_sync_delimited(int64_t id
, Error
**errp
)
48 ga_set_response_delimited(ga_state
);
52 int64_t qmp_guest_sync(int64_t id
, Error
**errp
)
57 void qmp_guest_ping(Error
**errp
)
59 slog("guest-ping called");
62 static void qmp_command_info(const QmpCommand
*cmd
, void *opaque
)
64 GuestAgentInfo
*info
= opaque
;
65 GuestAgentCommandInfo
*cmd_info
;
67 cmd_info
= g_new0(GuestAgentCommandInfo
, 1);
68 cmd_info
->name
= g_strdup(qmp_command_name(cmd
));
69 cmd_info
->enabled
= qmp_command_is_enabled(cmd
);
70 cmd_info
->success_response
= qmp_has_success_response(cmd
);
72 QAPI_LIST_PREPEND(info
->supported_commands
, cmd_info
);
75 struct GuestAgentInfo
*qmp_guest_info(Error
**errp
)
77 GuestAgentInfo
*info
= g_new0(GuestAgentInfo
, 1);
79 info
->version
= g_strdup(QEMU_VERSION
);
80 qmp_for_each_command(&ga_commands
, qmp_command_info
, info
);
84 struct GuestExecIOData
{
92 typedef struct GuestExecIOData GuestExecIOData
;
94 struct GuestExecInfo
{
103 QTAILQ_ENTRY(GuestExecInfo
) next
;
105 typedef struct GuestExecInfo GuestExecInfo
;
108 QTAILQ_HEAD(, GuestExecInfo
) processes
;
109 } guest_exec_state
= {
110 .processes
= QTAILQ_HEAD_INITIALIZER(guest_exec_state
.processes
),
113 static int64_t gpid_to_int64(GPid pid
)
116 return GetProcessId(pid
);
122 static GuestExecInfo
*guest_exec_info_add(GPid pid
)
126 gei
= g_new0(GuestExecInfo
, 1);
128 gei
->pid_numeric
= gpid_to_int64(pid
);
129 QTAILQ_INSERT_TAIL(&guest_exec_state
.processes
, gei
, next
);
134 static GuestExecInfo
*guest_exec_info_find(int64_t pid_numeric
)
138 QTAILQ_FOREACH(gei
, &guest_exec_state
.processes
, next
) {
139 if (gei
->pid_numeric
== pid_numeric
) {
147 GuestExecStatus
*qmp_guest_exec_status(int64_t pid
, Error
**errp
)
150 GuestExecStatus
*ges
;
152 slog("guest-exec-status called, pid: %u", (uint32_t)pid
);
154 gei
= guest_exec_info_find(pid
);
156 error_setg(errp
, "PID " PRId64
" does not exist");
160 ges
= g_new0(GuestExecStatus
, 1);
162 bool finished
= gei
->finished
;
164 /* need to wait till output channels are closed
165 * to be sure we captured all output at this point */
166 if (gei
->has_output
) {
167 finished
&= gei
->out
.closed
&& gei
->err
.closed
;
170 ges
->exited
= finished
;
172 /* Glib has no portable way to parse exit status.
173 * On UNIX, we can get either exit code from normal termination
175 * On Windows, it is either the same exit code or the exception
176 * value for an unhandled exception that caused the process
178 * See MSDN for GetExitCodeProcess() and ntstatus.h for possible
179 * well-known codes, e.g. C0000005 ACCESS_DENIED - analog of SIGSEGV
181 * https://msdn.microsoft.com/en-us/library/windows/desktop/ms683189(v=vs.85).aspx
182 * https://msdn.microsoft.com/en-us/library/aa260331(v=vs.60).aspx
185 /* Additionally WIN32 does not provide any additional information
186 * on whether the child exited or terminated via signal.
187 * We use this simple range check to distinguish application exit code
188 * (usually value less then 256) and unhandled exception code with
189 * ntstatus (always value greater then 0xC0000005). */
190 if ((uint32_t)gei
->status
< 0xC0000000U
) {
191 ges
->has_exitcode
= true;
192 ges
->exitcode
= gei
->status
;
194 ges
->has_signal
= true;
195 ges
->signal
= gei
->status
;
198 if (WIFEXITED(gei
->status
)) {
199 ges
->has_exitcode
= true;
200 ges
->exitcode
= WEXITSTATUS(gei
->status
);
201 } else if (WIFSIGNALED(gei
->status
)) {
202 ges
->has_signal
= true;
203 ges
->signal
= WTERMSIG(gei
->status
);
206 if (gei
->out
.length
> 0) {
207 ges
->out_data
= g_base64_encode(gei
->out
.data
, gei
->out
.length
);
208 ges
->has_out_truncated
= gei
->out
.truncated
;
210 g_free(gei
->out
.data
);
212 if (gei
->err
.length
> 0) {
213 ges
->err_data
= g_base64_encode(gei
->err
.data
, gei
->err
.length
);
214 ges
->has_err_truncated
= gei
->err
.truncated
;
216 g_free(gei
->err
.data
);
218 QTAILQ_REMOVE(&guest_exec_state
.processes
, gei
, next
);
225 /* Get environment variables or arguments array for execve(). */
226 static char **guest_exec_get_args(const strList
*entry
, bool log
)
229 int count
= 1, i
= 0; /* reserve for NULL terminator */
231 char *str
; /* for logging array of arguments */
234 for (it
= entry
; it
!= NULL
; it
= it
->next
) {
236 str_size
+= 1 + strlen(it
->value
);
239 str
= g_malloc(str_size
);
241 args
= g_new(char *, count
);
242 for (it
= entry
; it
!= NULL
; it
= it
->next
) {
243 args
[i
++] = it
->value
;
244 pstrcat(str
, str_size
, it
->value
);
246 pstrcat(str
, str_size
, " ");
252 slog("guest-exec called: \"%s\"", str
);
259 static void guest_exec_child_watch(GPid pid
, gint status
, gpointer data
)
261 GuestExecInfo
*gei
= (GuestExecInfo
*)data
;
263 g_debug("guest_exec_child_watch called, pid: %d, status: %u",
264 (int32_t)gpid_to_int64(pid
), (uint32_t)status
);
266 gei
->status
= status
;
267 gei
->finished
= true;
269 g_spawn_close_pid(pid
);
272 static void guest_exec_task_setup(gpointer data
)
274 #if !defined(G_OS_WIN32)
275 bool has_merge
= *(bool *)data
;
276 struct sigaction sigact
;
280 * FIXME: When `GLIB_VERSION_MIN_REQUIRED` is bumped to 2.58+, use
281 * g_spawn_async_with_fds() to be portable on windows. The current
282 * logic does not work on windows b/c `GSpawnChildSetupFunc` is run
283 * inside the parent, not the child.
285 if (dup2(STDOUT_FILENO
, STDERR_FILENO
) != 0) {
286 slog("dup2() failed to merge stderr into stdout: %s",
291 /* Reset ignored signals back to default. */
292 memset(&sigact
, 0, sizeof(struct sigaction
));
293 sigact
.sa_handler
= SIG_DFL
;
295 if (sigaction(SIGPIPE
, &sigact
, NULL
) != 0) {
296 slog("sigaction() failed to reset child process's SIGPIPE: %s",
302 static gboolean
guest_exec_input_watch(GIOChannel
*ch
,
303 GIOCondition cond
, gpointer p_
)
305 GuestExecIOData
*p
= (GuestExecIOData
*)p_
;
306 gsize bytes_written
= 0;
310 /* nothing left to write */
311 if (p
->size
== p
->length
) {
315 status
= g_io_channel_write_chars(ch
, (gchar
*)p
->data
+ p
->length
,
316 p
->size
- p
->length
, &bytes_written
, &gerr
);
318 /* can be not 0 even if not G_IO_STATUS_NORMAL */
319 if (bytes_written
!= 0) {
320 p
->length
+= bytes_written
;
323 /* continue write, our callback will be called again */
324 if (status
== G_IO_STATUS_NORMAL
|| status
== G_IO_STATUS_AGAIN
) {
329 g_warning("qga: i/o error writing to input_data channel: %s",
335 g_io_channel_shutdown(ch
, true, NULL
);
336 g_io_channel_unref(ch
);
343 static gboolean
guest_exec_output_watch(GIOChannel
*ch
,
344 GIOCondition cond
, gpointer p_
)
346 GuestExecIOData
*p
= (GuestExecIOData
*)p_
;
350 if (cond
== G_IO_HUP
|| cond
== G_IO_ERR
) {
354 if (p
->size
== p
->length
) {
356 if (!p
->truncated
&& p
->size
< GUEST_EXEC_MAX_OUTPUT
) {
357 t
= g_try_realloc(p
->data
, p
->size
+ GUEST_EXEC_IO_SIZE
);
360 /* ignore truncated output */
361 gchar buf
[GUEST_EXEC_IO_SIZE
];
364 gstatus
= g_io_channel_read_chars(ch
, buf
, sizeof(buf
),
366 if (gstatus
== G_IO_STATUS_EOF
|| gstatus
== G_IO_STATUS_ERROR
) {
372 p
->size
+= GUEST_EXEC_IO_SIZE
;
376 /* Calling read API once.
377 * On next available data our callback will be called again */
378 gstatus
= g_io_channel_read_chars(ch
, (gchar
*)p
->data
+ p
->length
,
379 p
->size
- p
->length
, &bytes_read
, NULL
);
380 if (gstatus
== G_IO_STATUS_EOF
|| gstatus
== G_IO_STATUS_ERROR
) {
384 p
->length
+= bytes_read
;
389 g_io_channel_shutdown(ch
, true, NULL
);
390 g_io_channel_unref(ch
);
395 static GuestExecCaptureOutputMode
ga_parse_capture_output(
396 GuestExecCaptureOutput
*capture_output
)
399 return GUEST_EXEC_CAPTURE_OUTPUT_MODE_NONE
;
400 else if (capture_output
->type
== QTYPE_QBOOL
)
401 return capture_output
->u
.flag
? GUEST_EXEC_CAPTURE_OUTPUT_MODE_SEPARATED
402 : GUEST_EXEC_CAPTURE_OUTPUT_MODE_NONE
;
404 return capture_output
->u
.mode
;
407 GuestExec
*qmp_guest_exec(const char *path
,
408 bool has_arg
, strList
*arg
,
409 bool has_env
, strList
*env
,
410 const char *input_data
,
411 GuestExecCaptureOutput
*capture_output
,
415 GuestExec
*ge
= NULL
;
421 gint in_fd
, out_fd
, err_fd
;
422 GIOChannel
*in_ch
, *out_ch
, *err_ch
;
424 bool has_output
= false;
425 bool has_merge
= false;
426 GuestExecCaptureOutputMode output_mode
;
427 g_autofree
uint8_t *input
= NULL
;
430 arglist
.value
= (char *)path
;
431 arglist
.next
= has_arg
? arg
: NULL
;
434 input
= qbase64_decode(input_data
, -1, &ninput
, errp
);
440 argv
= guest_exec_get_args(&arglist
, true);
441 envp
= has_env
? guest_exec_get_args(env
, false) : NULL
;
443 flags
= G_SPAWN_SEARCH_PATH
| G_SPAWN_DO_NOT_REAP_CHILD
|
444 G_SPAWN_SEARCH_PATH_FROM_ENVP
;
446 output_mode
= ga_parse_capture_output(capture_output
);
447 switch (output_mode
) {
448 case GUEST_EXEC_CAPTURE_OUTPUT_MODE_NONE
:
449 flags
|= G_SPAWN_STDOUT_TO_DEV_NULL
| G_SPAWN_STDERR_TO_DEV_NULL
;
451 case GUEST_EXEC_CAPTURE_OUTPUT_MODE_STDOUT
:
453 flags
|= G_SPAWN_STDERR_TO_DEV_NULL
;
455 case GUEST_EXEC_CAPTURE_OUTPUT_MODE_STDERR
:
457 flags
|= G_SPAWN_STDOUT_TO_DEV_NULL
;
459 case GUEST_EXEC_CAPTURE_OUTPUT_MODE_SEPARATED
:
462 #if !defined(G_OS_WIN32)
463 case GUEST_EXEC_CAPTURE_OUTPUT_MODE_MERGED
:
468 case GUEST_EXEC_CAPTURE_OUTPUT_MODE__MAX
:
469 /* Silence warning; impossible branch */
473 ret
= g_spawn_async_with_pipes(NULL
, argv
, envp
, flags
,
474 guest_exec_task_setup
, &has_merge
, &pid
, input_data
? &in_fd
: NULL
,
475 has_output
? &out_fd
: NULL
, has_output
? &err_fd
: NULL
, &gerr
);
477 error_setg(errp
, "%s", gerr
->message
);
482 ge
= g_new0(GuestExec
, 1);
483 ge
->pid
= gpid_to_int64(pid
);
485 gei
= guest_exec_info_add(pid
);
486 gei
->has_output
= has_output
;
487 g_child_watch_add(pid
, guest_exec_child_watch
, gei
);
490 gei
->in
.data
= g_steal_pointer(&input
);
491 gei
->in
.size
= ninput
;
493 in_ch
= g_io_channel_win32_new_fd(in_fd
);
495 in_ch
= g_io_channel_unix_new(in_fd
);
497 g_io_channel_set_encoding(in_ch
, NULL
, NULL
);
498 g_io_channel_set_buffered(in_ch
, false);
499 g_io_channel_set_flags(in_ch
, G_IO_FLAG_NONBLOCK
, NULL
);
500 g_io_channel_set_close_on_unref(in_ch
, true);
501 g_io_add_watch(in_ch
, G_IO_OUT
, guest_exec_input_watch
, &gei
->in
);
506 out_ch
= g_io_channel_win32_new_fd(out_fd
);
507 err_ch
= g_io_channel_win32_new_fd(err_fd
);
509 out_ch
= g_io_channel_unix_new(out_fd
);
510 err_ch
= g_io_channel_unix_new(err_fd
);
512 g_io_channel_set_encoding(out_ch
, NULL
, NULL
);
513 g_io_channel_set_encoding(err_ch
, NULL
, NULL
);
514 g_io_channel_set_buffered(out_ch
, false);
515 g_io_channel_set_buffered(err_ch
, false);
516 g_io_channel_set_close_on_unref(out_ch
, true);
517 g_io_channel_set_close_on_unref(err_ch
, true);
518 g_io_add_watch(out_ch
, G_IO_IN
| G_IO_HUP
,
519 guest_exec_output_watch
, &gei
->out
);
520 g_io_add_watch(err_ch
, G_IO_IN
| G_IO_HUP
,
521 guest_exec_output_watch
, &gei
->err
);
531 /* Convert GuestFileWhence (either a raw integer or an enum value) into
532 * the guest's SEEK_ constants. */
533 int ga_parse_whence(GuestFileWhence
*whence
, Error
**errp
)
536 * Exploit the fact that we picked values to match QGA_SEEK_*;
537 * however, we have to use a temporary variable since the union
538 * members may have different size.
540 if (whence
->type
== QTYPE_QSTRING
) {
541 int value
= whence
->u
.name
;
542 whence
->type
= QTYPE_QNUM
;
543 whence
->u
.value
= value
;
545 switch (whence
->u
.value
) {
553 error_setg(errp
, "invalid whence code %"PRId64
, whence
->u
.value
);
557 GuestHostName
*qmp_guest_get_host_name(Error
**errp
)
559 GuestHostName
*result
= NULL
;
560 g_autofree
char *hostname
= qga_get_host_name(errp
);
563 * We want to avoid using g_get_host_name() because that
564 * caches the result and we wouldn't reflect changes in the
569 hostname
= g_strdup("localhost");
572 result
= g_new0(GuestHostName
, 1);
573 result
->host_name
= g_steal_pointer(&hostname
);
577 GuestTimezone
*qmp_guest_get_timezone(Error
**errp
)
579 GuestTimezone
*info
= NULL
;
580 GTimeZone
*tz
= NULL
;
583 gchar
const *name
= NULL
;
585 info
= g_new0(GuestTimezone
, 1);
586 tz
= g_time_zone_new_local();
588 error_setg(errp
, "Couldn't retrieve local timezone");
592 now
= g_get_real_time() / G_USEC_PER_SEC
;
593 intv
= g_time_zone_find_interval(tz
, G_TIME_TYPE_UNIVERSAL
, now
);
594 info
->offset
= g_time_zone_get_offset(tz
, intv
);
595 name
= g_time_zone_get_abbreviation(tz
, intv
);
597 info
->zone
= g_strdup(name
);
599 g_time_zone_unref(tz
);
608 GuestFileRead
*qmp_guest_file_read(int64_t handle
, bool has_count
,
609 int64_t count
, Error
**errp
)
611 GuestFileHandle
*gfh
= guest_file_handle_find(handle
, errp
);
612 GuestFileRead
*read_data
;
618 count
= QGA_READ_COUNT_DEFAULT
;
619 } else if (count
< 0 || count
> GUEST_FILE_READ_COUNT_MAX
) {
620 error_setg(errp
, "value '%" PRId64
"' is invalid for argument count",
625 read_data
= guest_file_read_unsafe(gfh
, count
, errp
);
627 slog("guest-file-write failed, handle: %" PRId64
, handle
);
633 int64_t qmp_guest_get_time(Error
**errp
)
635 return g_get_real_time() * 1000;