Return to commands.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / qga

Annotation of qemu/qga/commands.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * QEMU Guest Agent common/cross-platform command implementations
        !             3:  *
        !             4:  * Copyright IBM Corp. 2012
        !             5:  *
        !             6:  * Authors:
        !             7:  *  Michael Roth      <[email protected]>
        !             8:  *
        !             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.
        !            11:  */
        !            12: 
        !            13: #include <glib.h>
        !            14: #include "qga/guest-agent-core.h"
        !            15: #include "qga-qmp-commands.h"
        !            16: #include "qerror.h"
        !            17: 
        !            18: /* Note: in some situations, like with the fsfreeze, logging may be
        !            19:  * temporarilly disabled. if it is necessary that a command be able
        !            20:  * to log for accounting purposes, check ga_logging_enabled() beforehand,
        !            21:  * and use the QERR_QGA_LOGGING_DISABLED to generate an error
        !            22:  */
        !            23: void slog(const gchar *fmt, ...)
        !            24: {
        !            25:     va_list ap;
        !            26: 
        !            27:     va_start(ap, fmt);
        !            28:     g_logv("syslog", G_LOG_LEVEL_INFO, fmt, ap);
        !            29:     va_end(ap);
        !            30: }
        !            31: 
        !            32: int64_t qmp_guest_sync_delimited(int64_t id, Error **errp)
        !            33: {
        !            34:     ga_set_response_delimited(ga_state);
        !            35:     return id;
        !            36: }
        !            37: 
        !            38: int64_t qmp_guest_sync(int64_t id, Error **errp)
        !            39: {
        !            40:     return id;
        !            41: }
        !            42: 
        !            43: void qmp_guest_ping(Error **err)
        !            44: {
        !            45:     slog("guest-ping called");
        !            46: }
        !            47: 
        !            48: struct GuestAgentInfo *qmp_guest_info(Error **err)
        !            49: {
        !            50:     GuestAgentInfo *info = g_malloc0(sizeof(GuestAgentInfo));
        !            51:     GuestAgentCommandInfo *cmd_info;
        !            52:     GuestAgentCommandInfoList *cmd_info_list;
        !            53:     char **cmd_list_head, **cmd_list;
        !            54: 
        !            55:     info->version = g_strdup(QEMU_VERSION);
        !            56: 
        !            57:     cmd_list_head = cmd_list = qmp_get_command_list();
        !            58:     if (*cmd_list_head == NULL) {
        !            59:         goto out;
        !            60:     }
        !            61: 
        !            62:     while (*cmd_list) {
        !            63:         cmd_info = g_malloc0(sizeof(GuestAgentCommandInfo));
        !            64:         cmd_info->name = strdup(*cmd_list);
        !            65:         cmd_info->enabled = qmp_command_is_enabled(cmd_info->name);
        !            66: 
        !            67:         cmd_info_list = g_malloc0(sizeof(GuestAgentCommandInfoList));
        !            68:         cmd_info_list->value = cmd_info;
        !            69:         cmd_info_list->next = info->supported_commands;
        !            70:         info->supported_commands = cmd_info_list;
        !            71: 
        !            72:         g_free(*cmd_list);
        !            73:         cmd_list++;
        !            74:     }
        !            75: 
        !            76: out:
        !            77:     g_free(cmd_list_head);
        !            78:     return info;
        !            79: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.