src/gallium/winsys/virgl/vtest/virgl_vtest_socket.c

   1 /*
   2  * Copyright 2014, 2015 Red Hat.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #include <sys/socket.h>
  25 #include <errno.h>
  26 #include <stdio.h>
  27 #include <netinet/in.h>
  28 #include <sys/un.h>
  29 #include <unistd.h>
  30
  31 #include <os/os_process.h>
  32 #include <util/format/u_format.h>
  33
  34 #include "virgl_vtest_winsys.h"
  35 #include "virgl_vtest_public.h"
  36
  37 /* block read/write routines */
  38 static int virgl_block_write(int fd, void *buf, int size)
  39 {
  40    void *ptr = buf;
  41    int left;
  42    int ret;
  43    left = size;
  44    do {
  45       ret = write(fd, ptr, left);
  46       if (ret < 0)
  47          return -errno;
  48       left -= ret;
  49       ptr += ret;
  50    } while (left);
  51    return size;
  52 }
  53
  54 static int virgl_block_read(int fd, void *buf, int size)
  55 {
  56    void *ptr = buf;
  57    int left;
  58    int ret;
  59    left = size;
  60    do {
  61       ret = read(fd, ptr, left);
  62       if (ret <= 0) {
  63          fprintf(stderr,
  64                  "lost connection to rendering server on %d read %d %d\n",
  65                  size, ret, errno);
  66          abort();
  67          return ret < 0 ? -errno : 0;
  68       }
  69       left -= ret;
  70       ptr += ret;
  71    } while (left);
  72    return size;
  73 }
  74
  75 static int virgl_vtest_receive_fd(int socket_fd)
  76 {
  77     struct cmsghdr *cmsgh;
  78     struct msghdr msgh = { 0 };
  79     char buf[CMSG_SPACE(sizeof(int))], c;
  80     struct iovec iovec;
  81
  82     iovec.iov_base = &c;
  83     iovec.iov_len = sizeof(char);
  84
  85     msgh.msg_name = NULL;
  86     msgh.msg_namelen = 0;
  87     msgh.msg_iov = &iovec;
  88     msgh.msg_iovlen = 1;
  89     msgh.msg_control = buf;
  90     msgh.msg_controllen = sizeof(buf);
  91     msgh.msg_flags = 0;
  92
  93     int size = recvmsg(socket_fd, &msgh, 0);
  94     if (size < 0) {
  95       fprintf(stderr, "Failed with %s\n", strerror(errno));
  96       return -1;
  97     }
  98
  99     cmsgh = CMSG_FIRSTHDR(&msgh);
 100     if (!cmsgh) {
 101       fprintf(stderr, "No headers available\n");
 102       return -1;
 103     }
 104
 105     if (cmsgh->cmsg_level != SOL_SOCKET) {
 106       fprintf(stderr, "invalid cmsg_level %d\n", cmsgh->cmsg_level);
 107       return -1;
 108     }
 109
 110     if (cmsgh->cmsg_type != SCM_RIGHTS) {
 111       fprintf(stderr, "invalid cmsg_type %d\n", cmsgh->cmsg_type);
 112       return -1;
 113     }
 114
 115     return *((int *) CMSG_DATA(cmsgh));
 116 }
 117
 118 static int virgl_vtest_send_init(struct virgl_vtest_winsys *vws)
 119 {
 120    uint32_t buf[VTEST_HDR_SIZE];
 121    const char *nstr = "virtest";
 122    char cmdline[64];
 123    int ret;
 124
 125    ret = os_get_process_name(cmdline, 63);
 126    if (ret == FALSE)
 127       strcpy(cmdline, nstr);
 128 #if defined(HAVE_PROGRAM_INVOCATION_NAME)
 129    if (!strcmp(cmdline, "shader_runner")) {
 130       const char *name;
 131       /* hack to get better testname */
 132       name = program_invocation_short_name;
 133       name += strlen(name) + 1;
 134       strncpy(cmdline, name, 63);
 135    }
 136 #endif
 137    buf[VTEST_CMD_LEN] = strlen(cmdline) + 1;
 138    buf[VTEST_CMD_ID] = VCMD_CREATE_RENDERER;
 139
 140    virgl_block_write(vws->sock_fd, &buf, sizeof(buf));
 141    virgl_block_write(vws->sock_fd, (void *)cmdline, strlen(cmdline) + 1);
 142    return 0;
 143 }
 144
 145 static int virgl_vtest_negotiate_version(struct virgl_vtest_winsys *vws)
 146 {
 147    uint32_t vtest_hdr[VTEST_HDR_SIZE];
 148    uint32_t version_buf[VCMD_PROTOCOL_VERSION_SIZE];
 149    uint32_t busy_wait_buf[VCMD_BUSY_WAIT_SIZE];
 150    uint32_t busy_wait_result[1];
 151    int ret;
 152
 153    vtest_hdr[VTEST_CMD_LEN] = VCMD_PING_PROTOCOL_VERSION_SIZE;
 154    vtest_hdr[VTEST_CMD_ID] = VCMD_PING_PROTOCOL_VERSION;
 155    virgl_block_write(vws->sock_fd, &vtest_hdr, sizeof(vtest_hdr));
 156
 157    vtest_hdr[VTEST_CMD_LEN] = VCMD_BUSY_WAIT_SIZE;
 158    vtest_hdr[VTEST_CMD_ID] = VCMD_RESOURCE_BUSY_WAIT;
 159    busy_wait_buf[VCMD_BUSY_WAIT_HANDLE] = 0;
 160    busy_wait_buf[VCMD_BUSY_WAIT_FLAGS] = 0;
 161    virgl_block_write(vws->sock_fd, &vtest_hdr, sizeof(vtest_hdr));
 162    virgl_block_write(vws->sock_fd, &busy_wait_buf, sizeof(busy_wait_buf));
 163
 164    ret = virgl_block_read(vws->sock_fd, vtest_hdr, sizeof(vtest_hdr));
 165    assert(ret);
 166
 167    if (vtest_hdr[VTEST_CMD_ID] == VCMD_PING_PROTOCOL_VERSION) {
 168      /* Read dummy busy_wait response */
 169      ret = virgl_block_read(vws->sock_fd, vtest_hdr, sizeof(vtest_hdr));
 170      assert(ret);
 171      ret = virgl_block_read(vws->sock_fd, busy_wait_result, sizeof(busy_wait_result));
 172      assert(ret);
 173
 174      vtest_hdr[VTEST_CMD_LEN] = VCMD_PROTOCOL_VERSION_SIZE;
 175      vtest_hdr[VTEST_CMD_ID] = VCMD_PROTOCOL_VERSION;
 176      version_buf[VCMD_PROTOCOL_VERSION_VERSION] = VTEST_PROTOCOL_VERSION;
 177      virgl_block_write(vws->sock_fd, &vtest_hdr, sizeof(vtest_hdr));
 178      virgl_block_write(vws->sock_fd, &version_buf, sizeof(version_buf));
 179
 180      ret = virgl_block_read(vws->sock_fd, vtest_hdr, sizeof(vtest_hdr));
 181      assert(ret);
 182      ret = virgl_block_read(vws->sock_fd, version_buf, sizeof(version_buf));
 183      assert(ret);
 184      return version_buf[VCMD_PROTOCOL_VERSION_VERSION];
 185    }
 186
 187    /* Read dummy busy_wait response */
 188    assert(vtest_hdr[VTEST_CMD_ID] == VCMD_RESOURCE_BUSY_WAIT);
 189    ret = virgl_block_read(vws->sock_fd, busy_wait_result, sizeof(busy_wait_result));
 190    assert(ret);
 191
 192    /* Old server, return version 0 */
 193    return 0;
 194 }
 195
 196 int virgl_vtest_connect(struct virgl_vtest_winsys *vws)
 197 {
 198    struct sockaddr_un un;
 199    int sock, ret;
 200
 201    sock = socket(PF_UNIX, SOCK_STREAM, 0);
 202    if (sock < 0)
 203       return -1;
 204
 205    memset(&un, 0, sizeof(un));
 206    un.sun_family = AF_UNIX;
 207    snprintf(un.sun_path, sizeof(un.sun_path), "%s", VTEST_DEFAULT_SOCKET_NAME);
 208
 209    do {
 210       ret = 0;
 211       if (connect(sock, (struct sockaddr *)&un, sizeof(un)) < 0) {
 212          ret = -errno;
 213       }
 214    } while (ret == -EINTR);
 215
 216    vws->sock_fd = sock;
 217    virgl_vtest_send_init(vws);
 218    vws->protocol_version = virgl_vtest_negotiate_version(vws);
 219
 220    /* Version 1 is deprecated. */
 221    if (vws->protocol_version == 1)
 222       vws->protocol_version = 0;
 223
 224    return 0;
 225 }
 226
 227 int virgl_vtest_send_get_caps(struct virgl_vtest_winsys *vws,
 228                               struct virgl_drm_caps *caps)
 229 {
 230    uint32_t get_caps_buf[VTEST_HDR_SIZE * 2];
 231    uint32_t resp_buf[VTEST_HDR_SIZE];
 232    uint32_t caps_size = sizeof(struct virgl_caps_v2);
 233    int ret;
 234    get_caps_buf[VTEST_CMD_LEN] = 0;
 235    get_caps_buf[VTEST_CMD_ID] = VCMD_GET_CAPS2;
 236    get_caps_buf[VTEST_CMD_LEN + 2] = 0;
 237    get_caps_buf[VTEST_CMD_ID + 2] = VCMD_GET_CAPS;
 238
 239    virgl_block_write(vws->sock_fd, &get_caps_buf, sizeof(get_caps_buf));
 240
 241    ret = virgl_block_read(vws->sock_fd, resp_buf, sizeof(resp_buf));
 242    if (ret <= 0)
 243       return 0;
 244
 245    if (resp_buf[1] == 2) {
 246        struct virgl_caps_v1 dummy;
 247        uint32_t resp_size = resp_buf[0] - 1;
 248        uint32_t dummy_size = 0;
 249        if (resp_size > caps_size) {
 250            dummy_size = resp_size - caps_size;
 251            resp_size = caps_size;
 252        }
 253
 254        ret = virgl_block_read(vws->sock_fd, &caps->caps, resp_size);
 255
 256        if (dummy_size)
 257            ret = virgl_block_read(vws->sock_fd, &dummy, dummy_size);
 258
 259        /* now read back the pointless caps v1 we requested */
 260        ret = virgl_block_read(vws->sock_fd, resp_buf, sizeof(resp_buf));
 261        if (ret <= 0)
 262            return 0;
 263        ret = virgl_block_read(vws->sock_fd, &dummy, sizeof(struct virgl_caps_v1));
 264    } else
 265        ret = virgl_block_read(vws->sock_fd, &caps->caps, sizeof(struct virgl_caps_v1));
 266
 267    return 0;
 268 }
 269
 270 static int virgl_vtest_send_resource_create2(struct virgl_vtest_winsys *vws,
 271                                              uint32_t handle,
 272                                              enum pipe_texture_target target,
 273                                              uint32_t format,
 274                                              uint32_t bind,
 275                                              uint32_t width,
 276                                              uint32_t height,
 277                                              uint32_t depth,
 278                                              uint32_t array_size,
 279                                              uint32_t last_level,
 280                                              uint32_t nr_samples,
 281                                              uint32_t size,
 282                                              int *out_fd)
 283 {
 284    uint32_t res_create_buf[VCMD_RES_CREATE2_SIZE], vtest_hdr[VTEST_HDR_SIZE];
 285
 286    vtest_hdr[VTEST_CMD_LEN] = VCMD_RES_CREATE2_SIZE;
 287    vtest_hdr[VTEST_CMD_ID] = VCMD_RESOURCE_CREATE2;
 288
 289    res_create_buf[VCMD_RES_CREATE2_RES_HANDLE] = handle;
 290    res_create_buf[VCMD_RES_CREATE2_TARGET] = target;
 291    res_create_buf[VCMD_RES_CREATE2_FORMAT] = format;
 292    res_create_buf[VCMD_RES_CREATE2_BIND] = bind;
 293    res_create_buf[VCMD_RES_CREATE2_WIDTH] = width;
 294    res_create_buf[VCMD_RES_CREATE2_HEIGHT] = height;
 295    res_create_buf[VCMD_RES_CREATE2_DEPTH] = depth;
 296    res_create_buf[VCMD_RES_CREATE2_ARRAY_SIZE] = array_size;
 297    res_create_buf[VCMD_RES_CREATE2_LAST_LEVEL] = last_level;
 298    res_create_buf[VCMD_RES_CREATE2_NR_SAMPLES] = nr_samples;
 299    res_create_buf[VCMD_RES_CREATE2_DATA_SIZE] = size;
 300
 301    virgl_block_write(vws->sock_fd, &vtest_hdr, sizeof(vtest_hdr));
 302    virgl_block_write(vws->sock_fd, &res_create_buf, sizeof(res_create_buf));
 303
 304    /* Multi-sampled textures have no backing store attached. */
 305    if (size == 0)
 306       return 0;
 307
 308    *out_fd = virgl_vtest_receive_fd(vws->sock_fd);
 309    if (*out_fd < 0) {
 310       fprintf(stderr, "failed to get fd\n");
 311       return -1;
 312    }
 313
 314    return 0;
 315 }
 316
 317 int virgl_vtest_send_resource_create(struct virgl_vtest_winsys *vws,
 318                                      uint32_t handle,
 319                                      enum pipe_texture_target target,
 320                                      uint32_t format,
 321                                      uint32_t bind,
 322                                      uint32_t width,
 323                                      uint32_t height,
 324                                      uint32_t depth,
 325                                      uint32_t array_size,
 326                                      uint32_t last_level,
 327                                      uint32_t nr_samples,
 328                                      uint32_t size,
 329                                      int *out_fd)
 330 {
 331    uint32_t res_create_buf[VCMD_RES_CREATE_SIZE], vtest_hdr[VTEST_HDR_SIZE];
 332
 333    if (vws->protocol_version >= 2)
 334       return virgl_vtest_send_resource_create2(vws, handle, target, format,
 335                                                bind, width, height, depth,
 336                                                array_size, last_level,
 337                                                nr_samples, size, out_fd);
 338
 339    vtest_hdr[VTEST_CMD_LEN] = VCMD_RES_CREATE_SIZE;
 340    vtest_hdr[VTEST_CMD_ID] = VCMD_RESOURCE_CREATE;
 341
 342    res_create_buf[VCMD_RES_CREATE_RES_HANDLE] = handle;
 343    res_create_buf[VCMD_RES_CREATE_TARGET] = target;
 344    res_create_buf[VCMD_RES_CREATE_FORMAT] = format;
 345    res_create_buf[VCMD_RES_CREATE_BIND] = bind;
 346    res_create_buf[VCMD_RES_CREATE_WIDTH] = width;
 347    res_create_buf[VCMD_RES_CREATE_HEIGHT] = height;
 348    res_create_buf[VCMD_RES_CREATE_DEPTH] = depth;
 349    res_create_buf[VCMD_RES_CREATE_ARRAY_SIZE] = array_size;
 350    res_create_buf[VCMD_RES_CREATE_LAST_LEVEL] = last_level;
 351    res_create_buf[VCMD_RES_CREATE_NR_SAMPLES] = nr_samples;
 352
 353    virgl_block_write(vws->sock_fd, &vtest_hdr, sizeof(vtest_hdr));
 354    virgl_block_write(vws->sock_fd, &res_create_buf, sizeof(res_create_buf));
 355
 356    return 0;
 357 }
 358
 359 int virgl_vtest_submit_cmd(struct virgl_vtest_winsys *vws,
 360                            struct virgl_vtest_cmd_buf *cbuf)
 361 {
 362    uint32_t vtest_hdr[VTEST_HDR_SIZE];
 363
 364    vtest_hdr[VTEST_CMD_LEN] = cbuf->base.cdw;
 365    vtest_hdr[VTEST_CMD_ID] = VCMD_SUBMIT_CMD;
 366
 367    virgl_block_write(vws->sock_fd, &vtest_hdr, sizeof(vtest_hdr));
 368    virgl_block_write(vws->sock_fd, cbuf->buf, cbuf->base.cdw * 4);
 369    return 0;
 370 }
 371
 372 int virgl_vtest_send_resource_unref(struct virgl_vtest_winsys *vws,
 373                                     uint32_t handle)
 374 {
 375    uint32_t vtest_hdr[VTEST_HDR_SIZE];
 376    uint32_t cmd[1];
 377    vtest_hdr[VTEST_CMD_LEN] = 1;
 378    vtest_hdr[VTEST_CMD_ID] = VCMD_RESOURCE_UNREF;
 379
 380    cmd[0] = handle;
 381    virgl_block_write(vws->sock_fd, &vtest_hdr, sizeof(vtest_hdr));
 382    virgl_block_write(vws->sock_fd, &cmd, sizeof(cmd));
 383    return 0;
 384 }
 385
 386 static int virgl_vtest_send_transfer_cmd(struct virgl_vtest_winsys *vws,
 387                                   uint32_t vcmd,
 388                                   uint32_t handle,
 389                                   uint32_t level, uint32_t stride,
 390                                   uint32_t layer_stride,
 391                                   const struct pipe_box *box,
 392                                   uint32_t data_size)
 393 {
 394    uint32_t vtest_hdr[VTEST_HDR_SIZE];
 395    uint32_t cmd[VCMD_TRANSFER_HDR_SIZE];
 396    vtest_hdr[VTEST_CMD_LEN] = VCMD_TRANSFER_HDR_SIZE;
 397    vtest_hdr[VTEST_CMD_ID] = vcmd;
 398
 399    /* The host expects the size in dwords so calculate the rounded up
 400     * value here. */
 401    if (vcmd == VCMD_TRANSFER_PUT)
 402       vtest_hdr[VTEST_CMD_LEN] += (data_size + 3) / 4;
 403
 404    cmd[0] = handle;
 405    cmd[1] = level;
 406    cmd[2] = stride;
 407    cmd[3] = layer_stride;
 408    cmd[4] = box->x;
 409    cmd[5] = box->y;
 410    cmd[6] = box->z;
 411    cmd[7] = box->width;
 412    cmd[8] = box->height;
 413    cmd[9] = box->depth;
 414    cmd[10] = data_size;
 415    virgl_block_write(vws->sock_fd, &vtest_hdr, sizeof(vtest_hdr));
 416    virgl_block_write(vws->sock_fd, &cmd, sizeof(cmd));
 417
 418    return 0;
 419 }
 420
 421 static int virgl_vtest_send_transfer_cmd2(struct virgl_vtest_winsys *vws,
 422                                   uint32_t vcmd,
 423                                   uint32_t handle,
 424                                   uint32_t level,
 425                                   const struct pipe_box *box,
 426                                   uint32_t data_size,
 427                                   uint32_t offset)
 428 {
 429    uint32_t vtest_hdr[VTEST_HDR_SIZE];
 430    uint32_t cmd[VCMD_TRANSFER2_HDR_SIZE];
 431    vtest_hdr[VTEST_CMD_LEN] = VCMD_TRANSFER2_HDR_SIZE;
 432    vtest_hdr[VTEST_CMD_ID] = vcmd;
 433
 434    /* The host expects the size in dwords so calculate the rounded up
 435     * value here. */
 436    if (vcmd == VCMD_TRANSFER_PUT2)
 437       vtest_hdr[VTEST_CMD_LEN] += (data_size + 3) / 4;
 438
 439    cmd[VCMD_TRANSFER2_RES_HANDLE] = handle;
 440    cmd[VCMD_TRANSFER2_LEVEL] = level;
 441    cmd[VCMD_TRANSFER2_X] = box->x;
 442    cmd[VCMD_TRANSFER2_Y] = box->y;
 443    cmd[VCMD_TRANSFER2_Z] = box->z;
 444    cmd[VCMD_TRANSFER2_WIDTH] = box->width;
 445    cmd[VCMD_TRANSFER2_HEIGHT] = box->height;
 446    cmd[VCMD_TRANSFER2_DEPTH] = box->depth;
 447    cmd[VCMD_TRANSFER2_DATA_SIZE] = data_size;
 448    cmd[VCMD_TRANSFER2_OFFSET] = offset;
 449    virgl_block_write(vws->sock_fd, &vtest_hdr, sizeof(vtest_hdr));
 450    virgl_block_write(vws->sock_fd, &cmd, sizeof(cmd));
 451
 452    return 0;
 453 }
 454
 455 int virgl_vtest_send_transfer_get(struct virgl_vtest_winsys *vws,
 456                                   uint32_t handle,
 457                                   uint32_t level, uint32_t stride,
 458                                   uint32_t layer_stride,
 459                                   const struct pipe_box *box,
 460                                   uint32_t data_size,
 461                                   uint32_t offset)
 462 {
 463    if (vws->protocol_version < 2)
 464       return virgl_vtest_send_transfer_cmd(vws, VCMD_TRANSFER_GET, handle,
 465                                            level, stride, layer_stride, box,
 466                                            data_size);
 467
 468    return virgl_vtest_send_transfer_cmd2(vws, VCMD_TRANSFER_GET2, handle,
 469                                         level, box, data_size, offset);
 470 }
 471
 472 int virgl_vtest_send_transfer_put(struct virgl_vtest_winsys *vws,
 473                                   uint32_t handle,
 474                                   uint32_t level, uint32_t stride,
 475                                   uint32_t layer_stride,
 476                                   const struct pipe_box *box,
 477                                   uint32_t data_size,
 478                                   uint32_t offset)
 479 {
 480    if (vws->protocol_version < 2)
 481       return virgl_vtest_send_transfer_cmd(vws, VCMD_TRANSFER_PUT, handle,
 482                                            level, stride, layer_stride, box,
 483                                            data_size);
 484
 485    return virgl_vtest_send_transfer_cmd2(vws, VCMD_TRANSFER_PUT2, handle,
 486                                         level, box, data_size, offset);
 487 }
 488
 489 int virgl_vtest_send_transfer_put_data(struct virgl_vtest_winsys *vws,
 490                                        void *data,
 491                                        uint32_t data_size)
 492 {
 493    return virgl_block_write(vws->sock_fd, data, data_size);
 494 }
 495
 496 int virgl_vtest_recv_transfer_get_data(struct virgl_vtest_winsys *vws,
 497                                        void *data,
 498                                        uint32_t data_size,
 499                                        uint32_t stride,
 500                                        const struct pipe_box *box,
 501                                        uint32_t format)
 502 {
 503    void *line;
 504    void *ptr = data;
 505    int hblocks = util_format_get_nblocksy(format, box->height);
 506
 507    line = malloc(stride);
 508    while (hblocks) {
 509       virgl_block_read(vws->sock_fd, line, stride);
 510       memcpy(ptr, line, util_format_get_stride(format, box->width));
 511       ptr += stride;
 512       hblocks--;
 513    }
 514    free(line);
 515    return 0;
 516 }
 517
 518 int virgl_vtest_busy_wait(struct virgl_vtest_winsys *vws, int handle,
 519                           int flags)
 520 {
 521    uint32_t vtest_hdr[VTEST_HDR_SIZE];
 522    uint32_t cmd[VCMD_BUSY_WAIT_SIZE];
 523    uint32_t result[1];
 524    int ret;
 525    vtest_hdr[VTEST_CMD_LEN] = VCMD_BUSY_WAIT_SIZE;
 526    vtest_hdr[VTEST_CMD_ID] = VCMD_RESOURCE_BUSY_WAIT;
 527    cmd[VCMD_BUSY_WAIT_HANDLE] = handle;
 528    cmd[VCMD_BUSY_WAIT_FLAGS] = flags;
 529
 530    virgl_block_write(vws->sock_fd, &vtest_hdr, sizeof(vtest_hdr));
 531    virgl_block_write(vws->sock_fd, &cmd, sizeof(cmd));
 532
 533    ret = virgl_block_read(vws->sock_fd, vtest_hdr, sizeof(vtest_hdr));
 534    assert(ret);
 535    ret = virgl_block_read(vws->sock_fd, result, sizeof(result));
 536    assert(ret);
 537    return result[0];
 538 }