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 "guest-agent-core.h"
15 #include "qga-qapi-commands.h"
16 #include "qapi/error.h"
17 #include "qapi/qmp/qerror.h"
18 #include "qemu/base64.h"
19 #include "qemu/cutils.h"
20 #include "qemu/atomic.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 /* Note: in some situations, like with the fsfreeze, logging may be
28 * temporarilly disabled. if it is necessary that a command be able
29 * to log for accounting purposes, check ga_logging_enabled() beforehand,
30 * and use the QERR_QGA_LOGGING_DISABLED to generate an error
32 void slog(const gchar
*fmt
, ...)
37 g_logv("syslog", G_LOG_LEVEL_INFO
, fmt
, ap
);
41 int64_t qmp_guest_sync_delimited(int64_t id
, Error
**errp
)
43 ga_set_response_delimited(ga_state
);
47 int64_t qmp_guest_sync(int64_t id
, Error
**errp
)
52 void qmp_guest_ping(Error
**errp
)
54 slog("guest-ping called");
57 static void qmp_command_info(QmpCommand
*cmd
, void *opaque
)
59 GuestAgentInfo
*info
= opaque
;
60 GuestAgentCommandInfo
*cmd_info
;
61 GuestAgentCommandInfoList
*cmd_info_list
;
63 cmd_info
= g_new0(GuestAgentCommandInfo
, 1);
64 cmd_info
->name
= g_strdup(qmp_command_name(cmd
));
65 cmd_info
->enabled
= qmp_command_is_enabled(cmd
);
66 cmd_info
->success_response
= qmp_has_success_response(cmd
);
68 cmd_info_list
= g_new0(GuestAgentCommandInfoList
, 1);
69 cmd_info_list
->value
= cmd_info
;
70 cmd_info_list
->next
= info
->supported_commands
;
71 info
->supported_commands
= cmd_info_list
;
74 struct GuestAgentInfo
*qmp_guest_info(Error
**errp
)
76 GuestAgentInfo
*info
= g_new0(GuestAgentInfo
, 1);
78 info
->version
= g_strdup(QEMU_VERSION
);
79 qmp_for_each_command(&ga_commands
, qmp_command_info
, info
);
83 struct GuestExecIOData
{
91 typedef struct GuestExecIOData GuestExecIOData
;
93 struct GuestExecInfo
{
102 QTAILQ_ENTRY(GuestExecInfo
) next
;
104 typedef struct GuestExecInfo GuestExecInfo
;
107 QTAILQ_HEAD(, GuestExecInfo
) processes
;
108 } guest_exec_state
= {
109 .processes
= QTAILQ_HEAD_INITIALIZER(guest_exec_state
.processes
),
112 static int64_t gpid_to_int64(GPid pid
)
115 return GetProcessId(pid
);
121 static GuestExecInfo
*guest_exec_info_add(GPid pid
)
125 gei
= g_new0(GuestExecInfo
, 1);
127 gei
->pid_numeric
= gpid_to_int64(pid
);
128 QTAILQ_INSERT_TAIL(&guest_exec_state
.processes
, gei
, next
);
133 static GuestExecInfo
*guest_exec_info_find(int64_t pid_numeric
)
137 QTAILQ_FOREACH(gei
, &guest_exec_state
.processes
, next
) {
138 if (gei
->pid_numeric
== pid_numeric
) {
146 GuestExecStatus
*qmp_guest_exec_status(int64_t pid
, Error
**err
)
149 GuestExecStatus
*ges
;
151 slog("guest-exec-status called, pid: %u", (uint32_t)pid
);
153 gei
= guest_exec_info_find(pid
);
155 error_setg(err
, QERR_INVALID_PARAMETER
, "pid");
159 ges
= g_new0(GuestExecStatus
, 1);
161 bool finished
= atomic_mb_read(&gei
->finished
);
163 /* need to wait till output channels are closed
164 * to be sure we captured all output at this point */
165 if (gei
->has_output
) {
166 finished
= finished
&& atomic_mb_read(&gei
->out
.closed
);
167 finished
= finished
&& atomic_mb_read(&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
->has_out_data
= true;
208 ges
->out_data
= g_base64_encode(gei
->out
.data
, gei
->out
.length
);
209 g_free(gei
->out
.data
);
210 ges
->has_out_truncated
= gei
->out
.truncated
;
213 if (gei
->err
.length
> 0) {
214 ges
->has_err_data
= true;
215 ges
->err_data
= g_base64_encode(gei
->err
.data
, gei
->err
.length
);
216 g_free(gei
->err
.data
);
217 ges
->has_err_truncated
= gei
->err
.truncated
;
220 QTAILQ_REMOVE(&guest_exec_state
.processes
, gei
, next
);
227 /* Get environment variables or arguments array for execve(). */
228 static char **guest_exec_get_args(const strList
*entry
, bool log
)
231 int count
= 1, i
= 0; /* reserve for NULL terminator */
233 char *str
; /* for logging array of arguments */
236 for (it
= entry
; it
!= NULL
; it
= it
->next
) {
238 str_size
+= 1 + strlen(it
->value
);
241 str
= g_malloc(str_size
);
243 args
= g_malloc(count
* sizeof(char *));
244 for (it
= entry
; it
!= NULL
; it
= it
->next
) {
245 args
[i
++] = it
->value
;
246 pstrcat(str
, str_size
, it
->value
);
248 pstrcat(str
, str_size
, " ");
254 slog("guest-exec called: \"%s\"", str
);
261 static void guest_exec_child_watch(GPid pid
, gint status
, gpointer data
)
263 GuestExecInfo
*gei
= (GuestExecInfo
*)data
;
265 g_debug("guest_exec_child_watch called, pid: %d, status: %u",
266 (int32_t)gpid_to_int64(pid
), (uint32_t)status
);
268 gei
->status
= status
;
269 atomic_mb_set(&gei
->finished
, true);
271 g_spawn_close_pid(pid
);
274 /** Reset ignored signals back to default. */
275 static void guest_exec_task_setup(gpointer data
)
277 #if !defined(G_OS_WIN32)
278 struct sigaction sigact
;
280 memset(&sigact
, 0, sizeof(struct sigaction
));
281 sigact
.sa_handler
= SIG_DFL
;
283 if (sigaction(SIGPIPE
, &sigact
, NULL
) != 0) {
284 slog("sigaction() failed to reset child process's SIGPIPE: %s",
290 static gboolean
guest_exec_input_watch(GIOChannel
*ch
,
291 GIOCondition cond
, gpointer p_
)
293 GuestExecIOData
*p
= (GuestExecIOData
*)p_
;
294 gsize bytes_written
= 0;
298 /* nothing left to write */
299 if (p
->size
== p
->length
) {
303 status
= g_io_channel_write_chars(ch
, (gchar
*)p
->data
+ p
->length
,
304 p
->size
- p
->length
, &bytes_written
, &gerr
);
306 /* can be not 0 even if not G_IO_STATUS_NORMAL */
307 if (bytes_written
!= 0) {
308 p
->length
+= bytes_written
;
311 /* continue write, our callback will be called again */
312 if (status
== G_IO_STATUS_NORMAL
|| status
== G_IO_STATUS_AGAIN
) {
317 g_warning("qga: i/o error writing to input_data channel: %s",
323 g_io_channel_shutdown(ch
, true, NULL
);
324 g_io_channel_unref(ch
);
325 atomic_mb_set(&p
->closed
, true);
331 static gboolean
guest_exec_output_watch(GIOChannel
*ch
,
332 GIOCondition cond
, gpointer p_
)
334 GuestExecIOData
*p
= (GuestExecIOData
*)p_
;
338 if (cond
== G_IO_HUP
|| cond
== G_IO_ERR
) {
342 if (p
->size
== p
->length
) {
344 if (!p
->truncated
&& p
->size
< GUEST_EXEC_MAX_OUTPUT
) {
345 t
= g_try_realloc(p
->data
, p
->size
+ GUEST_EXEC_IO_SIZE
);
348 /* ignore truncated output */
349 gchar buf
[GUEST_EXEC_IO_SIZE
];
352 gstatus
= g_io_channel_read_chars(ch
, buf
, sizeof(buf
),
354 if (gstatus
== G_IO_STATUS_EOF
|| gstatus
== G_IO_STATUS_ERROR
) {
360 p
->size
+= GUEST_EXEC_IO_SIZE
;
364 /* Calling read API once.
365 * On next available data our callback will be called again */
366 gstatus
= g_io_channel_read_chars(ch
, (gchar
*)p
->data
+ p
->length
,
367 p
->size
- p
->length
, &bytes_read
, NULL
);
368 if (gstatus
== G_IO_STATUS_EOF
|| gstatus
== G_IO_STATUS_ERROR
) {
372 p
->length
+= bytes_read
;
377 g_io_channel_shutdown(ch
, true, NULL
);
378 g_io_channel_unref(ch
);
379 atomic_mb_set(&p
->closed
, true);
383 GuestExec
*qmp_guest_exec(const char *path
,
384 bool has_arg
, strList
*arg
,
385 bool has_env
, strList
*env
,
386 bool has_input_data
, const char *input_data
,
387 bool has_capture_output
, bool capture_output
,
391 GuestExec
*ge
= NULL
;
397 gint in_fd
, out_fd
, err_fd
;
398 GIOChannel
*in_ch
, *out_ch
, *err_ch
;
400 bool has_output
= (has_capture_output
&& capture_output
);
401 uint8_t *input
= NULL
;
404 arglist
.value
= (char *)path
;
405 arglist
.next
= has_arg
? arg
: NULL
;
407 if (has_input_data
) {
408 input
= qbase64_decode(input_data
, -1, &ninput
, err
);
414 argv
= guest_exec_get_args(&arglist
, true);
415 envp
= has_env
? guest_exec_get_args(env
, false) : NULL
;
417 flags
= G_SPAWN_SEARCH_PATH
| G_SPAWN_DO_NOT_REAP_CHILD
|
418 G_SPAWN_SEARCH_PATH_FROM_ENVP
;
420 flags
|= G_SPAWN_STDOUT_TO_DEV_NULL
| G_SPAWN_STDERR_TO_DEV_NULL
;
423 ret
= g_spawn_async_with_pipes(NULL
, argv
, envp
, flags
,
424 guest_exec_task_setup
, NULL
, &pid
, has_input_data
? &in_fd
: NULL
,
425 has_output
? &out_fd
: NULL
, has_output
? &err_fd
: NULL
, &gerr
);
427 error_setg(err
, QERR_QGA_COMMAND_FAILED
, gerr
->message
);
432 ge
= g_new0(GuestExec
, 1);
433 ge
->pid
= gpid_to_int64(pid
);
435 gei
= guest_exec_info_add(pid
);
436 gei
->has_output
= has_output
;
437 g_child_watch_add(pid
, guest_exec_child_watch
, gei
);
439 if (has_input_data
) {
440 gei
->in
.data
= input
;
441 gei
->in
.size
= ninput
;
443 in_ch
= g_io_channel_win32_new_fd(in_fd
);
445 in_ch
= g_io_channel_unix_new(in_fd
);
447 g_io_channel_set_encoding(in_ch
, NULL
, NULL
);
448 g_io_channel_set_buffered(in_ch
, false);
449 g_io_channel_set_flags(in_ch
, G_IO_FLAG_NONBLOCK
, NULL
);
450 g_io_channel_set_close_on_unref(in_ch
, true);
451 g_io_add_watch(in_ch
, G_IO_OUT
, guest_exec_input_watch
, &gei
->in
);
456 out_ch
= g_io_channel_win32_new_fd(out_fd
);
457 err_ch
= g_io_channel_win32_new_fd(err_fd
);
459 out_ch
= g_io_channel_unix_new(out_fd
);
460 err_ch
= g_io_channel_unix_new(err_fd
);
462 g_io_channel_set_encoding(out_ch
, NULL
, NULL
);
463 g_io_channel_set_encoding(err_ch
, NULL
, NULL
);
464 g_io_channel_set_buffered(out_ch
, false);
465 g_io_channel_set_buffered(err_ch
, false);
466 g_io_channel_set_close_on_unref(out_ch
, true);
467 g_io_channel_set_close_on_unref(err_ch
, true);
468 g_io_add_watch(out_ch
, G_IO_IN
| G_IO_HUP
,
469 guest_exec_output_watch
, &gei
->out
);
470 g_io_add_watch(err_ch
, G_IO_IN
| G_IO_HUP
,
471 guest_exec_output_watch
, &gei
->err
);
481 /* Convert GuestFileWhence (either a raw integer or an enum value) into
482 * the guest's SEEK_ constants. */
483 int ga_parse_whence(GuestFileWhence
*whence
, Error
**errp
)
485 /* Exploit the fact that we picked values to match QGA_SEEK_*. */
486 if (whence
->type
== QTYPE_QSTRING
) {
487 whence
->type
= QTYPE_QNUM
;
488 whence
->u
.value
= whence
->u
.name
;
490 switch (whence
->u
.value
) {
498 error_setg(errp
, "invalid whence code %"PRId64
, whence
->u
.value
);
502 GuestHostName
*qmp_guest_get_host_name(Error
**err
)
504 GuestHostName
*result
= NULL
;
505 gchar
const *hostname
= g_get_host_name();
506 if (hostname
!= NULL
) {
507 result
= g_new0(GuestHostName
, 1);
508 result
->host_name
= g_strdup(hostname
);
513 GuestTimezone
*qmp_guest_get_timezone(Error
**errp
)
515 GuestTimezone
*info
= NULL
;
516 GTimeZone
*tz
= NULL
;
519 gchar
const *name
= NULL
;
521 info
= g_new0(GuestTimezone
, 1);
522 tz
= g_time_zone_new_local();
524 error_setg(errp
, QERR_QGA_COMMAND_FAILED
,
525 "Couldn't retrieve local timezone");
529 now
= g_get_real_time() / G_USEC_PER_SEC
;
530 intv
= g_time_zone_find_interval(tz
, G_TIME_TYPE_UNIVERSAL
, now
);
531 info
->offset
= g_time_zone_get_offset(tz
, intv
);
532 name
= g_time_zone_get_abbreviation(tz
, intv
);
534 info
->has_zone
= true;
535 info
->zone
= g_strdup(name
);
537 g_time_zone_unref(tz
);