Archipelago » qemu

ETEXI

    {

        .name       = "memchar_write",

        .args_type  = "device:s,data:s",

        .params     = "device data",

        .help       = "Provide writing interface for CirMemCharDriver. Write"

                      "'data' to it.",

        .mhandler.cmd = hmp_memchar_write,

    },

STEXI

@item memchar_write @var{device} @var{data}

@findex memchar_write

Provide writing interface for CirMemCharDriver. Write @var{data}

to char device 'memory'.

void hmp_memchar_write(Monitor *mon, const QDict *qdict)

{

    uint32_t size;

    const char *chardev = qdict_get_str(qdict, "device");

    const char *data = qdict_get_str(qdict, "data");

    Error *errp = NULL;

    size = strlen(data);

    qmp_memchar_write(chardev, size, data, false, 0, &errp);

    hmp_handle_error(mon, &errp);

}

void hmp_memchar_write(Monitor *mon, const QDict *qdict);

# @DataFormat:

#

# An enumeration of data format.

#

# @utf8: The data format is 'utf8'.

#

# @base64: The data format is 'base64'.

#

# Since: 1.4

##

{ 'enum': 'DataFormat'

  'data': [ 'utf8', 'base64' ] }

##

# @memchar-write:

#

# Provide writing interface for memchardev. Write data to char

# device 'memory'.

#

# @device: the name of the memory char device.

#

# @size: the size to write in bytes.

#

# @data: the source data write to memchar.

#

# @format: #optional the format of the data write to chardev 'memory',

#          by default is 'utf8'.

#

# Returns: Nothing on success

#          If @device is not a valid char device, DeviceNotFound

#

# Since: 1.4

##

{ 'command': 'memchar-write',

  'data': {'device': 'str', 'size': 'int', 'data': 'str',

           '*format': 'DataFormat'} }

##

static bool qemu_is_chr(const CharDriverState *chr, const char *filename)

{

    return strcmp(chr->filename, filename);

}

void qmp_memchar_write(const char *device, int64_t size,

                       const char *data, bool has_format,

                       enum DataFormat format,

                       Error **errp)

{

    CharDriverState *chr;

    guchar *write_data;

    int ret;

    gsize write_count;

    chr = qemu_chr_find(device);

    if (!chr) {

        error_set(errp, QERR_DEVICE_NOT_FOUND, device);

        return;

    }

    if (qemu_is_chr(chr, "memory")) {

        error_setg(errp,"%s is not memory char device", device);

        return;

    }

    write_count = (gsize)size;

    if (has_format && (format == DATA_FORMAT_BASE64)) {

        write_data = g_base64_decode(data, &write_count);

    } else {

        write_data = (uint8_t *)data;

    }

    ret = cirmem_chr_write(chr, write_data, write_count);

    if (ret < 0) {

        error_setg(errp, "Failed to write to device %s", device);

        return;

    }

}

        .name       = "memchar-write",

        .args_type  = "device:s,size:i,data:s,format:s?",

        .mhandler.cmd_new = qmp_marshal_input_memchar_write,

    },

SQMP

memchar-write

-------------

Provide writing interface for CirMemCharDriver. Write data to memory

char device.

Arguments:

- "device": the name of the char device, must be unique (json-string)

- "size": the memory size, in bytes, should be power of 2 (json-int)

- "data": the source data write to memory (json-string)

- "format": the data format write to memory, default is

            utf8. (json-string, optional)

          - Possible values: "utf8", "base64"

Example:

-> { "execute": "memchar-write",

                "arguments": { "device": foo,

                               "size": 8,

                               "data": "abcdefgh",

                               "format": "utf8" } }

<- { "return": {} }

EQMP

    {