text: /*
   * Copyright 2014, 2015 Red Hat.
   *
   * Permission is hereby granted, free of charge, to any person obtaining a
   * copy of this software and associated documentation files (the "Software"),
   * to deal in the Software without restriction, including without limitation
   * on the rights to use, copy, modify, merge, publish, distribute, sub
   * license, and/or sell copies of the Software, and to permit persons to whom
   * the Software is furnished to do so, subject to the following conditions:
   *
   * The above copyright notice and this permission notice (including the next
   * paragraph) shall be included in all copies or substantial portions of the
   * Software.
   *
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
   * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
   * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
   * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
   * USE OR OTHER DEALINGS IN THE SOFTWARE.
   */
  #include <stdio.h>
  #include "util/u_surface.h"
  #include "util/u_memory.h"
  #include "util/format/u_format.h"
  #include "util/u_inlines.h"
  #include "util/os_time.h"
  #include "frontend/sw_winsys.h"
  #include "os/os_mman.h"
  
  #include "virgl_vtest_winsys.h"
  #include "virgl_vtest_public.h"
  
  /* Gets a pointer to the virgl_hw_res containing the pointed to cache entry. */
  #define cache_entry_container_res(ptr) \
      (struct virgl_hw_res*)((char*)ptr - offsetof(struct virgl_hw_res, cache_entry))
  
  static void *virgl_vtest_resource_map(struct virgl_winsys *vws,
                                        struct virgl_hw_res *res);
  static void virgl_vtest_resource_unmap(struct virgl_winsys *vws,
                                         struct virgl_hw_res *res);
  
  static inline boolean can_cache_resource_with_bind(uint32_t bind)
  {
     return bind == VIRGL_BIND_CONSTANT_BUFFER ||
            bind == VIRGL_BIND_INDEX_BUFFER ||
            bind == VIRGL_BIND_VERTEX_BUFFER ||
            bind == VIRGL_BIND_CUSTOM ||
            bind == VIRGL_BIND_STAGING;
  }
  
  static uint32_t vtest_get_transfer_size(struct virgl_hw_res *res,
                                          const struct pipe_box *box,
                                          uint32_t stride, uint32_t layer_stride,
                                          uint32_t level, uint32_t *valid_stride_p)
  {
     uint32_t valid_stride, valid_layer_stride;
  
     valid_stride = util_format_get_stride(res->format, box->width);
     if (stride) {
        if (box->height > 1)
           valid_stride = stride;
     }
  
     valid_layer_stride = util_format_get_2d_size(res->format, valid_stride,
                                                  box->height);
     if (layer_stride) {
        if (box->depth > 1)
           valid_layer_stride = layer_stride;
     }
  
     *valid_stride_p = valid_stride;
     return valid_layer_stride * box->depth;
  }
  
  static int
  virgl_vtest_transfer_put(struct virgl_winsys *vws,
                           struct virgl_hw_res *res,
                           const struct pipe_box *box,
                           uint32_t stride, uint32_t layer_stride,
                           uint32_t buf_offset, uint32_t level)
  {
     struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
     uint32_t size;
     void *ptr;
     uint32_t valid_stride;
  
     size = vtest_get_transfer_size(res, box, stride, layer_stride, level,
                                    &valid_stride);
  
     virgl_vtest_send_transfer_put(vtws, res->res_handle,
                                   level, stride, layer_stride,
                                   box, size, buf_offset);
  
     if (vtws->protocol_version >= 2)
        return 0;
  
     ptr = virgl_vtest_resource_map(vws, res);
     virgl_vtest_send_transfer_put_data(vtws, ptr + buf_offset, size);
     virgl_vtest_resource_unmap(vws, res);
     return 0;
  }
  
  static int
  virgl_vtest_transfer_get_internal(struct virgl_winsys *vws,
                                    struct virgl_hw_res *res,
                                    const struct pipe_box *box,
                                    uint32_t stride, uint32_t layer_stride,
                                    uint32_t buf_offset, uint32_t level,
                                    bool flush_front_buffer)
  {
     struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
     uint32_t size;
     void *ptr;
     uint32_t valid_stride;
  
     size = vtest_get_transfer_size(res, box, stride, layer_stride, level,
                                    &valid_stride);
     virgl_vtest_send_transfer_get(vtws, res->res_handle,
                                   level, stride, layer_stride,
                                   box, size, buf_offset);
  
     if (flush_front_buffer || vtws->protocol_version >= 2)
        virgl_vtest_busy_wait(vtws, res->res_handle, VCMD_BUSY_WAIT_FLAG_WAIT);
  
     if (vtws->protocol_version >= 2) {
        if (flush_front_buffer) {
           if (box->depth > 1 || box->z > 1) {
              fprintf(stderr, "Expected a 2D resource, received a 3D resource\n");
              return -1;
           }
  
           void *dt_map;
           uint32_t shm_stride;
  
           /*
            * The display target is aligned to 64 bytes, while the shared resource
            * between the client/server is not.
            */
           shm_stride = util_format_get_stride(res->format, res->width);
           ptr = virgl_vtest_resource_map(vws, res);
           dt_map = vtws->sws->displaytarget_map(vtws->sws, res->dt, 0);
  
           util_copy_rect(dt_map, res->format, res->stride, box->x, box->y,
                          box->width, box->height, ptr, shm_stride, box->x,
                          box->y);
  
           virgl_vtest_resource_unmap(vws, res);
           vtws->sws->displaytarget_unmap(vtws->sws, res->dt);
        }
     } else {
        ptr = virgl_vtest_resource_map(vws, res);
        virgl_vtest_recv_transfer_get_data(vtws, ptr + buf_offset, size,
                                           valid_stride, box, res->format);
        virgl_vtest_resource_unmap(vws, res);
     }
  
     return 0;
  }
  
  static int
  virgl_vtest_transfer_get(struct virgl_winsys *vws,
                           struct virgl_hw_res *res,
                           const struct pipe_box *box,
                           uint32_t stride, uint32_t layer_stride,
                           uint32_t buf_offset, uint32_t level)
  {
     return virgl_vtest_transfer_get_internal(vws, res, box, stride,
                                              layer_stride, buf_offset,
                                              level, false);
  }
  
  static void virgl_hw_res_destroy(struct virgl_vtest_winsys *vtws,
                                   struct virgl_hw_res *res)
  {
     virgl_vtest_send_resource_unref(vtws, res->res_handle);
     if (res->dt)
        vtws->sws->displaytarget_destroy(vtws->sws, res->dt);
     if (vtws->protocol_version >= 2) {
        if (res->ptr)
           os_munmap(res->ptr, res->size);
     } else {
        align_free(res->ptr);
     }
  
     FREE(res);
  }
  
  static boolean virgl_vtest_resource_is_busy(struct virgl_winsys *vws,
                                              struct virgl_hw_res *res)
  {
     struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
  
     /* implement busy check */
     int ret;
     ret = virgl_vtest_busy_wait(vtws, res->res_handle, 0);
  
     if (ret < 0)
        return FALSE;
  
     return ret == 1 ? TRUE : FALSE;
  }
  
  static void virgl_vtest_resource_reference(struct virgl_winsys *vws,
                                             struct virgl_hw_res **dres,
                                             struct virgl_hw_res *sres)
  {
     struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
     struct virgl_hw_res *old = *dres;
  
     if (pipe_reference(&(*dres)->reference, &sres->reference)) {
        if (!can_cache_resource_with_bind(old->bind)) {
           virgl_hw_res_destroy(vtws, old);
        } else {
           mtx_lock(&vtws->mutex);
           virgl_resource_cache_add(&vtws->cache, &old->cache_entry);
           mtx_unlock(&vtws->mutex);
        }
     }
     *dres = sres;
  }
  
  static struct virgl_hw_res *
  virgl_vtest_winsys_resource_create(struct virgl_winsys *vws,
                                     enum pipe_texture_target target,
                                     uint32_t format,
                                     uint32_t bind,
                                     uint32_t width,
                                     uint32_t height,
                                     uint32_t depth,
                                     uint32_t array_size,
                                     uint32_t last_level,
                                     uint32_t nr_samples,
                                     uint32_t size)
  {
     struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
     struct virgl_hw_res *res;
     static int handle = 1;
     int fd = -1;
  
     res = CALLOC_STRUCT(virgl_hw_res);
     if (!res)
        return NULL;
  
     if (bind & (VIRGL_BIND_DISPLAY_TARGET | VIRGL_BIND_SCANOUT)) {
        res->dt = vtws->sws->displaytarget_create(vtws->sws, bind, format,
                                                  width, height, 64, NULL,
                                                  &res->stride);
  
     } else if (vtws->protocol_version < 2) {
        res->ptr = align_malloc(size, 64);
        if (!res->ptr) {
           FREE(res);
           return NULL;
        }
     }
  
     res->bind = bind;
     res->format = format;
     res->height = height;
     res->width = width;
     res->size = size;
     virgl_vtest_send_resource_create(vtws, handle, target, pipe_to_virgl_format(format), bind,
                                      width, height, depth, array_size,
                                      last_level, nr_samples, size, &fd);
  
     if (vtws->protocol_version >= 2) {
        if (res->size == 0) {
           res->ptr = NULL;
           goto out;
        }
  
        if (fd < 0) {
           FREE(res);
           fprintf(stderr, "Unable to get a valid fd\n");
           return NULL;
        }
  
        res->ptr = os_mmap(NULL, res->size, PROT_WRITE | PROT_READ, MAP_SHARED,
                           fd, 0);
  
        if (res->ptr == MAP_FAILED) {
           fprintf(stderr, "Client failed to map shared memory region\n");
           close(fd);
           FREE(res);
           return NULL;
        }
  
        close(fd);
     }
  
  out:
     virgl_resource_cache_entry_init(&res->cache_entry, size, bind, format, 0);
     res->res_handle = handle++;
     pipe_reference_init(&res->reference, 1);
     p_atomic_set(&res->num_cs_references, 0);
     return res;
  }
  
  static void *virgl_vtest_resource_map(struct virgl_winsys *vws,
                                        struct virgl_hw_res *res)
  {
     struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
  
     /*
      * With protocol v0 we can either have a display target or a resource backing
      * store. With protocol v2 we can have both, so only return the memory mapped
      * backing store in this function. We can copy to the display target when
      * appropriate.
      */
     if (vtws->protocol_version >= 2 || !res->dt) {
        res->mapped = res->ptr;
        return res->mapped;
     } else {
        return vtws->sws->displaytarget_map(vtws->sws, res->dt, 0);
     }
  }
  
  static void virgl_vtest_resource_unmap(struct virgl_winsys *vws,
                                         struct virgl_hw_res *res)
  {
     struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
     if (res->mapped)
        res->mapped = NULL;
  
     if (res->dt && vtws->protocol_version < 2)
        vtws->sws->displaytarget_unmap(vtws->sws, res->dt);
  }
  
  static void virgl_vtest_resource_wait(struct virgl_winsys *vws,
                                        struct virgl_hw_res *res)
  {
     struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
  
     virgl_vtest_busy_wait(vtws, res->res_handle, VCMD_BUSY_WAIT_FLAG_WAIT);
  }
  
  static struct virgl_hw_res *
  virgl_vtest_winsys_resource_cache_create(struct virgl_winsys *vws,
                                           enum pipe_texture_target target,
                                           uint32_t format,
                                           uint32_t bind,
                                           uint32_t width,
                                           uint32_t height,
                                           uint32_t depth,
                                           uint32_t array_size,
                                           uint32_t last_level,
                                           uint32_t nr_samples,
                                           uint32_t flags,
                                           uint32_t size)
  {
     struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
     struct virgl_hw_res *res;
     struct virgl_resource_cache_entry *entry;
  
     if (!can_cache_resource_with_bind(bind))
        goto alloc;
  
     mtx_lock(&vtws->mutex);
  
     entry = virgl_resource_cache_remove_compatible(&vtws->cache, size,
                                                    bind, format, 0);
     if (entry) {
        res = cache_entry_container_res(entry);
        mtx_unlock(&vtws->mutex);
        pipe_reference_init(&res->reference, 1);
        return res;
     }
  
     mtx_unlock(&vtws->mutex);
  
  alloc:
     res = virgl_vtest_winsys_resource_create(vws, target, format, bind,
                                              width, height, depth, array_size,
                                              last_level, nr_samples, size);
     return res;
  }
  
  static boolean virgl_vtest_lookup_res(struct virgl_vtest_cmd_buf *cbuf,
                                        struct virgl_hw_res *res)
  {
     unsigned hash = res->res_handle & (sizeof(cbuf->is_handle_added)-1);
     int i;
  
     if (cbuf->is_handle_added[hash]) {
        i = cbuf->reloc_indices_hashlist[hash];
        if (cbuf->res_bo[i] == res)
           return true;
  
        for (i = 0; i < cbuf->cres; i++) {
           if (cbuf->res_bo[i] == res) {
              cbuf->reloc_indices_hashlist[hash] = i;
              return true;
           }
        }
     }
     return false;
  }
  
  static void virgl_vtest_release_all_res(struct virgl_vtest_winsys *vtws,
                                          struct virgl_vtest_cmd_buf *cbuf)
  {
     int i;
  
     for (i = 0; i < cbuf->cres; i++) {
        p_atomic_dec(&cbuf->res_bo[i]->num_cs_references);
        virgl_vtest_resource_reference(&vtws->base, &cbuf->res_bo[i], NULL);
     }
     cbuf->cres = 0;
  }
  
  static void virgl_vtest_add_res(struct virgl_vtest_winsys *vtws,
                                  struct virgl_vtest_cmd_buf *cbuf,
                                  struct virgl_hw_res *res)
  {
     unsigned hash = res->res_handle & (sizeof(cbuf->is_handle_added)-1);
  
     if (cbuf->cres >= cbuf->nres) {
        unsigned new_nres = cbuf->nres + 256;
        struct virgl_hw_res **new_re_bo = REALLOC(cbuf->res_bo,
                                                  cbuf->nres * sizeof(struct virgl_hw_buf*),
                                                  new_nres * sizeof(struct virgl_hw_buf*));
        if (!new_re_bo) {
            fprintf(stderr,"failure to add relocation %d, %d\n", cbuf->cres, cbuf->nres);
            return;
        }
  
        cbuf->res_bo = new_re_bo;
        cbuf->nres = new_nres;
     }
  
     cbuf->res_bo[cbuf->cres] = NULL;
     virgl_vtest_resource_reference(&vtws->base, &cbuf->res_bo[cbuf->cres], res);
     cbuf->is_handle_added[hash] = TRUE;
  
     cbuf->reloc_indices_hashlist[hash] = cbuf->cres;
     p_atomic_inc(&res->num_cs_references);
     cbuf->cres++;
  }
  
  static struct virgl_cmd_buf *virgl_vtest_cmd_buf_create(struct virgl_winsys *vws,
                                                          uint32_t size)
  {
     struct virgl_vtest_cmd_buf *cbuf;
  
     cbuf = CALLOC_STRUCT(virgl_vtest_cmd_buf);
     if (!cbuf)
        return NULL;
  
     cbuf->nres = 512;
     cbuf->res_bo = CALLOC(cbuf->nres, sizeof(struct virgl_hw_buf*));
     if (!cbuf->res_bo) {
        FREE(cbuf);
        return NULL;
     }
  
     cbuf->buf = CALLOC(size, sizeof(uint32_t));
     if (!cbuf->buf) {
        FREE(cbuf->res_bo);
        FREE(cbuf);
        return NULL;
     }
  
     cbuf->ws = vws;
     cbuf->base.buf = cbuf->buf;
     return &cbuf->base;
  }
  
  static void virgl_vtest_cmd_buf_destroy(struct virgl_cmd_buf *_cbuf)
  {
     struct virgl_vtest_cmd_buf *cbuf = virgl_vtest_cmd_buf(_cbuf);
  
     virgl_vtest_release_all_res(virgl_vtest_winsys(cbuf->ws), cbuf);
     FREE(cbuf->res_bo);
     FREE(cbuf->buf);
     FREE(cbuf);
  }
  
  static struct pipe_fence_handle *
  virgl_vtest_fence_create(struct virgl_winsys *vws)
  {
     struct virgl_hw_res *res;
  
     /* Resources for fences should not be from the cache, since we are basing
      * the fence status on the resource creation busy status.
      */
     res = virgl_vtest_winsys_resource_create(vws,
                                              PIPE_BUFFER,
                                              PIPE_FORMAT_R8_UNORM,
                                              VIRGL_BIND_CUSTOM,
                                              8, 1, 1, 0, 0, 0, 8);
  
     return (struct pipe_fence_handle *)res;
  }
  
  static int virgl_vtest_winsys_submit_cmd(struct virgl_winsys *vws,
                                           struct virgl_cmd_buf *_cbuf,
                                           struct pipe_fence_handle **fence)
  {
     struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
     struct virgl_vtest_cmd_buf *cbuf = virgl_vtest_cmd_buf(_cbuf);
     int ret;
  
     if (cbuf->base.cdw == 0)
        return 0;
  
     ret = virgl_vtest_submit_cmd(vtws, cbuf);
     if (fence && ret == 0)
        *fence = virgl_vtest_fence_create(vws);
  
     virgl_vtest_release_all_res(vtws, cbuf);
     memset(cbuf->is_handle_added, 0, sizeof(cbuf->is_handle_added));
     cbuf->base.cdw = 0;
     return ret;
  }
  
  static void virgl_vtest_emit_res(struct virgl_winsys *vws,
                                   struct virgl_cmd_buf *_cbuf,
                                   struct virgl_hw_res *res, boolean write_buf)
  {
     struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
     struct virgl_vtest_cmd_buf *cbuf = virgl_vtest_cmd_buf(_cbuf);
     boolean already_in_list = virgl_vtest_lookup_res(cbuf, res);
  
     if (write_buf)
        cbuf->base.buf[cbuf->base.cdw++] = res->res_handle;
     if (!already_in_list)
        virgl_vtest_add_res(vtws, cbuf, res);
  }
  
  static boolean virgl_vtest_res_is_ref(struct virgl_winsys *vws,
                                        struct virgl_cmd_buf *_cbuf,
                                        struct virgl_hw_res *res)
  {
     if (!p_atomic_read(&res->num_cs_references))
        return FALSE;
  
     return TRUE;
  }
  
  static int virgl_vtest_get_caps(struct virgl_winsys *vws,
                                  struct virgl_drm_caps *caps)
  {
     struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
  
     virgl_ws_fill_new_caps_defaults(caps);
     return virgl_vtest_send_get_caps(vtws, caps);
  }
  
  static struct pipe_fence_handle *
  virgl_cs_create_fence(struct virgl_winsys *vws, int fd)
  {
     return virgl_vtest_fence_create(vws);
  }
  
  static bool virgl_fence_wait(struct virgl_winsys *vws,
                               struct pipe_fence_handle *fence,
                               uint64_t timeout)
  {
     struct virgl_hw_res *res = virgl_hw_res(fence);
  
     if (timeout == 0)
        return !virgl_vtest_resource_is_busy(vws, res);
  
     if (timeout != PIPE_TIMEOUT_INFINITE) {
        int64_t start_time = os_time_get();
        timeout /= 1000;
        while (virgl_vtest_resource_is_busy(vws, res)) {
           if (os_time_get() - start_time >= timeout)
              return FALSE;
           os_time_sleep(10);
        }
        return TRUE;
     }
     virgl_vtest_resource_wait(vws, res);
     return TRUE;
  }
  
  static void virgl_fence_reference(struct virgl_winsys *vws,
                                    struct pipe_fence_handle **dst,
                                    struct pipe_fence_handle *src)
  {
     struct virgl_vtest_winsys *vdws = virgl_vtest_winsys(vws);
     virgl_vtest_resource_reference(&vdws->base, (struct virgl_hw_res **)dst,
                                    virgl_hw_res(src));
  }
  
  static void virgl_vtest_flush_frontbuffer(struct virgl_winsys *vws,
                                            struct virgl_hw_res *res,
                                            unsigned level, unsigned layer,
                                            void *winsys_drawable_handle,
                                            struct pipe_box *sub_box)
  {
     struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
     struct pipe_box box;
     uint32_t offset = 0;
     if (!res->dt)
        return;
  
     memset(&box, 0, sizeof(box));
  
     if (sub_box) {
        box = *sub_box;
        offset = box.y / util_format_get_blockheight(res->format) * res->stride +
                 box.x / util_format_get_blockwidth(res->format) * util_format_get_blocksize(res->format);
     } else {
        box.z = layer;
        box.width = res->width;
        box.height = res->height;
        box.depth = 1;
     }
  
     virgl_vtest_transfer_get_internal(vws, res, &box, res->stride, 0, offset,
                                       level, true);
  
     vtws->sws->displaytarget_display(vtws->sws, res->dt, winsys_drawable_handle,
                                      sub_box);
  }
  
  static void
  virgl_vtest_winsys_destroy(struct virgl_winsys *vws)
  {
     struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
  
     virgl_resource_cache_flush(&vtws->cache);
  
     mtx_destroy(&vtws->mutex);
     FREE(vtws);
  }
  
  static bool
  virgl_vtest_resource_cache_entry_is_busy(struct virgl_resource_cache_entry *entry,
                                           void *user_data)
  {
     struct virgl_vtest_winsys *vtws = user_data;
     struct virgl_hw_res *res = cache_entry_container_res(entry);
  
     return virgl_vtest_resource_is_busy(&vtws->base, res);
  }
  
  static void
  virgl_vtest_resource_cache_entry_release(struct virgl_resource_cache_entry *entry,
                                           void *user_data)
  {
     struct virgl_vtest_winsys *vtws = user_data;
     struct virgl_hw_res *res = cache_entry_container_res(entry);
  
     virgl_hw_res_destroy(vtws, res);
  }
  
  struct virgl_winsys *
  virgl_vtest_winsys_wrap(struct sw_winsys *sws)
  {
     static const unsigned CACHE_TIMEOUT_USEC = 1000000;
     struct virgl_vtest_winsys *vtws;
  
     vtws = CALLOC_STRUCT(virgl_vtest_winsys);
     if (!vtws)
        return NULL;
  
     virgl_vtest_connect(vtws);
     vtws->sws = sws;
  
     virgl_resource_cache_init(&vtws->cache, CACHE_TIMEOUT_USEC,
                               virgl_vtest_resource_cache_entry_is_busy,
                               virgl_vtest_resource_cache_entry_release,
                               vtws);
     (void) mtx_init(&vtws->mutex, mtx_plain);
  
     vtws->base.destroy = virgl_vtest_winsys_destroy;
  
     vtws->base.transfer_put = virgl_vtest_transfer_put;
     vtws->base.transfer_get = virgl_vtest_transfer_get;
  
     vtws->base.resource_create = virgl_vtest_winsys_resource_cache_create;
     vtws->base.resource_reference = virgl_vtest_resource_reference;
     vtws->base.resource_map = virgl_vtest_resource_map;
     vtws->base.resource_wait = virgl_vtest_resource_wait;
     vtws->base.resource_is_busy = virgl_vtest_resource_is_busy;
     vtws->base.cmd_buf_create = virgl_vtest_cmd_buf_create;
     vtws->base.cmd_buf_destroy = virgl_vtest_cmd_buf_destroy;
     vtws->base.submit_cmd = virgl_vtest_winsys_submit_cmd;
  
     vtws->base.emit_res = virgl_vtest_emit_res;
     vtws->base.res_is_referenced = virgl_vtest_res_is_ref;
     vtws->base.get_caps = virgl_vtest_get_caps;
  
     vtws->base.cs_create_fence = virgl_cs_create_fence;
     vtws->base.fence_wait = virgl_fence_wait;
     vtws->base.fence_reference = virgl_fence_reference;
     vtws->base.supports_fences =  0;
     vtws->base.supports_encoded_transfers = (vtws->protocol_version >= 2);
  
     vtws->base.flush_frontbuffer = virgl_vtest_flush_frontbuffer;
  
     return &vtws->base;
  }
  