Re: [PATCH spice-server 1/8] test-stream-device: Factor out VMC emulation

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On Mon, Oct 07, 2019 at 11:38:59AM +0100, Frediano Ziglio wrote:
> Allows to reuse code for emulating a character device.
> It will be used for Smardcard test.
> 
> Signed-off-by: Frediano Ziglio <fziglio@xxxxxxxxxx>
> ---
>  server/tests/Makefile.am          |   2 +
>  server/tests/meson.build          |   2 +
>  server/tests/test-stream-device.c | 224 +++++++++---------------------
>  server/tests/vmc-emu.c            | 121 ++++++++++++++++
>  server/tests/vmc-emu.h            |  48 +++++++
>  5 files changed, 236 insertions(+), 161 deletions(-)
>  create mode 100644 server/tests/vmc-emu.c
>  create mode 100644 server/tests/vmc-emu.h
> 
> diff --git a/server/tests/Makefile.am b/server/tests/Makefile.am
> index 1e62557a..98250851 100644
> --- a/server/tests/Makefile.am
> +++ b/server/tests/Makefile.am
> @@ -37,6 +37,8 @@ libtest_a_SOURCES =				\
>  	test-glib-compat.h			\
>  	win-alarm.c				\
>  	win-alarm.h				\
> +	vmc-emu.c				\
> +	vmc-emu.h				\
>  	$(NULL)
>  
>  LDADD =								\
> diff --git a/server/tests/meson.build b/server/tests/meson.build
> index c9377f1e..33472f14 100644
> --- a/server/tests/meson.build
> +++ b/server/tests/meson.build
> @@ -13,6 +13,8 @@ test_lib_sources = [
>    'test-glib-compat.h',
>    'win-alarm.c',
>    'win-alarm.h',
> +  'vmc-emu.c',
> +  'vmc-emu.h',
>  ]
>  
>  test_libs = []
> diff --git a/server/tests/test-stream-device.c b/server/tests/test-stream-device.c
> index f5698c7d..613caed3 100644
> --- a/server/tests/test-stream-device.c
> +++ b/server/tests/test-stream-device.c
> @@ -34,84 +34,9 @@
>  #include "stream-channel.h"
>  #include "reds.h"
>  #include "win-alarm.h"
> +#include "vmc-emu.h"
>  
> -static SpiceCharDeviceInstance vmc_instance;
> -
> -// device buffer to read from
> -static uint8_t message[2048];
> -// position to read from
> -static unsigned pos;
> -// array of limits when the read should return
> -// the array is defined as [message_sizes_curr, message_sizes_end)
> -// then the size is reach we move on next one till exausted
> -static unsigned message_sizes[16];
> -static unsigned *message_sizes_end, *message_sizes_curr;
> -static bool device_enabled = false;
> -
> -static unsigned vmc_write_pos;
> -static uint8_t vmc_write_buf[2048];
> -
> -// handle writes to the device
> -static int vmc_write(SPICE_GNUC_UNUSED SpiceCharDeviceInstance *sin,
> -                     SPICE_GNUC_UNUSED const uint8_t *buf,
> -                     int len)
> -{
> -    // just copy into the buffer
> -    unsigned copy = MIN(sizeof(vmc_write_buf) - vmc_write_pos, len);
> -    memcpy(vmc_write_buf+vmc_write_pos, buf, copy);
> -    vmc_write_pos += copy;
> -    return len;
> -}
> -
> -static int vmc_read(SPICE_GNUC_UNUSED SpiceCharDeviceInstance *sin,
> -                    uint8_t *buf,
> -                    int len)
> -{
> -    int ret;
> -
> -    if (pos >= *message_sizes_curr && message_sizes_curr < message_sizes_end) {
> -        ++message_sizes_curr;
> -    }
> -    if (message_sizes_curr >= message_sizes_end || pos >= *message_sizes_curr) {
> -        return 0;
> -    }
> -    ret = MIN(*message_sizes_curr - pos, len);
> -    memcpy(buf, &message[pos], ret);
> -    pos += ret;
> -    // kick off next message read
> -    // currently Qemu kicks the device so we need to do it manually
> -    // here. If not all data are read, the device goes into blocking
> -    // state and we get the wake only when we read from the device
> -    // again
> -    if (pos >= *message_sizes_curr) {
> -        spice_server_char_device_wakeup(&vmc_instance);
> -    }
> -    return ret;
> -}
> -
> -static void vmc_state(SPICE_GNUC_UNUSED SpiceCharDeviceInstance *sin,
> -                      SPICE_GNUC_UNUSED int connected)
> -{
> -    device_enabled = !!connected;
> -}
> -
> -static SpiceCharDeviceInterface vmc_interface = {
> -    .base = {
> -        .type          = SPICE_INTERFACE_CHAR_DEVICE,
> -        .description   = "test spice virtual channel char device",
> -        .major_version = SPICE_INTERFACE_CHAR_DEVICE_MAJOR,
> -        .minor_version = SPICE_INTERFACE_CHAR_DEVICE_MINOR,
> -    },
> -    .state              = vmc_state,
> -    .write              = vmc_write,
> -    .read               = vmc_read,
> -};
> -
> -// this specifically creates a stream device
> -static SpiceCharDeviceInstance vmc_instance = {
> -    .subtype = "port",
> -    .portname = "org.spice-space.stream.0",
> -};
> +static VmcEmu *vmc;
>  
>  static uint8_t *add_stream_hdr(uint8_t *p, StreamMsgType type, uint32_t size)
>  {
> @@ -145,18 +70,18 @@ discard_server_capabilities(void)
>  {
>      StreamDevHeader hdr;
>  
> -    if (vmc_write_pos == 0) {
> +    if (vmc->write_pos == 0) {
>          return;
>      }
> -    g_assert(vmc_write_pos >= sizeof(hdr));
> +    g_assert(vmc->write_pos >= sizeof(hdr));
>  
> -    memcpy(&hdr, vmc_write_buf, sizeof(hdr));
> +    memcpy(&hdr, vmc->write_buf, sizeof(hdr));
>      hdr.type = GUINT16_FROM_LE(hdr.type);
>      hdr.size = GUINT32_FROM_LE(hdr.size);
>      if (hdr.type == STREAM_TYPE_CAPABILITIES) {
> -        g_assert_cmpint(hdr.size, <=, vmc_write_pos - sizeof(hdr));
> -        vmc_write_pos -= hdr.size + sizeof(hdr);
> -        memmove(vmc_write_buf, vmc_write_buf + hdr.size + sizeof(hdr), vmc_write_pos);
> +        g_assert_cmpint(hdr.size, <=, vmc->write_pos - sizeof(hdr));
> +        vmc->write_pos -= hdr.size + sizeof(hdr);
> +        memmove(vmc->write_buf, vmc->write_buf + hdr.size + sizeof(hdr), vmc->write_pos);
>      }
>  }
>  
> @@ -168,12 +93,12 @@ check_vmc_error_message(void)
>  
>      discard_server_capabilities();
>  
> -    g_assert_cmpint(vmc_write_pos, >= ,sizeof(hdr));
> +    g_assert_cmpint(vmc->write_pos, >= ,sizeof(hdr));
>  
> -    memcpy(&hdr, vmc_write_buf, sizeof(hdr));
> +    memcpy(&hdr, vmc->write_buf, sizeof(hdr));
>      g_assert_cmpint(hdr.protocol_version, ==, STREAM_DEVICE_PROTOCOL);
>      g_assert_cmpint(GUINT16_FROM_LE(hdr.type), ==, STREAM_TYPE_NOTIFY_ERROR);
> -    g_assert_cmpint(GUINT32_FROM_LE(hdr.size), <=, vmc_write_pos - sizeof(hdr));
> +    g_assert_cmpint(GUINT32_FROM_LE(hdr.size), <=, vmc->write_pos - sizeof(hdr));
>  }
>  
>  static int num_send_data_calls = 0;
> @@ -246,15 +171,13 @@ static void test_stream_device_setup(TestFixture *fixture, gconstpointer user_da
>  {
>      g_assert_null(core);
>      g_assert_null(test);
> +    g_assert_null(vmc);
>      core = basic_event_loop_init();
>      g_assert_nonnull(core);
>      test = test_new(core);
>      g_assert_nonnull(test);
> -
> -    pos = 0;
> -    vmc_write_pos = 0;
> -    message_sizes_curr = message_sizes;
> -    message_sizes_end = message_sizes;
> +    vmc = vmc_emu_new("port", "org.spice-space.stream.0");
> +    g_assert_nonnull(vmc);
>  
>      num_send_data_calls = 0;
>      send_data_bytes = 0;
> @@ -265,6 +188,8 @@ static void test_stream_device_teardown(TestFixture *fixture, gconstpointer user
>      g_assert_nonnull(core);
>      g_assert_nonnull(test);
>  
> +    vmc_emu_destroy(vmc);
> +    vmc = NULL;
>      test_destroy(test);
>      test = NULL;
>      basic_event_loop_destroy();
> @@ -273,122 +198,109 @@ static void test_stream_device_teardown(TestFixture *fixture, gconstpointer user
>  
>  static void test_kick(void)
>  {
> -    vmc_instance.base.sif = &vmc_interface.base;
> -    spice_server_add_interface(test->server, &vmc_instance.base);
> +    spice_server_add_interface(test->server, &vmc->instance.base);
>  
>      // we need to open the device and kick the start
>      // the alarm is to prevent the program from getting stuck
>      alarm(5);
> -    spice_server_port_event(&vmc_instance, SPICE_PORT_EVENT_OPENED);
> -    spice_server_char_device_wakeup(&vmc_instance);
> +    spice_server_port_event(&vmc->instance, SPICE_PORT_EVENT_OPENED);
> +    spice_server_char_device_wakeup(&vmc->instance);
>      alarm(0);
>  }
>  
>  static void test_stream_device(TestFixture *fixture, gconstpointer user_data)
>  {
> -    uint8_t *p = message;
> -
>      for (int test_num=0; test_num < 2; ++test_num) {
> -        pos = 0;
> -        vmc_write_pos = 0;
> -        message_sizes_curr = message_sizes;
> -        message_sizes_end = message_sizes;
> +        vmc_emu_reset(vmc);
> +        uint8_t *p = vmc->message;
>  
>          // add some messages into device buffer
>          // here we are testing the device is reading at least two
>          // consecutive format messages
>          // first message part has 2 extra bytes to check for header split
>          p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_MJPEG);
> -        *message_sizes_end = p - message + 2;
> -        ++message_sizes_end;
> +        vmc_emu_add_read_till(vmc, p + 2);
>  
>          p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_VP9);
>  
>          // this split the second format in half
> -        *message_sizes_end = p - message - 4;
> -        ++message_sizes_end;
> +        vmc_emu_add_read_till(vmc, p - 4);
>  
> -        *message_sizes_end = p - message;
> -        ++message_sizes_end;
> +        vmc_emu_add_read_till(vmc, p);
>  
>          // add a message to stop data to be read
>          p = add_stream_hdr(p, STREAM_TYPE_INVALID, 0);
> -        *message_sizes_end = p - message;
> -        ++message_sizes_end;
> +        vmc_emu_add_read_till(vmc, p);
>  
>          // this message should not be read
>          p = add_stream_hdr(p, STREAM_TYPE_INVALID, 0);
> -        *message_sizes_end = p - message;
> -        ++message_sizes_end;
> +        vmc_emu_add_read_till(vmc, p);
>  
> -        vmc_instance.base.sif = &vmc_interface.base;
> -        spice_server_add_interface(test->server, &vmc_instance.base);
> +        spice_server_add_interface(test->server, &vmc->instance.base);
>  
>          // device should not have read data before we open it
> -        spice_server_char_device_wakeup(&vmc_instance);
> -        g_assert_cmpint(pos, ==, 0);
> +        spice_server_char_device_wakeup(&vmc->instance);
> +        g_assert_cmpint(vmc->pos, ==, 0);
>  
>          g_test_expect_message(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Stream device received invalid message: Invalid message type");
>  
>          // we need to open the device and kick the start
> -        spice_server_port_event(&vmc_instance, SPICE_PORT_EVENT_OPENED);
> -        spice_server_char_device_wakeup(&vmc_instance);
> -        spice_server_port_event(&vmc_instance, SPICE_PORT_EVENT_CLOSED);
> +        spice_server_port_event(&vmc->instance, SPICE_PORT_EVENT_OPENED);
> +        spice_server_char_device_wakeup(&vmc->instance);
> +        spice_server_port_event(&vmc->instance, SPICE_PORT_EVENT_CLOSED);
>  
>          // make sure first 3 parts are read completely
> -        g_assert(message_sizes_curr - message_sizes >= 3);
> +        g_assert(vmc->message_sizes_curr - vmc->message_sizes >= 3);
>          // make sure the device readed all or that device was
>          // disabled, we need this to make sure that device will be in
>          // sync when opened again
> -        g_assert(message_sizes_curr - message_sizes == 5 || !device_enabled);
> +        g_assert(vmc->message_sizes_curr - vmc->message_sizes == 5 || !vmc->device_enabled);
>  
>          check_vmc_error_message();
> -        spice_server_remove_interface(&vmc_instance.base);
> +        spice_server_remove_interface(&vmc->instance.base);
>      }
>  }
>  
>  // check if sending a partial message causes issues
>  static void test_stream_device_unfinished(TestFixture *fixture, gconstpointer user_data)
>  {
> -    uint8_t *p = message;
> +    uint8_t *p = vmc->message;
>  
>      // this long and not finished message should not cause an infinite loop
>      p = add_stream_hdr(p, STREAM_TYPE_DATA, 100000);
> -    *message_sizes_end = p - message;
> -    ++message_sizes_end;
> +    vmc_emu_add_read_till(vmc, p);
>  
>      test_kick();
>  
>      // we should have read all data
> -    g_assert(message_sizes_curr - message_sizes == 1);
> +    g_assert(vmc->message_sizes_curr - vmc->message_sizes == 1);
>  
>      // we should have no data from the device
>      discard_server_capabilities();
> -    g_assert_cmpint(vmc_write_pos, ==, 0);
> +    g_assert_cmpint(vmc->write_pos, ==, 0);
>  }
>  
>  // check if sending multiple messages cause stall
>  static void test_stream_device_multiple(TestFixture *fixture, gconstpointer user_data)
>  {
> -    uint8_t *p = message;
> +    uint8_t *p = vmc->message;
>  
>      // add some messages into device buffer
>      p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_MJPEG);
>      p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_MJPEG);
>      p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_MJPEG);
> -    *message_sizes_end = p - message;
> -    ++message_sizes_end;
> +    vmc_emu_add_read_till(vmc, p);
>  
>      test_kick();
>  
>      // we should have read all data
> -    g_assert(message_sizes_curr - message_sizes == 1);
> +    g_assert(vmc->message_sizes_curr - vmc->message_sizes == 1);
>  }
>  
>  // check if data message consume even following message
>  static void test_stream_device_format_after_data(TestFixture *fixture, gconstpointer user_data)
>  {
> -    uint8_t *p = message;
> +    uint8_t *p = vmc->message;
>  
>      // add some messages into device buffer
>      p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_MJPEG);
> @@ -396,15 +308,14 @@ static void test_stream_device_format_after_data(TestFixture *fixture, gconstpoi
>      memcpy(p, "hello", 5);
>      p += 5;
>      p = add_stream_hdr(p, STREAM_TYPE_INVALID, 0);
> -    *message_sizes_end = p - message;
> -    ++message_sizes_end;
> +    vmc_emu_add_read_till(vmc, p);
>  
>      g_test_expect_message(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Stream device received invalid message: Invalid message type");
>  
>      test_kick();
>  
>      // we should read all data
> -    g_assert(message_sizes_curr - message_sizes == 1);
> +    g_assert(vmc->message_sizes_curr - vmc->message_sizes == 1);
>  
>      // we should have an error back
>      check_vmc_error_message();
> @@ -414,46 +325,42 @@ static void test_stream_device_format_after_data(TestFixture *fixture, gconstpoi
>  static void test_stream_device_empty(TestFixture *fixture, gconstpointer user_data)
>  {
>      const StreamMsgType msg_type = (StreamMsgType) GPOINTER_TO_INT(user_data);
> -    uint8_t *p = message;
> +    uint8_t *p = vmc->message;
>  
>      // add some messages into device buffer
>      p = add_stream_hdr(p, msg_type, 0);
> -    *message_sizes_end = p - message;
> -    ++message_sizes_end;
> +    vmc_emu_add_read_till(vmc, p);
>      p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_MJPEG);
> -    *message_sizes_end = p - message;
> -    ++message_sizes_end;
> +    vmc_emu_add_read_till(vmc, p);
>      p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_MJPEG);
> -    *message_sizes_end = p - message;
> -    ++message_sizes_end;
> +    vmc_emu_add_read_till(vmc, p);
>  
>      test_kick();
>  
>      // we should read all data
> -    g_assert(message_sizes_curr - message_sizes == 3);
> +    g_assert(vmc->message_sizes_curr - vmc->message_sizes == 3);
>  
>      // we should have no data from the device
>      discard_server_capabilities();
> -    g_assert_cmpint(vmc_write_pos, ==, 0);
> +    g_assert_cmpint(vmc->write_pos, ==, 0);
>  }
>  
>  // check that server refuse huge data messages
>  static void test_stream_device_huge_data(TestFixture *fixture, gconstpointer user_data)
>  {
> -    uint8_t *p = message;
> +    uint8_t *p = vmc->message;
>  
>      // add some messages into device buffer
>      p = add_stream_hdr(p, STREAM_TYPE_DATA, 33 * 1024 * 1024);
>      p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_MJPEG);
> -    *message_sizes_end = p - message;
> -    ++message_sizes_end;
> +    vmc_emu_add_read_till(vmc, p);
>  
>      g_test_expect_message(G_LOG_DOMAIN, G_LOG_LEVEL_WARNING, "Stream device received invalid message: STREAM_DATA too large");
>  
>      test_kick();
>  
>      // we should read all data
> -    g_assert(message_sizes_curr - message_sizes == 1);
> +    g_assert(vmc->message_sizes_curr - vmc->message_sizes == 1);
>  
>      // we should have an error back
>      check_vmc_error_message();
> @@ -462,7 +369,7 @@ static void test_stream_device_huge_data(TestFixture *fixture, gconstpointer use
>  // check that server send all message
>  static void test_stream_device_data_message(TestFixture *fixture, gconstpointer user_data)
>  {
> -    uint8_t *p = message;
> +    uint8_t *p = vmc->message;
>  
>      // add some messages into device buffer
>      p = add_format(p, 640, 480, SPICE_VIDEO_CODEC_TYPE_MJPEG);
> @@ -470,23 +377,19 @@ static void test_stream_device_data_message(TestFixture *fixture, gconstpointer
>      for (int i = 0; i < 1017; ++i, ++p) {
>          *p = (uint8_t) (i * 123 + 57);
>      }
> -    *message_sizes_end = 51;
> -    ++message_sizes_end;
> -    *message_sizes_end = 123;
> -    ++message_sizes_end;
> -    *message_sizes_end = 534;
> -    ++message_sizes_end;
> -    *message_sizes_end = p - message;
> -    ++message_sizes_end;
> +    vmc_emu_add_read_till(vmc, vmc->message + 51);
> +    vmc_emu_add_read_till(vmc, vmc->message + 123);
> +    vmc_emu_add_read_till(vmc, vmc->message + 534);
> +    vmc_emu_add_read_till(vmc, p);
>  
>      test_kick();
>  
>      // we should read all data
> -    g_assert(message_sizes_curr - message_sizes == 4);
> +    g_assert(vmc->message_sizes_curr - vmc->message_sizes == 4);
>  
>      // we should have no data from the device
>      discard_server_capabilities();
> -    g_assert_cmpint(vmc_write_pos, ==, 0);
> +    g_assert_cmpint(vmc->write_pos, ==, 0);
>  
>      // make sure data were collapsed in a single message
>      g_assert_cmpint(num_send_data_calls, ==, 1);
> @@ -509,15 +412,14 @@ static void test_display_info(TestFixture *fixture, gconstpointer user_data)
>          .device_display_id = GUINT32_TO_LE(0x0a0b0c0d),
>          .device_address_len = GUINT32_TO_LE(sizeof(address)),
>      };
> -    uint8_t *p = message;
> +    uint8_t *p = vmc->message;
>      p = add_stream_hdr(p, STREAM_TYPE_DEVICE_DISPLAY_INFO, sizeof(info) + sizeof(address));
>      memcpy(p, &info, sizeof(info));
>      p += sizeof(info);
>      strcpy((char*)p, address);
>      p += sizeof(address);
>  
> -    *message_sizes_end = p - message;
> -    ++message_sizes_end;
> +    vmc_emu_add_read_till(vmc, p);
>  
>      // parse the simulated display info message from the stream device so the server now has display
>      // info for the mock stream device
> diff --git a/server/tests/vmc-emu.c b/server/tests/vmc-emu.c
> new file mode 100644
> index 00000000..ddac5269
> --- /dev/null
> +++ b/server/tests/vmc-emu.c
> @@ -0,0 +1,121 @@
> +/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
> +/*
> +   Copyright (C) 2019 Red Hat, Inc.
> +
> +   This library is free software; you can redistribute it and/or
> +   modify it under the terms of the GNU Lesser General Public
> +   License as published by the Free Software Foundation; either
> +   version 2.1 of the License, or (at your option) any later version.
> +
> +   This library is distributed in the hope that it will be useful,
> +   but WITHOUT ANY WARRANTY; without even the implied warranty of
> +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> +   Lesser General Public License for more details.
> +
> +   You should have received a copy of the GNU Lesser General Public
> +   License along with this library; if not, see <http://www.gnu.org/licenses/>.
> +*/
> +
> +#include <config.h>
> +#include <glib.h>
> +
> +#include "vmc-emu.h"
> +
> +// handle writes to the device
> +static int vmc_write(SpiceCharDeviceInstance *sin,
> +                     const uint8_t *buf, int len)
> +{
> +    VmcEmu *const vmc = SPICE_CONTAINEROF(sin, VmcEmu, instance);
> +
> +    // just copy into the buffer
> +    unsigned copy = MIN(sizeof(vmc->write_buf) - vmc->write_pos, len);
> +    memcpy(vmc->write_buf+vmc->write_pos, buf, copy);
> +    vmc->write_pos += copy;
> +    return len;
> +}
> +
> +static int vmc_read(SpiceCharDeviceInstance *sin,
> +                    uint8_t *buf, int len)
> +{
> +    VmcEmu *const vmc = SPICE_CONTAINEROF(sin, VmcEmu, instance);
> +    int ret;
> +
> +    if (vmc->pos >= *vmc->message_sizes_curr && vmc->message_sizes_curr < vmc->message_sizes_end) {
> +        ++vmc->message_sizes_curr;
> +    }
> +    if (vmc->message_sizes_curr >= vmc->message_sizes_end || vmc->pos >= *vmc->message_sizes_curr) {
> +        return 0;
> +    }
> +    ret = MIN(*vmc->message_sizes_curr - vmc->pos, len);
> +    memcpy(buf, &vmc->message[vmc->pos], ret);
> +    vmc->pos += ret;
> +    // kick off next message read
> +    // currently Qemu kicks the device so we need to do it manually
> +    // here. If not all data are read, the device goes into blocking
> +    // state and we get the wake only when we read from the device
> +    // again
> +    if (vmc->pos >= *vmc->message_sizes_curr) {
> +        spice_server_char_device_wakeup(&vmc->instance);
> +    }
> +    return ret;
> +}
> +
> +static void vmc_state(SpiceCharDeviceInstance *sin,
> +                      int connected)
> +{
> +    VmcEmu *const vmc = SPICE_CONTAINEROF(sin, VmcEmu, instance);
> +    vmc->device_enabled = !!connected;
> +}
> +
> +static const SpiceCharDeviceInterface vmc_interface = {
> +    .base = {
> +        .type          = SPICE_INTERFACE_CHAR_DEVICE,
> +        .description   = "test spice virtual channel char device",
> +        .major_version = SPICE_INTERFACE_CHAR_DEVICE_MAJOR,
> +        .minor_version = SPICE_INTERFACE_CHAR_DEVICE_MINOR,
> +    },
> +    .state              = vmc_state,
> +    .write              = vmc_write,
> +    .read               = vmc_read,
> +};
> +
> +VmcEmu *vmc_emu_new(const char *subtype, const char *portname)
> +{
> +    VmcEmu *vmc = g_new0(VmcEmu, 1);
> +    vmc->interface = vmc_interface;
> +    vmc->instance.base.sif = &vmc->interface.base;
> +    vmc->instance.subtype = g_strdup(subtype);
> +    if (portname) {
> +        vmc->instance.portname = g_strdup(portname);
> +    }
> +    vmc_emu_reset(vmc);
> +    return vmc;
> +}
> +
> +void vmc_emu_destroy(VmcEmu *vmc)
> +{
> +    g_free((char *) vmc->instance.portname);
> +    g_free((char *) vmc->instance.subtype);
> +    g_free(vmc);
> +}
> +
> +void vmc_emu_reset(VmcEmu *vmc)
> +{
> +    vmc->pos = 0;
> +    vmc->write_pos = 0;
> +    vmc->message_sizes_curr = vmc->message_sizes;
> +    vmc->message_sizes_end = vmc->message_sizes;
> +}
> +
> +void vmc_emu_add_read_till(VmcEmu *vmc, uint8_t *end)
> +{
> +    g_assert(vmc->message_sizes_end - vmc->message_sizes < G_N_ELEMENTS(vmc->message_sizes));

I'd move the unsigned size here and change both asserts to use
it, that is:

    unsigned size = end - vmc->message;
    g_assert(size >= 0);
    g_assert(size <= G_N_ELEMENTS(vmc->message));

This is my only nitpick for this patch, feel free to ignore if
you want

    Acked-by: Victor Toso <victortoso@xxxxxxxxxx>

> +    g_assert(end >= vmc->message);
> +    g_assert(end - vmc->message <= G_N_ELEMENTS(vmc->message));
> +    unsigned prev_size =
> +        vmc->message_sizes_end > vmc->message_sizes ? vmc->message_sizes_end[-1] : 0;

Forgot how long since I saw a negative index in C!

> +    unsigned size = end - vmc->message;
> +    g_assert(size >= prev_size);
> +    *vmc->message_sizes_end = size;
> +    ++vmc->message_sizes_end;
> +}
> diff --git a/server/tests/vmc-emu.h b/server/tests/vmc-emu.h
> new file mode 100644
> index 00000000..6fcea69d
> --- /dev/null
> +++ b/server/tests/vmc-emu.h
> @@ -0,0 +1,48 @@
> +/* -*- Mode: C; c-basic-offset: 4; indent-tabs-mode: nil -*- */
> +/*
> +   Copyright (C) 2019 Red Hat, Inc.
> +
> +   This library is free software; you can redistribute it and/or
> +   modify it under the terms of the GNU Lesser General Public
> +   License as published by the Free Software Foundation; either
> +   version 2.1 of the License, or (at your option) any later version.
> +
> +   This library is distributed in the hope that it will be useful,
> +   but WITHOUT ANY WARRANTY; without even the implied warranty of
> +   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
> +   Lesser General Public License for more details.
> +
> +   You should have received a copy of the GNU Lesser General Public
> +   License along with this library; if not, see <http://www.gnu.org/licenses/>.
> +*/
> +#pragma once
> +
> +#include "char-device.h"
> +
> +typedef struct VmcEmu VmcEmu;
> +
> +struct VmcEmu {
> +    SpiceCharDeviceInterface interface;
> +    SpiceCharDeviceInstance instance;
> +
> +    // device buffer to read from
> +    uint8_t message[2048];
> +    // position to read from
> +    unsigned pos;
> +
> +    // array of limits when the read should return
> +    // the array is defined as [message_sizes_curr, message_sizes_end)
> +    // then the size is reach we move on next one till exausted
> +    unsigned message_sizes[16];
> +    unsigned *message_sizes_end, *message_sizes_curr;
> +
> +    bool device_enabled;
> +
> +    unsigned write_pos;
> +    uint8_t write_buf[2048];
> +};
> +
> +VmcEmu *vmc_emu_new(const char *subtype, const char *portname);
> +void vmc_emu_destroy(VmcEmu *vmc);
> +void vmc_emu_reset(VmcEmu *vmc);
> +void vmc_emu_add_read_till(VmcEmu *vmc, uint8_t *end);
> -- 
> 2.21.0
> 
> _______________________________________________
> Spice-devel mailing list
> Spice-devel@xxxxxxxxxxxxxxxxxxxxx
> https://lists.freedesktop.org/mailman/listinfo/spice-devel

Attachment: signature.asc
Description: PGP signature

_______________________________________________
Spice-devel mailing list
Spice-devel@xxxxxxxxxxxxxxxxxxxxx
https://lists.freedesktop.org/mailman/listinfo/spice-devel

[Index of Archives]     [Linux Virtualization]     [Linux Virtualization]     [Linux ARM Kernel]     [Linux ARM]     [Linux Omap]     [Fedora ARM]     [IETF Annouce]     [Security]     [Bugtraq]     [Linux OMAP]     [Linux MIPS]     [ECOS]     [Asterisk Internet PBX]     [Linux API]     [Monitors]