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 #include <stdio.h>
24 #include "util/u_surface.h"
25 #include "util/u_memory.h"
26 #include "util/format/u_format.h"
27 #include "util/u_inlines.h"
28 #include "util/os_time.h"
29 #include "frontend/sw_winsys.h"
30 #include "os/os_mman.h"
31
32 #include "virgl_vtest_winsys.h"
33 #include "virgl_vtest_public.h"
34
35 /* Gets a pointer to the virgl_hw_res containing the pointed to cache entry. */
36 #define cache_entry_container_res(ptr) \
37 (struct virgl_hw_res*)((char*)ptr - offsetof(struct virgl_hw_res, cache_entry))
38
39 static void *virgl_vtest_resource_map(struct virgl_winsys *vws,
40 struct virgl_hw_res *res);
41 static void virgl_vtest_resource_unmap(struct virgl_winsys *vws,
42 struct virgl_hw_res *res);
43
can_cache_resource_with_bind(uint32_t bind)44 static inline boolean can_cache_resource_with_bind(uint32_t bind)
45 {
46 return bind == VIRGL_BIND_CONSTANT_BUFFER ||
47 bind == VIRGL_BIND_INDEX_BUFFER ||
48 bind == VIRGL_BIND_VERTEX_BUFFER ||
49 bind == VIRGL_BIND_CUSTOM ||
50 bind == VIRGL_BIND_STAGING;
51 }
52
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)53 static uint32_t vtest_get_transfer_size(struct virgl_hw_res *res,
54 const struct pipe_box *box,
55 uint32_t stride, uint32_t layer_stride,
56 uint32_t level, uint32_t *valid_stride_p)
57 {
58 uint32_t valid_stride, valid_layer_stride;
59
60 valid_stride = util_format_get_stride(res->format, box->width);
61 if (stride) {
62 if (box->height > 1)
63 valid_stride = stride;
64 }
65
66 valid_layer_stride = util_format_get_2d_size(res->format, valid_stride,
67 box->height);
68 if (layer_stride) {
69 if (box->depth > 1)
70 valid_layer_stride = layer_stride;
71 }
72
73 *valid_stride_p = valid_stride;
74 return valid_layer_stride * box->depth;
75 }
76
77 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)78 virgl_vtest_transfer_put(struct virgl_winsys *vws,
79 struct virgl_hw_res *res,
80 const struct pipe_box *box,
81 uint32_t stride, uint32_t layer_stride,
82 uint32_t buf_offset, uint32_t level)
83 {
84 struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
85 uint32_t size;
86 void *ptr;
87 uint32_t valid_stride;
88
89 size = vtest_get_transfer_size(res, box, stride, layer_stride, level,
90 &valid_stride);
91
92 virgl_vtest_send_transfer_put(vtws, res->res_handle,
93 level, stride, layer_stride,
94 box, size, buf_offset);
95
96 if (vtws->protocol_version >= 2)
97 return 0;
98
99 ptr = virgl_vtest_resource_map(vws, res);
100 virgl_vtest_send_transfer_put_data(vtws, ptr + buf_offset, size);
101 virgl_vtest_resource_unmap(vws, res);
102 return 0;
103 }
104
105 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)106 virgl_vtest_transfer_get_internal(struct virgl_winsys *vws,
107 struct virgl_hw_res *res,
108 const struct pipe_box *box,
109 uint32_t stride, uint32_t layer_stride,
110 uint32_t buf_offset, uint32_t level,
111 bool flush_front_buffer)
112 {
113 struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
114 uint32_t size;
115 void *ptr;
116 uint32_t valid_stride;
117
118 size = vtest_get_transfer_size(res, box, stride, layer_stride, level,
119 &valid_stride);
120 virgl_vtest_send_transfer_get(vtws, res->res_handle,
121 level, stride, layer_stride,
122 box, size, buf_offset);
123
124 if (flush_front_buffer || vtws->protocol_version >= 2)
125 virgl_vtest_busy_wait(vtws, res->res_handle, VCMD_BUSY_WAIT_FLAG_WAIT);
126
127 if (vtws->protocol_version >= 2) {
128 if (flush_front_buffer) {
129 if (box->depth > 1 || box->z > 1) {
130 fprintf(stderr, "Expected a 2D resource, received a 3D resource\n");
131 return -1;
132 }
133
134 void *dt_map;
135 uint32_t shm_stride;
136
137 /*
138 * The display target is aligned to 64 bytes, while the shared resource
139 * between the client/server is not.
140 */
141 shm_stride = util_format_get_stride(res->format, res->width);
142 ptr = virgl_vtest_resource_map(vws, res);
143 dt_map = vtws->sws->displaytarget_map(vtws->sws, res->dt, 0);
144
145 util_copy_rect(dt_map, res->format, res->stride, box->x, box->y,
146 box->width, box->height, ptr, shm_stride, box->x,
147 box->y);
148
149 virgl_vtest_resource_unmap(vws, res);
150 vtws->sws->displaytarget_unmap(vtws->sws, res->dt);
151 }
152 } else {
153 ptr = virgl_vtest_resource_map(vws, res);
154 virgl_vtest_recv_transfer_get_data(vtws, ptr + buf_offset, size,
155 valid_stride, box, res->format);
156 virgl_vtest_resource_unmap(vws, res);
157 }
158
159 return 0;
160 }
161
162 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)163 virgl_vtest_transfer_get(struct virgl_winsys *vws,
164 struct virgl_hw_res *res,
165 const struct pipe_box *box,
166 uint32_t stride, uint32_t layer_stride,
167 uint32_t buf_offset, uint32_t level)
168 {
169 return virgl_vtest_transfer_get_internal(vws, res, box, stride,
170 layer_stride, buf_offset,
171 level, false);
172 }
173
virgl_hw_res_destroy(struct virgl_vtest_winsys * vtws,struct virgl_hw_res * res)174 static void virgl_hw_res_destroy(struct virgl_vtest_winsys *vtws,
175 struct virgl_hw_res *res)
176 {
177 virgl_vtest_send_resource_unref(vtws, res->res_handle);
178 if (res->dt)
179 vtws->sws->displaytarget_destroy(vtws->sws, res->dt);
180 if (vtws->protocol_version >= 2) {
181 if (res->ptr)
182 os_munmap(res->ptr, res->size);
183 } else {
184 align_free(res->ptr);
185 }
186
187 FREE(res);
188 }
189
virgl_vtest_resource_is_busy(struct virgl_winsys * vws,struct virgl_hw_res * res)190 static boolean virgl_vtest_resource_is_busy(struct virgl_winsys *vws,
191 struct virgl_hw_res *res)
192 {
193 struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
194
195 /* implement busy check */
196 int ret;
197 ret = virgl_vtest_busy_wait(vtws, res->res_handle, 0);
198
199 if (ret < 0)
200 return FALSE;
201
202 return ret == 1 ? TRUE : FALSE;
203 }
204
virgl_vtest_resource_reference(struct virgl_winsys * vws,struct virgl_hw_res ** dres,struct virgl_hw_res * sres)205 static void virgl_vtest_resource_reference(struct virgl_winsys *vws,
206 struct virgl_hw_res **dres,
207 struct virgl_hw_res *sres)
208 {
209 struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
210 struct virgl_hw_res *old = *dres;
211
212 if (pipe_reference(&(*dres)->reference, &sres->reference)) {
213 if (!can_cache_resource_with_bind(old->bind)) {
214 virgl_hw_res_destroy(vtws, old);
215 } else {
216 mtx_lock(&vtws->mutex);
217 virgl_resource_cache_add(&vtws->cache, &old->cache_entry);
218 mtx_unlock(&vtws->mutex);
219 }
220 }
221 *dres = sres;
222 }
223
224 static struct virgl_hw_res *
virgl_vtest_winsys_resource_create(struct virgl_winsys * vws,enum pipe_texture_target target,const void * map_front_private,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)225 virgl_vtest_winsys_resource_create(struct virgl_winsys *vws,
226 enum pipe_texture_target target,
227 const void *map_front_private,
228 uint32_t format,
229 uint32_t bind,
230 uint32_t width,
231 uint32_t height,
232 uint32_t depth,
233 uint32_t array_size,
234 uint32_t last_level,
235 uint32_t nr_samples,
236 uint32_t size)
237 {
238 struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
239 struct virgl_hw_res *res;
240 static int handle = 1;
241 int fd = -1;
242 struct virgl_resource_params params = { .size = size,
243 .bind = bind,
244 .format = format,
245 .flags = 0,
246 .nr_samples = nr_samples,
247 .width = width,
248 .height = height,
249 .depth = depth,
250 .array_size = array_size,
251 .last_level = last_level,
252 .target = target };
253
254 res = CALLOC_STRUCT(virgl_hw_res);
255 if (!res)
256 return NULL;
257
258 if (bind & (VIRGL_BIND_DISPLAY_TARGET | VIRGL_BIND_SCANOUT)) {
259 res->dt = vtws->sws->displaytarget_create(vtws->sws, bind, format,
260 width, height, 64, map_front_private,
261 &res->stride);
262
263 } else if (vtws->protocol_version < 2) {
264 res->ptr = align_malloc(size, 64);
265 if (!res->ptr) {
266 FREE(res);
267 return NULL;
268 }
269 }
270
271 res->bind = bind;
272 res->format = format;
273 res->height = height;
274 res->width = width;
275 res->size = size;
276 virgl_vtest_send_resource_create(vtws, handle, target, pipe_to_virgl_format(format), bind,
277 width, height, depth, array_size,
278 last_level, nr_samples, size, &fd);
279
280 if (vtws->protocol_version >= 2) {
281 if (res->size == 0) {
282 res->ptr = NULL;
283 res->res_handle = handle;
284 goto out;
285 }
286
287 if (fd < 0) {
288 FREE(res);
289 fprintf(stderr, "Unable to get a valid fd\n");
290 return NULL;
291 }
292
293 res->ptr = os_mmap(NULL, res->size, PROT_WRITE | PROT_READ, MAP_SHARED,
294 fd, 0);
295
296 if (res->ptr == MAP_FAILED) {
297 fprintf(stderr, "Client failed to map shared memory region\n");
298 close(fd);
299 FREE(res);
300 return NULL;
301 }
302
303 close(fd);
304 }
305
306 res->res_handle = handle;
307 if (map_front_private && res->ptr && res->dt) {
308 void *dt_map = vtws->sws->displaytarget_map(vtws->sws, res->dt, PIPE_MAP_READ_WRITE);
309 uint32_t shm_stride = util_format_get_stride(res->format, res->width);
310 util_copy_rect(res->ptr, res->format, shm_stride, 0, 0,
311 res->width, res->height, dt_map, res->stride, 0, 0);
312
313 struct pipe_box box;
314 u_box_2d(0, 0, res->width, res->height, &box);
315 virgl_vtest_transfer_put(vws, res, &box, res->stride, 0, 0, 0);
316 }
317
318 out:
319 virgl_resource_cache_entry_init(&res->cache_entry, params);
320 handle++;
321 pipe_reference_init(&res->reference, 1);
322 p_atomic_set(&res->num_cs_references, 0);
323 return res;
324 }
325
virgl_vtest_resource_map(struct virgl_winsys * vws,struct virgl_hw_res * res)326 static void *virgl_vtest_resource_map(struct virgl_winsys *vws,
327 struct virgl_hw_res *res)
328 {
329 struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
330
331 /*
332 * With protocol v0 we can either have a display target or a resource backing
333 * store. With protocol v2 we can have both, so only return the memory mapped
334 * backing store in this function. We can copy to the display target when
335 * appropriate.
336 */
337 if (vtws->protocol_version >= 2 || !res->dt) {
338 res->mapped = res->ptr;
339 return res->mapped;
340 } else {
341 return vtws->sws->displaytarget_map(vtws->sws, res->dt, 0);
342 }
343 }
344
virgl_vtest_resource_unmap(struct virgl_winsys * vws,struct virgl_hw_res * res)345 static void virgl_vtest_resource_unmap(struct virgl_winsys *vws,
346 struct virgl_hw_res *res)
347 {
348 struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
349 if (res->mapped)
350 res->mapped = NULL;
351
352 if (res->dt && vtws->protocol_version < 2)
353 vtws->sws->displaytarget_unmap(vtws->sws, res->dt);
354 }
355
virgl_vtest_resource_wait(struct virgl_winsys * vws,struct virgl_hw_res * res)356 static void virgl_vtest_resource_wait(struct virgl_winsys *vws,
357 struct virgl_hw_res *res)
358 {
359 struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
360
361 virgl_vtest_busy_wait(vtws, res->res_handle, VCMD_BUSY_WAIT_FLAG_WAIT);
362 }
363
364 static struct virgl_hw_res *
virgl_vtest_winsys_resource_cache_create(struct virgl_winsys * vws,enum pipe_texture_target target,const void * map_front_private,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)365 virgl_vtest_winsys_resource_cache_create(struct virgl_winsys *vws,
366 enum pipe_texture_target target,
367 const void *map_front_private,
368 uint32_t format,
369 uint32_t bind,
370 uint32_t width,
371 uint32_t height,
372 uint32_t depth,
373 uint32_t array_size,
374 uint32_t last_level,
375 uint32_t nr_samples,
376 uint32_t flags,
377 uint32_t size)
378 {
379 struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
380 struct virgl_hw_res *res;
381 struct virgl_resource_cache_entry *entry;
382 struct virgl_resource_params params = { .size = size,
383 .bind = bind,
384 .format = format,
385 .flags = 0,
386 .nr_samples = nr_samples,
387 .width = width,
388 .height = height,
389 .depth = depth,
390 .array_size = array_size,
391 .last_level = last_level,
392 .target = target };
393
394 if (!can_cache_resource_with_bind(bind))
395 goto alloc;
396
397 mtx_lock(&vtws->mutex);
398
399 entry = virgl_resource_cache_remove_compatible(&vtws->cache, params);
400 if (entry) {
401 res = cache_entry_container_res(entry);
402 mtx_unlock(&vtws->mutex);
403 pipe_reference_init(&res->reference, 1);
404 return res;
405 }
406
407 mtx_unlock(&vtws->mutex);
408
409 alloc:
410 res = virgl_vtest_winsys_resource_create(vws, target, map_front_private,
411 format, bind, width, height, depth,
412 array_size, last_level, nr_samples,
413 size);
414 return res;
415 }
416
virgl_vtest_lookup_res(struct virgl_vtest_cmd_buf * cbuf,struct virgl_hw_res * res)417 static boolean virgl_vtest_lookup_res(struct virgl_vtest_cmd_buf *cbuf,
418 struct virgl_hw_res *res)
419 {
420 unsigned hash = res->res_handle & (sizeof(cbuf->is_handle_added)-1);
421 int i;
422
423 if (cbuf->is_handle_added[hash]) {
424 i = cbuf->reloc_indices_hashlist[hash];
425 if (cbuf->res_bo[i] == res)
426 return true;
427
428 for (i = 0; i < cbuf->cres; i++) {
429 if (cbuf->res_bo[i] == res) {
430 cbuf->reloc_indices_hashlist[hash] = i;
431 return true;
432 }
433 }
434 }
435 return false;
436 }
437
virgl_vtest_release_all_res(struct virgl_vtest_winsys * vtws,struct virgl_vtest_cmd_buf * cbuf)438 static void virgl_vtest_release_all_res(struct virgl_vtest_winsys *vtws,
439 struct virgl_vtest_cmd_buf *cbuf)
440 {
441 int i;
442
443 for (i = 0; i < cbuf->cres; i++) {
444 p_atomic_dec(&cbuf->res_bo[i]->num_cs_references);
445 virgl_vtest_resource_reference(&vtws->base, &cbuf->res_bo[i], NULL);
446 }
447 cbuf->cres = 0;
448 }
449
virgl_vtest_add_res(struct virgl_vtest_winsys * vtws,struct virgl_vtest_cmd_buf * cbuf,struct virgl_hw_res * res)450 static void virgl_vtest_add_res(struct virgl_vtest_winsys *vtws,
451 struct virgl_vtest_cmd_buf *cbuf,
452 struct virgl_hw_res *res)
453 {
454 unsigned hash = res->res_handle & (sizeof(cbuf->is_handle_added)-1);
455
456 if (cbuf->cres >= cbuf->nres) {
457 unsigned new_nres = cbuf->nres + 256;
458 struct virgl_hw_res **new_re_bo = REALLOC(cbuf->res_bo,
459 cbuf->nres * sizeof(struct virgl_hw_buf*),
460 new_nres * sizeof(struct virgl_hw_buf*));
461 if (!new_re_bo) {
462 fprintf(stderr,"failure to add relocation %d, %d\n", cbuf->cres, cbuf->nres);
463 return;
464 }
465
466 cbuf->res_bo = new_re_bo;
467 cbuf->nres = new_nres;
468 }
469
470 cbuf->res_bo[cbuf->cres] = NULL;
471 virgl_vtest_resource_reference(&vtws->base, &cbuf->res_bo[cbuf->cres], res);
472 cbuf->is_handle_added[hash] = TRUE;
473
474 cbuf->reloc_indices_hashlist[hash] = cbuf->cres;
475 p_atomic_inc(&res->num_cs_references);
476 cbuf->cres++;
477 }
478
virgl_vtest_cmd_buf_create(struct virgl_winsys * vws,uint32_t size)479 static struct virgl_cmd_buf *virgl_vtest_cmd_buf_create(struct virgl_winsys *vws,
480 uint32_t size)
481 {
482 struct virgl_vtest_cmd_buf *cbuf;
483
484 cbuf = CALLOC_STRUCT(virgl_vtest_cmd_buf);
485 if (!cbuf)
486 return NULL;
487
488 cbuf->nres = 512;
489 cbuf->res_bo = CALLOC(cbuf->nres, sizeof(struct virgl_hw_buf*));
490 if (!cbuf->res_bo) {
491 FREE(cbuf);
492 return NULL;
493 }
494
495 cbuf->buf = CALLOC(size, sizeof(uint32_t));
496 if (!cbuf->buf) {
497 FREE(cbuf->res_bo);
498 FREE(cbuf);
499 return NULL;
500 }
501
502 cbuf->ws = vws;
503 cbuf->base.buf = cbuf->buf;
504 return &cbuf->base;
505 }
506
virgl_vtest_cmd_buf_destroy(struct virgl_cmd_buf * _cbuf)507 static void virgl_vtest_cmd_buf_destroy(struct virgl_cmd_buf *_cbuf)
508 {
509 struct virgl_vtest_cmd_buf *cbuf = virgl_vtest_cmd_buf(_cbuf);
510
511 virgl_vtest_release_all_res(virgl_vtest_winsys(cbuf->ws), cbuf);
512 FREE(cbuf->res_bo);
513 FREE(cbuf->buf);
514 FREE(cbuf);
515 }
516
517 static struct pipe_fence_handle *
virgl_vtest_fence_create(struct virgl_winsys * vws)518 virgl_vtest_fence_create(struct virgl_winsys *vws)
519 {
520 struct virgl_hw_res *res;
521
522 /* Resources for fences should not be from the cache, since we are basing
523 * the fence status on the resource creation busy status.
524 */
525 res = virgl_vtest_winsys_resource_create(vws,
526 PIPE_BUFFER,
527 NULL,
528 PIPE_FORMAT_R8_UNORM,
529 VIRGL_BIND_CUSTOM,
530 8, 1, 1, 0, 0, 0, 8);
531
532 return (struct pipe_fence_handle *)res;
533 }
534
virgl_vtest_winsys_submit_cmd(struct virgl_winsys * vws,struct virgl_cmd_buf * _cbuf,struct pipe_fence_handle ** fence)535 static int virgl_vtest_winsys_submit_cmd(struct virgl_winsys *vws,
536 struct virgl_cmd_buf *_cbuf,
537 struct pipe_fence_handle **fence)
538 {
539 struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
540 struct virgl_vtest_cmd_buf *cbuf = virgl_vtest_cmd_buf(_cbuf);
541 int ret;
542
543 if (cbuf->base.cdw == 0)
544 return 0;
545
546 ret = virgl_vtest_submit_cmd(vtws, cbuf);
547 if (fence && ret == 0)
548 *fence = virgl_vtest_fence_create(vws);
549
550 virgl_vtest_release_all_res(vtws, cbuf);
551 memset(cbuf->is_handle_added, 0, sizeof(cbuf->is_handle_added));
552 cbuf->base.cdw = 0;
553 return ret;
554 }
555
virgl_vtest_emit_res(struct virgl_winsys * vws,struct virgl_cmd_buf * _cbuf,struct virgl_hw_res * res,boolean write_buf)556 static void virgl_vtest_emit_res(struct virgl_winsys *vws,
557 struct virgl_cmd_buf *_cbuf,
558 struct virgl_hw_res *res, boolean write_buf)
559 {
560 struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
561 struct virgl_vtest_cmd_buf *cbuf = virgl_vtest_cmd_buf(_cbuf);
562 boolean already_in_list = virgl_vtest_lookup_res(cbuf, res);
563
564 if (write_buf)
565 cbuf->base.buf[cbuf->base.cdw++] = res->res_handle;
566 if (!already_in_list)
567 virgl_vtest_add_res(vtws, cbuf, res);
568 }
569
virgl_vtest_res_is_ref(struct virgl_winsys * vws,struct virgl_cmd_buf * _cbuf,struct virgl_hw_res * res)570 static boolean virgl_vtest_res_is_ref(struct virgl_winsys *vws,
571 struct virgl_cmd_buf *_cbuf,
572 struct virgl_hw_res *res)
573 {
574 if (!p_atomic_read(&res->num_cs_references))
575 return FALSE;
576
577 return TRUE;
578 }
579
virgl_vtest_get_caps(struct virgl_winsys * vws,struct virgl_drm_caps * caps)580 static int virgl_vtest_get_caps(struct virgl_winsys *vws,
581 struct virgl_drm_caps *caps)
582 {
583 struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
584 int ret;
585
586 virgl_ws_fill_new_caps_defaults(caps);
587 ret = virgl_vtest_send_get_caps(vtws, caps);
588 // vtest doesn't support that
589 if (caps->caps.v2.capability_bits_v2 & VIRGL_CAP_V2_COPY_TRANSFER_BOTH_DIRECTIONS)
590 caps->caps.v2.capability_bits_v2 &= ~VIRGL_CAP_V2_COPY_TRANSFER_BOTH_DIRECTIONS;
591 return ret;
592 }
593
594 static struct pipe_fence_handle *
virgl_cs_create_fence(struct virgl_winsys * vws,int fd)595 virgl_cs_create_fence(struct virgl_winsys *vws, int fd)
596 {
597 return virgl_vtest_fence_create(vws);
598 }
599
virgl_fence_wait(struct virgl_winsys * vws,struct pipe_fence_handle * fence,uint64_t timeout)600 static bool virgl_fence_wait(struct virgl_winsys *vws,
601 struct pipe_fence_handle *fence,
602 uint64_t timeout)
603 {
604 struct virgl_hw_res *res = virgl_hw_res(fence);
605
606 if (timeout == 0)
607 return !virgl_vtest_resource_is_busy(vws, res);
608
609 if (timeout != PIPE_TIMEOUT_INFINITE) {
610 int64_t start_time = os_time_get();
611 timeout /= 1000;
612 while (virgl_vtest_resource_is_busy(vws, res)) {
613 if (os_time_get() - start_time >= timeout)
614 return FALSE;
615 os_time_sleep(10);
616 }
617 return TRUE;
618 }
619 virgl_vtest_resource_wait(vws, res);
620 return TRUE;
621 }
622
virgl_fence_reference(struct virgl_winsys * vws,struct pipe_fence_handle ** dst,struct pipe_fence_handle * src)623 static void virgl_fence_reference(struct virgl_winsys *vws,
624 struct pipe_fence_handle **dst,
625 struct pipe_fence_handle *src)
626 {
627 struct virgl_vtest_winsys *vdws = virgl_vtest_winsys(vws);
628 virgl_vtest_resource_reference(&vdws->base, (struct virgl_hw_res **)dst,
629 virgl_hw_res(src));
630 }
631
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)632 static void virgl_vtest_flush_frontbuffer(struct virgl_winsys *vws,
633 struct virgl_hw_res *res,
634 unsigned level, unsigned layer,
635 void *winsys_drawable_handle,
636 struct pipe_box *sub_box)
637 {
638 struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
639 struct pipe_box box;
640 uint32_t offset = 0;
641 if (!res->dt)
642 return;
643
644 memset(&box, 0, sizeof(box));
645
646 if (sub_box) {
647 box = *sub_box;
648 uint32_t shm_stride = util_format_get_stride(res->format, res->width);
649 offset = box.y / util_format_get_blockheight(res->format) * shm_stride +
650 box.x / util_format_get_blockwidth(res->format) * util_format_get_blocksize(res->format);
651 } else {
652 box.z = layer;
653 box.width = res->width;
654 box.height = res->height;
655 box.depth = 1;
656 }
657
658 virgl_vtest_transfer_get_internal(vws, res, &box, res->stride, 0, offset,
659 level, true);
660
661 vtws->sws->displaytarget_display(vtws->sws, res->dt, winsys_drawable_handle,
662 sub_box);
663 }
664
665 static void
virgl_vtest_winsys_destroy(struct virgl_winsys * vws)666 virgl_vtest_winsys_destroy(struct virgl_winsys *vws)
667 {
668 struct virgl_vtest_winsys *vtws = virgl_vtest_winsys(vws);
669
670 virgl_resource_cache_flush(&vtws->cache);
671
672 mtx_destroy(&vtws->mutex);
673 FREE(vtws);
674 }
675
676 static bool
virgl_vtest_resource_cache_entry_is_busy(struct virgl_resource_cache_entry * entry,void * user_data)677 virgl_vtest_resource_cache_entry_is_busy(struct virgl_resource_cache_entry *entry,
678 void *user_data)
679 {
680 struct virgl_vtest_winsys *vtws = user_data;
681 struct virgl_hw_res *res = cache_entry_container_res(entry);
682
683 return virgl_vtest_resource_is_busy(&vtws->base, res);
684 }
685
686 static void
virgl_vtest_resource_cache_entry_release(struct virgl_resource_cache_entry * entry,void * user_data)687 virgl_vtest_resource_cache_entry_release(struct virgl_resource_cache_entry *entry,
688 void *user_data)
689 {
690 struct virgl_vtest_winsys *vtws = user_data;
691 struct virgl_hw_res *res = cache_entry_container_res(entry);
692
693 virgl_hw_res_destroy(vtws, res);
694 }
695
696 struct virgl_winsys *
virgl_vtest_winsys_wrap(struct sw_winsys * sws)697 virgl_vtest_winsys_wrap(struct sw_winsys *sws)
698 {
699 static const unsigned CACHE_TIMEOUT_USEC = 1000000;
700 struct virgl_vtest_winsys *vtws;
701
702 vtws = CALLOC_STRUCT(virgl_vtest_winsys);
703 if (!vtws)
704 return NULL;
705
706 virgl_vtest_connect(vtws);
707 vtws->sws = sws;
708
709 virgl_resource_cache_init(&vtws->cache, CACHE_TIMEOUT_USEC,
710 virgl_vtest_resource_cache_entry_is_busy,
711 virgl_vtest_resource_cache_entry_release,
712 vtws);
713 (void) mtx_init(&vtws->mutex, mtx_plain);
714
715 vtws->base.destroy = virgl_vtest_winsys_destroy;
716
717 vtws->base.transfer_put = virgl_vtest_transfer_put;
718 vtws->base.transfer_get = virgl_vtest_transfer_get;
719
720 vtws->base.resource_create = virgl_vtest_winsys_resource_cache_create;
721 vtws->base.resource_reference = virgl_vtest_resource_reference;
722 vtws->base.resource_map = virgl_vtest_resource_map;
723 vtws->base.resource_wait = virgl_vtest_resource_wait;
724 vtws->base.resource_is_busy = virgl_vtest_resource_is_busy;
725 vtws->base.cmd_buf_create = virgl_vtest_cmd_buf_create;
726 vtws->base.cmd_buf_destroy = virgl_vtest_cmd_buf_destroy;
727 vtws->base.submit_cmd = virgl_vtest_winsys_submit_cmd;
728
729 vtws->base.emit_res = virgl_vtest_emit_res;
730 vtws->base.res_is_referenced = virgl_vtest_res_is_ref;
731 vtws->base.get_caps = virgl_vtest_get_caps;
732
733 vtws->base.cs_create_fence = virgl_cs_create_fence;
734 vtws->base.fence_wait = virgl_fence_wait;
735 vtws->base.fence_reference = virgl_fence_reference;
736 vtws->base.supports_fences = 0;
737 vtws->base.supports_encoded_transfers = (vtws->protocol_version >= 2);
738
739 vtws->base.flush_frontbuffer = virgl_vtest_flush_frontbuffer;
740
741 return &vtws->base;
742 }
743