x86/xen: resume timer irqs early
[linux/fpc-iii.git] / drivers / gpu / drm / vmwgfx / vmwgfx_execbuf.c
blob1b9aa982257e66d32ba092a84c02e57a57f793cd
1 /**************************************************************************
3 * Copyright © 2009 VMware, Inc., Palo Alto, CA., USA
4 * All Rights Reserved.
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
16 * of the Software.
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
21 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
22 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
23 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
24 * USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
28 #include "vmwgfx_drv.h"
29 #include "vmwgfx_reg.h"
30 #include <drm/ttm/ttm_bo_api.h>
31 #include <drm/ttm/ttm_placement.h>
33 #define VMW_RES_HT_ORDER 12
35 /**
36 * struct vmw_resource_relocation - Relocation info for resources
38 * @head: List head for the software context's relocation list.
39 * @res: Non-ref-counted pointer to the resource.
40 * @offset: Offset of 4 byte entries into the command buffer where the
41 * id that needs fixup is located.
43 struct vmw_resource_relocation {
44 struct list_head head;
45 const struct vmw_resource *res;
46 unsigned long offset;
49 /**
50 * struct vmw_resource_val_node - Validation info for resources
52 * @head: List head for the software context's resource list.
53 * @hash: Hash entry for quick resouce to val_node lookup.
54 * @res: Ref-counted pointer to the resource.
55 * @switch_backup: Boolean whether to switch backup buffer on unreserve.
56 * @new_backup: Refcounted pointer to the new backup buffer.
57 * @new_backup_offset: New backup buffer offset if @new_backup is non-NUll.
58 * @first_usage: Set to true the first time the resource is referenced in
59 * the command stream.
60 * @no_buffer_needed: Resources do not need to allocate buffer backup on
61 * reservation. The command stream will provide one.
63 struct vmw_resource_val_node {
64 struct list_head head;
65 struct drm_hash_item hash;
66 struct vmw_resource *res;
67 struct vmw_dma_buffer *new_backup;
68 unsigned long new_backup_offset;
69 bool first_usage;
70 bool no_buffer_needed;
73 /**
74 * vmw_resource_unreserve - unreserve resources previously reserved for
75 * command submission.
77 * @list_head: list of resources to unreserve.
78 * @backoff: Whether command submission failed.
80 static void vmw_resource_list_unreserve(struct list_head *list,
81 bool backoff)
83 struct vmw_resource_val_node *val;
85 list_for_each_entry(val, list, head) {
86 struct vmw_resource *res = val->res;
87 struct vmw_dma_buffer *new_backup =
88 backoff ? NULL : val->new_backup;
90 vmw_resource_unreserve(res, new_backup,
91 val->new_backup_offset);
92 vmw_dmabuf_unreference(&val->new_backup);
97 /**
98 * vmw_resource_val_add - Add a resource to the software context's
99 * resource list if it's not already on it.
101 * @sw_context: Pointer to the software context.
102 * @res: Pointer to the resource.
103 * @p_node On successful return points to a valid pointer to a
104 * struct vmw_resource_val_node, if non-NULL on entry.
106 static int vmw_resource_val_add(struct vmw_sw_context *sw_context,
107 struct vmw_resource *res,
108 struct vmw_resource_val_node **p_node)
110 struct vmw_resource_val_node *node;
111 struct drm_hash_item *hash;
112 int ret;
114 if (likely(drm_ht_find_item(&sw_context->res_ht, (unsigned long) res,
115 &hash) == 0)) {
116 node = container_of(hash, struct vmw_resource_val_node, hash);
117 node->first_usage = false;
118 if (unlikely(p_node != NULL))
119 *p_node = node;
120 return 0;
123 node = kzalloc(sizeof(*node), GFP_KERNEL);
124 if (unlikely(node == NULL)) {
125 DRM_ERROR("Failed to allocate a resource validation "
126 "entry.\n");
127 return -ENOMEM;
130 node->hash.key = (unsigned long) res;
131 ret = drm_ht_insert_item(&sw_context->res_ht, &node->hash);
132 if (unlikely(ret != 0)) {
133 DRM_ERROR("Failed to initialize a resource validation "
134 "entry.\n");
135 kfree(node);
136 return ret;
138 list_add_tail(&node->head, &sw_context->resource_list);
139 node->res = vmw_resource_reference(res);
140 node->first_usage = true;
142 if (unlikely(p_node != NULL))
143 *p_node = node;
145 return 0;
149 * vmw_resource_relocation_add - Add a relocation to the relocation list
151 * @list: Pointer to head of relocation list.
152 * @res: The resource.
153 * @offset: Offset into the command buffer currently being parsed where the
154 * id that needs fixup is located. Granularity is 4 bytes.
156 static int vmw_resource_relocation_add(struct list_head *list,
157 const struct vmw_resource *res,
158 unsigned long offset)
160 struct vmw_resource_relocation *rel;
162 rel = kmalloc(sizeof(*rel), GFP_KERNEL);
163 if (unlikely(rel == NULL)) {
164 DRM_ERROR("Failed to allocate a resource relocation.\n");
165 return -ENOMEM;
168 rel->res = res;
169 rel->offset = offset;
170 list_add_tail(&rel->head, list);
172 return 0;
176 * vmw_resource_relocations_free - Free all relocations on a list
178 * @list: Pointer to the head of the relocation list.
180 static void vmw_resource_relocations_free(struct list_head *list)
182 struct vmw_resource_relocation *rel, *n;
184 list_for_each_entry_safe(rel, n, list, head) {
185 list_del(&rel->head);
186 kfree(rel);
191 * vmw_resource_relocations_apply - Apply all relocations on a list
193 * @cb: Pointer to the start of the command buffer bein patch. This need
194 * not be the same buffer as the one being parsed when the relocation
195 * list was built, but the contents must be the same modulo the
196 * resource ids.
197 * @list: Pointer to the head of the relocation list.
199 static void vmw_resource_relocations_apply(uint32_t *cb,
200 struct list_head *list)
202 struct vmw_resource_relocation *rel;
204 list_for_each_entry(rel, list, head)
205 cb[rel->offset] = rel->res->id;
208 static int vmw_cmd_invalid(struct vmw_private *dev_priv,
209 struct vmw_sw_context *sw_context,
210 SVGA3dCmdHeader *header)
212 return capable(CAP_SYS_ADMIN) ? : -EINVAL;
215 static int vmw_cmd_ok(struct vmw_private *dev_priv,
216 struct vmw_sw_context *sw_context,
217 SVGA3dCmdHeader *header)
219 return 0;
223 * vmw_bo_to_validate_list - add a bo to a validate list
225 * @sw_context: The software context used for this command submission batch.
226 * @bo: The buffer object to add.
227 * @p_val_node: If non-NULL Will be updated with the validate node number
228 * on return.
230 * Returns -EINVAL if the limit of number of buffer objects per command
231 * submission is reached.
233 static int vmw_bo_to_validate_list(struct vmw_sw_context *sw_context,
234 struct ttm_buffer_object *bo,
235 uint32_t *p_val_node)
237 uint32_t val_node;
238 struct vmw_validate_buffer *vval_buf;
239 struct ttm_validate_buffer *val_buf;
240 struct drm_hash_item *hash;
241 int ret;
243 if (likely(drm_ht_find_item(&sw_context->res_ht, (unsigned long) bo,
244 &hash) == 0)) {
245 vval_buf = container_of(hash, struct vmw_validate_buffer,
246 hash);
247 val_buf = &vval_buf->base;
248 val_node = vval_buf - sw_context->val_bufs;
249 } else {
250 val_node = sw_context->cur_val_buf;
251 if (unlikely(val_node >= VMWGFX_MAX_VALIDATIONS)) {
252 DRM_ERROR("Max number of DMA buffers per submission "
253 "exceeded.\n");
254 return -EINVAL;
256 vval_buf = &sw_context->val_bufs[val_node];
257 vval_buf->hash.key = (unsigned long) bo;
258 ret = drm_ht_insert_item(&sw_context->res_ht, &vval_buf->hash);
259 if (unlikely(ret != 0)) {
260 DRM_ERROR("Failed to initialize a buffer validation "
261 "entry.\n");
262 return ret;
264 ++sw_context->cur_val_buf;
265 val_buf = &vval_buf->base;
266 val_buf->bo = ttm_bo_reference(bo);
267 val_buf->reserved = false;
268 list_add_tail(&val_buf->head, &sw_context->validate_nodes);
271 sw_context->fence_flags |= DRM_VMW_FENCE_FLAG_EXEC;
273 if (p_val_node)
274 *p_val_node = val_node;
276 return 0;
280 * vmw_resources_reserve - Reserve all resources on the sw_context's
281 * resource list.
283 * @sw_context: Pointer to the software context.
285 * Note that since vmware's command submission currently is protected by
286 * the cmdbuf mutex, no fancy deadlock avoidance is required for resources,
287 * since only a single thread at once will attempt this.
289 static int vmw_resources_reserve(struct vmw_sw_context *sw_context)
291 struct vmw_resource_val_node *val;
292 int ret;
294 list_for_each_entry(val, &sw_context->resource_list, head) {
295 struct vmw_resource *res = val->res;
297 ret = vmw_resource_reserve(res, val->no_buffer_needed);
298 if (unlikely(ret != 0))
299 return ret;
301 if (res->backup) {
302 struct ttm_buffer_object *bo = &res->backup->base;
304 ret = vmw_bo_to_validate_list
305 (sw_context, bo, NULL);
307 if (unlikely(ret != 0))
308 return ret;
311 return 0;
315 * vmw_resources_validate - Validate all resources on the sw_context's
316 * resource list.
318 * @sw_context: Pointer to the software context.
320 * Before this function is called, all resource backup buffers must have
321 * been validated.
323 static int vmw_resources_validate(struct vmw_sw_context *sw_context)
325 struct vmw_resource_val_node *val;
326 int ret;
328 list_for_each_entry(val, &sw_context->resource_list, head) {
329 struct vmw_resource *res = val->res;
331 ret = vmw_resource_validate(res);
332 if (unlikely(ret != 0)) {
333 if (ret != -ERESTARTSYS)
334 DRM_ERROR("Failed to validate resource.\n");
335 return ret;
338 return 0;
342 * vmw_cmd_res_check - Check that a resource is present and if so, put it
343 * on the resource validate list unless it's already there.
345 * @dev_priv: Pointer to a device private structure.
346 * @sw_context: Pointer to the software context.
347 * @res_type: Resource type.
348 * @converter: User-space visisble type specific information.
349 * @id: Pointer to the location in the command buffer currently being
350 * parsed from where the user-space resource id handle is located.
352 static int vmw_cmd_res_check(struct vmw_private *dev_priv,
353 struct vmw_sw_context *sw_context,
354 enum vmw_res_type res_type,
355 const struct vmw_user_resource_conv *converter,
356 uint32_t *id,
357 struct vmw_resource_val_node **p_val)
359 struct vmw_res_cache_entry *rcache =
360 &sw_context->res_cache[res_type];
361 struct vmw_resource *res;
362 struct vmw_resource_val_node *node;
363 int ret;
365 if (*id == SVGA3D_INVALID_ID)
366 return 0;
369 * Fastpath in case of repeated commands referencing the same
370 * resource
373 if (likely(rcache->valid && *id == rcache->handle)) {
374 const struct vmw_resource *res = rcache->res;
376 rcache->node->first_usage = false;
377 if (p_val)
378 *p_val = rcache->node;
380 return vmw_resource_relocation_add
381 (&sw_context->res_relocations, res,
382 id - sw_context->buf_start);
385 ret = vmw_user_resource_lookup_handle(dev_priv,
386 sw_context->tfile,
387 *id,
388 converter,
389 &res);
390 if (unlikely(ret != 0)) {
391 DRM_ERROR("Could not find or use resource 0x%08x.\n",
392 (unsigned) *id);
393 dump_stack();
394 return ret;
397 rcache->valid = true;
398 rcache->res = res;
399 rcache->handle = *id;
401 ret = vmw_resource_relocation_add(&sw_context->res_relocations,
402 res,
403 id - sw_context->buf_start);
404 if (unlikely(ret != 0))
405 goto out_no_reloc;
407 ret = vmw_resource_val_add(sw_context, res, &node);
408 if (unlikely(ret != 0))
409 goto out_no_reloc;
411 rcache->node = node;
412 if (p_val)
413 *p_val = node;
414 vmw_resource_unreference(&res);
415 return 0;
417 out_no_reloc:
418 BUG_ON(sw_context->error_resource != NULL);
419 sw_context->error_resource = res;
421 return ret;
425 * vmw_cmd_cid_check - Check a command header for valid context information.
427 * @dev_priv: Pointer to a device private structure.
428 * @sw_context: Pointer to the software context.
429 * @header: A command header with an embedded user-space context handle.
431 * Convenience function: Call vmw_cmd_res_check with the user-space context
432 * handle embedded in @header.
434 static int vmw_cmd_cid_check(struct vmw_private *dev_priv,
435 struct vmw_sw_context *sw_context,
436 SVGA3dCmdHeader *header)
438 struct vmw_cid_cmd {
439 SVGA3dCmdHeader header;
440 __le32 cid;
441 } *cmd;
443 cmd = container_of(header, struct vmw_cid_cmd, header);
444 return vmw_cmd_res_check(dev_priv, sw_context, vmw_res_context,
445 user_context_converter, &cmd->cid, NULL);
448 static int vmw_cmd_set_render_target_check(struct vmw_private *dev_priv,
449 struct vmw_sw_context *sw_context,
450 SVGA3dCmdHeader *header)
452 struct vmw_sid_cmd {
453 SVGA3dCmdHeader header;
454 SVGA3dCmdSetRenderTarget body;
455 } *cmd;
456 int ret;
458 ret = vmw_cmd_cid_check(dev_priv, sw_context, header);
459 if (unlikely(ret != 0))
460 return ret;
462 cmd = container_of(header, struct vmw_sid_cmd, header);
463 ret = vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface,
464 user_surface_converter,
465 &cmd->body.target.sid, NULL);
466 return ret;
469 static int vmw_cmd_surface_copy_check(struct vmw_private *dev_priv,
470 struct vmw_sw_context *sw_context,
471 SVGA3dCmdHeader *header)
473 struct vmw_sid_cmd {
474 SVGA3dCmdHeader header;
475 SVGA3dCmdSurfaceCopy body;
476 } *cmd;
477 int ret;
479 cmd = container_of(header, struct vmw_sid_cmd, header);
480 ret = vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface,
481 user_surface_converter,
482 &cmd->body.src.sid, NULL);
483 if (unlikely(ret != 0))
484 return ret;
485 return vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface,
486 user_surface_converter,
487 &cmd->body.dest.sid, NULL);
490 static int vmw_cmd_stretch_blt_check(struct vmw_private *dev_priv,
491 struct vmw_sw_context *sw_context,
492 SVGA3dCmdHeader *header)
494 struct vmw_sid_cmd {
495 SVGA3dCmdHeader header;
496 SVGA3dCmdSurfaceStretchBlt body;
497 } *cmd;
498 int ret;
500 cmd = container_of(header, struct vmw_sid_cmd, header);
501 ret = vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface,
502 user_surface_converter,
503 &cmd->body.src.sid, NULL);
504 if (unlikely(ret != 0))
505 return ret;
506 return vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface,
507 user_surface_converter,
508 &cmd->body.dest.sid, NULL);
511 static int vmw_cmd_blt_surf_screen_check(struct vmw_private *dev_priv,
512 struct vmw_sw_context *sw_context,
513 SVGA3dCmdHeader *header)
515 struct vmw_sid_cmd {
516 SVGA3dCmdHeader header;
517 SVGA3dCmdBlitSurfaceToScreen body;
518 } *cmd;
520 cmd = container_of(header, struct vmw_sid_cmd, header);
522 if (unlikely(!sw_context->kernel)) {
523 DRM_ERROR("Kernel only SVGA3d command: %u.\n", cmd->header.id);
524 return -EPERM;
527 return vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface,
528 user_surface_converter,
529 &cmd->body.srcImage.sid, NULL);
532 static int vmw_cmd_present_check(struct vmw_private *dev_priv,
533 struct vmw_sw_context *sw_context,
534 SVGA3dCmdHeader *header)
536 struct vmw_sid_cmd {
537 SVGA3dCmdHeader header;
538 SVGA3dCmdPresent body;
539 } *cmd;
542 cmd = container_of(header, struct vmw_sid_cmd, header);
544 if (unlikely(!sw_context->kernel)) {
545 DRM_ERROR("Kernel only SVGA3d command: %u.\n", cmd->header.id);
546 return -EPERM;
549 return vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface,
550 user_surface_converter, &cmd->body.sid,
551 NULL);
555 * vmw_query_bo_switch_prepare - Prepare to switch pinned buffer for queries.
557 * @dev_priv: The device private structure.
558 * @new_query_bo: The new buffer holding query results.
559 * @sw_context: The software context used for this command submission.
561 * This function checks whether @new_query_bo is suitable for holding
562 * query results, and if another buffer currently is pinned for query
563 * results. If so, the function prepares the state of @sw_context for
564 * switching pinned buffers after successful submission of the current
565 * command batch.
567 static int vmw_query_bo_switch_prepare(struct vmw_private *dev_priv,
568 struct ttm_buffer_object *new_query_bo,
569 struct vmw_sw_context *sw_context)
571 struct vmw_res_cache_entry *ctx_entry =
572 &sw_context->res_cache[vmw_res_context];
573 int ret;
575 BUG_ON(!ctx_entry->valid);
576 sw_context->last_query_ctx = ctx_entry->res;
578 if (unlikely(new_query_bo != sw_context->cur_query_bo)) {
580 if (unlikely(new_query_bo->num_pages > 4)) {
581 DRM_ERROR("Query buffer too large.\n");
582 return -EINVAL;
585 if (unlikely(sw_context->cur_query_bo != NULL)) {
586 sw_context->needs_post_query_barrier = true;
587 ret = vmw_bo_to_validate_list(sw_context,
588 sw_context->cur_query_bo,
589 NULL);
590 if (unlikely(ret != 0))
591 return ret;
593 sw_context->cur_query_bo = new_query_bo;
595 ret = vmw_bo_to_validate_list(sw_context,
596 dev_priv->dummy_query_bo,
597 NULL);
598 if (unlikely(ret != 0))
599 return ret;
603 return 0;
608 * vmw_query_bo_switch_commit - Finalize switching pinned query buffer
610 * @dev_priv: The device private structure.
611 * @sw_context: The software context used for this command submission batch.
613 * This function will check if we're switching query buffers, and will then,
614 * issue a dummy occlusion query wait used as a query barrier. When the fence
615 * object following that query wait has signaled, we are sure that all
616 * preceding queries have finished, and the old query buffer can be unpinned.
617 * However, since both the new query buffer and the old one are fenced with
618 * that fence, we can do an asynchronus unpin now, and be sure that the
619 * old query buffer won't be moved until the fence has signaled.
621 * As mentioned above, both the new - and old query buffers need to be fenced
622 * using a sequence emitted *after* calling this function.
624 static void vmw_query_bo_switch_commit(struct vmw_private *dev_priv,
625 struct vmw_sw_context *sw_context)
628 * The validate list should still hold references to all
629 * contexts here.
632 if (sw_context->needs_post_query_barrier) {
633 struct vmw_res_cache_entry *ctx_entry =
634 &sw_context->res_cache[vmw_res_context];
635 struct vmw_resource *ctx;
636 int ret;
638 BUG_ON(!ctx_entry->valid);
639 ctx = ctx_entry->res;
641 ret = vmw_fifo_emit_dummy_query(dev_priv, ctx->id);
643 if (unlikely(ret != 0))
644 DRM_ERROR("Out of fifo space for dummy query.\n");
647 if (dev_priv->pinned_bo != sw_context->cur_query_bo) {
648 if (dev_priv->pinned_bo) {
649 vmw_bo_pin(dev_priv->pinned_bo, false);
650 ttm_bo_unref(&dev_priv->pinned_bo);
653 if (!sw_context->needs_post_query_barrier) {
654 vmw_bo_pin(sw_context->cur_query_bo, true);
657 * We pin also the dummy_query_bo buffer so that we
658 * don't need to validate it when emitting
659 * dummy queries in context destroy paths.
662 vmw_bo_pin(dev_priv->dummy_query_bo, true);
663 dev_priv->dummy_query_bo_pinned = true;
665 BUG_ON(sw_context->last_query_ctx == NULL);
666 dev_priv->query_cid = sw_context->last_query_ctx->id;
667 dev_priv->query_cid_valid = true;
668 dev_priv->pinned_bo =
669 ttm_bo_reference(sw_context->cur_query_bo);
675 * vmw_translate_guest_pointer - Prepare to translate a user-space buffer
676 * handle to a valid SVGAGuestPtr
678 * @dev_priv: Pointer to a device private structure.
679 * @sw_context: The software context used for this command batch validation.
680 * @ptr: Pointer to the user-space handle to be translated.
681 * @vmw_bo_p: Points to a location that, on successful return will carry
682 * a reference-counted pointer to the DMA buffer identified by the
683 * user-space handle in @id.
685 * This function saves information needed to translate a user-space buffer
686 * handle to a valid SVGAGuestPtr. The translation does not take place
687 * immediately, but during a call to vmw_apply_relocations().
688 * This function builds a relocation list and a list of buffers to validate.
689 * The former needs to be freed using either vmw_apply_relocations() or
690 * vmw_free_relocations(). The latter needs to be freed using
691 * vmw_clear_validations.
693 static int vmw_translate_guest_ptr(struct vmw_private *dev_priv,
694 struct vmw_sw_context *sw_context,
695 SVGAGuestPtr *ptr,
696 struct vmw_dma_buffer **vmw_bo_p)
698 struct vmw_dma_buffer *vmw_bo = NULL;
699 struct ttm_buffer_object *bo;
700 uint32_t handle = ptr->gmrId;
701 struct vmw_relocation *reloc;
702 int ret;
704 ret = vmw_user_dmabuf_lookup(sw_context->tfile, handle, &vmw_bo);
705 if (unlikely(ret != 0)) {
706 DRM_ERROR("Could not find or use GMR region.\n");
707 return -EINVAL;
709 bo = &vmw_bo->base;
711 if (unlikely(sw_context->cur_reloc >= VMWGFX_MAX_RELOCATIONS)) {
712 DRM_ERROR("Max number relocations per submission"
713 " exceeded\n");
714 ret = -EINVAL;
715 goto out_no_reloc;
718 reloc = &sw_context->relocs[sw_context->cur_reloc++];
719 reloc->location = ptr;
721 ret = vmw_bo_to_validate_list(sw_context, bo, &reloc->index);
722 if (unlikely(ret != 0))
723 goto out_no_reloc;
725 *vmw_bo_p = vmw_bo;
726 return 0;
728 out_no_reloc:
729 vmw_dmabuf_unreference(&vmw_bo);
730 vmw_bo_p = NULL;
731 return ret;
735 * vmw_cmd_begin_query - validate a SVGA_3D_CMD_BEGIN_QUERY command.
737 * @dev_priv: Pointer to a device private struct.
738 * @sw_context: The software context used for this command submission.
739 * @header: Pointer to the command header in the command stream.
741 static int vmw_cmd_begin_query(struct vmw_private *dev_priv,
742 struct vmw_sw_context *sw_context,
743 SVGA3dCmdHeader *header)
745 struct vmw_begin_query_cmd {
746 SVGA3dCmdHeader header;
747 SVGA3dCmdBeginQuery q;
748 } *cmd;
750 cmd = container_of(header, struct vmw_begin_query_cmd,
751 header);
753 return vmw_cmd_res_check(dev_priv, sw_context, vmw_res_context,
754 user_context_converter, &cmd->q.cid,
755 NULL);
759 * vmw_cmd_end_query - validate a SVGA_3D_CMD_END_QUERY command.
761 * @dev_priv: Pointer to a device private struct.
762 * @sw_context: The software context used for this command submission.
763 * @header: Pointer to the command header in the command stream.
765 static int vmw_cmd_end_query(struct vmw_private *dev_priv,
766 struct vmw_sw_context *sw_context,
767 SVGA3dCmdHeader *header)
769 struct vmw_dma_buffer *vmw_bo;
770 struct vmw_query_cmd {
771 SVGA3dCmdHeader header;
772 SVGA3dCmdEndQuery q;
773 } *cmd;
774 int ret;
776 cmd = container_of(header, struct vmw_query_cmd, header);
777 ret = vmw_cmd_cid_check(dev_priv, sw_context, header);
778 if (unlikely(ret != 0))
779 return ret;
781 ret = vmw_translate_guest_ptr(dev_priv, sw_context,
782 &cmd->q.guestResult,
783 &vmw_bo);
784 if (unlikely(ret != 0))
785 return ret;
787 ret = vmw_query_bo_switch_prepare(dev_priv, &vmw_bo->base, sw_context);
789 vmw_dmabuf_unreference(&vmw_bo);
790 return ret;
794 * vmw_cmd_wait_query - validate a SVGA_3D_CMD_WAIT_QUERY command.
796 * @dev_priv: Pointer to a device private struct.
797 * @sw_context: The software context used for this command submission.
798 * @header: Pointer to the command header in the command stream.
800 static int vmw_cmd_wait_query(struct vmw_private *dev_priv,
801 struct vmw_sw_context *sw_context,
802 SVGA3dCmdHeader *header)
804 struct vmw_dma_buffer *vmw_bo;
805 struct vmw_query_cmd {
806 SVGA3dCmdHeader header;
807 SVGA3dCmdWaitForQuery q;
808 } *cmd;
809 int ret;
811 cmd = container_of(header, struct vmw_query_cmd, header);
812 ret = vmw_cmd_cid_check(dev_priv, sw_context, header);
813 if (unlikely(ret != 0))
814 return ret;
816 ret = vmw_translate_guest_ptr(dev_priv, sw_context,
817 &cmd->q.guestResult,
818 &vmw_bo);
819 if (unlikely(ret != 0))
820 return ret;
822 vmw_dmabuf_unreference(&vmw_bo);
823 return 0;
826 static int vmw_cmd_dma(struct vmw_private *dev_priv,
827 struct vmw_sw_context *sw_context,
828 SVGA3dCmdHeader *header)
830 struct vmw_dma_buffer *vmw_bo = NULL;
831 struct vmw_surface *srf = NULL;
832 struct vmw_dma_cmd {
833 SVGA3dCmdHeader header;
834 SVGA3dCmdSurfaceDMA dma;
835 } *cmd;
836 int ret;
837 SVGA3dCmdSurfaceDMASuffix *suffix;
838 uint32_t bo_size;
840 cmd = container_of(header, struct vmw_dma_cmd, header);
841 suffix = (SVGA3dCmdSurfaceDMASuffix *)((unsigned long) &cmd->dma +
842 header->size - sizeof(*suffix));
844 /* Make sure device and verifier stays in sync. */
845 if (unlikely(suffix->suffixSize != sizeof(*suffix))) {
846 DRM_ERROR("Invalid DMA suffix size.\n");
847 return -EINVAL;
850 ret = vmw_translate_guest_ptr(dev_priv, sw_context,
851 &cmd->dma.guest.ptr,
852 &vmw_bo);
853 if (unlikely(ret != 0))
854 return ret;
856 /* Make sure DMA doesn't cross BO boundaries. */
857 bo_size = vmw_bo->base.num_pages * PAGE_SIZE;
858 if (unlikely(cmd->dma.guest.ptr.offset > bo_size)) {
859 DRM_ERROR("Invalid DMA offset.\n");
860 return -EINVAL;
863 bo_size -= cmd->dma.guest.ptr.offset;
864 if (unlikely(suffix->maximumOffset > bo_size))
865 suffix->maximumOffset = bo_size;
867 ret = vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface,
868 user_surface_converter, &cmd->dma.host.sid,
869 NULL);
870 if (unlikely(ret != 0)) {
871 if (unlikely(ret != -ERESTARTSYS))
872 DRM_ERROR("could not find surface for DMA.\n");
873 goto out_no_surface;
876 srf = vmw_res_to_srf(sw_context->res_cache[vmw_res_surface].res);
878 vmw_kms_cursor_snoop(srf, sw_context->tfile, &vmw_bo->base, header);
880 out_no_surface:
881 vmw_dmabuf_unreference(&vmw_bo);
882 return ret;
885 static int vmw_cmd_draw(struct vmw_private *dev_priv,
886 struct vmw_sw_context *sw_context,
887 SVGA3dCmdHeader *header)
889 struct vmw_draw_cmd {
890 SVGA3dCmdHeader header;
891 SVGA3dCmdDrawPrimitives body;
892 } *cmd;
893 SVGA3dVertexDecl *decl = (SVGA3dVertexDecl *)(
894 (unsigned long)header + sizeof(*cmd));
895 SVGA3dPrimitiveRange *range;
896 uint32_t i;
897 uint32_t maxnum;
898 int ret;
900 ret = vmw_cmd_cid_check(dev_priv, sw_context, header);
901 if (unlikely(ret != 0))
902 return ret;
904 cmd = container_of(header, struct vmw_draw_cmd, header);
905 maxnum = (header->size - sizeof(cmd->body)) / sizeof(*decl);
907 if (unlikely(cmd->body.numVertexDecls > maxnum)) {
908 DRM_ERROR("Illegal number of vertex declarations.\n");
909 return -EINVAL;
912 for (i = 0; i < cmd->body.numVertexDecls; ++i, ++decl) {
913 ret = vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface,
914 user_surface_converter,
915 &decl->array.surfaceId, NULL);
916 if (unlikely(ret != 0))
917 return ret;
920 maxnum = (header->size - sizeof(cmd->body) -
921 cmd->body.numVertexDecls * sizeof(*decl)) / sizeof(*range);
922 if (unlikely(cmd->body.numRanges > maxnum)) {
923 DRM_ERROR("Illegal number of index ranges.\n");
924 return -EINVAL;
927 range = (SVGA3dPrimitiveRange *) decl;
928 for (i = 0; i < cmd->body.numRanges; ++i, ++range) {
929 ret = vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface,
930 user_surface_converter,
931 &range->indexArray.surfaceId, NULL);
932 if (unlikely(ret != 0))
933 return ret;
935 return 0;
939 static int vmw_cmd_tex_state(struct vmw_private *dev_priv,
940 struct vmw_sw_context *sw_context,
941 SVGA3dCmdHeader *header)
943 struct vmw_tex_state_cmd {
944 SVGA3dCmdHeader header;
945 SVGA3dCmdSetTextureState state;
948 SVGA3dTextureState *last_state = (SVGA3dTextureState *)
949 ((unsigned long) header + header->size + sizeof(header));
950 SVGA3dTextureState *cur_state = (SVGA3dTextureState *)
951 ((unsigned long) header + sizeof(struct vmw_tex_state_cmd));
952 int ret;
954 ret = vmw_cmd_cid_check(dev_priv, sw_context, header);
955 if (unlikely(ret != 0))
956 return ret;
958 for (; cur_state < last_state; ++cur_state) {
959 if (likely(cur_state->name != SVGA3D_TS_BIND_TEXTURE))
960 continue;
962 ret = vmw_cmd_res_check(dev_priv, sw_context, vmw_res_surface,
963 user_surface_converter,
964 &cur_state->value, NULL);
965 if (unlikely(ret != 0))
966 return ret;
969 return 0;
972 static int vmw_cmd_check_define_gmrfb(struct vmw_private *dev_priv,
973 struct vmw_sw_context *sw_context,
974 void *buf)
976 struct vmw_dma_buffer *vmw_bo;
977 int ret;
979 struct {
980 uint32_t header;
981 SVGAFifoCmdDefineGMRFB body;
982 } *cmd = buf;
984 ret = vmw_translate_guest_ptr(dev_priv, sw_context,
985 &cmd->body.ptr,
986 &vmw_bo);
987 if (unlikely(ret != 0))
988 return ret;
990 vmw_dmabuf_unreference(&vmw_bo);
992 return ret;
996 * vmw_cmd_set_shader - Validate an SVGA_3D_CMD_SET_SHADER
997 * command
999 * @dev_priv: Pointer to a device private struct.
1000 * @sw_context: The software context being used for this batch.
1001 * @header: Pointer to the command header in the command stream.
1003 static int vmw_cmd_set_shader(struct vmw_private *dev_priv,
1004 struct vmw_sw_context *sw_context,
1005 SVGA3dCmdHeader *header)
1007 struct vmw_set_shader_cmd {
1008 SVGA3dCmdHeader header;
1009 SVGA3dCmdSetShader body;
1010 } *cmd;
1011 int ret;
1013 cmd = container_of(header, struct vmw_set_shader_cmd,
1014 header);
1016 ret = vmw_cmd_cid_check(dev_priv, sw_context, header);
1017 if (unlikely(ret != 0))
1018 return ret;
1020 return 0;
1023 static int vmw_cmd_check_not_3d(struct vmw_private *dev_priv,
1024 struct vmw_sw_context *sw_context,
1025 void *buf, uint32_t *size)
1027 uint32_t size_remaining = *size;
1028 uint32_t cmd_id;
1030 cmd_id = le32_to_cpu(((uint32_t *)buf)[0]);
1031 switch (cmd_id) {
1032 case SVGA_CMD_UPDATE:
1033 *size = sizeof(uint32_t) + sizeof(SVGAFifoCmdUpdate);
1034 break;
1035 case SVGA_CMD_DEFINE_GMRFB:
1036 *size = sizeof(uint32_t) + sizeof(SVGAFifoCmdDefineGMRFB);
1037 break;
1038 case SVGA_CMD_BLIT_GMRFB_TO_SCREEN:
1039 *size = sizeof(uint32_t) + sizeof(SVGAFifoCmdBlitGMRFBToScreen);
1040 break;
1041 case SVGA_CMD_BLIT_SCREEN_TO_GMRFB:
1042 *size = sizeof(uint32_t) + sizeof(SVGAFifoCmdBlitGMRFBToScreen);
1043 break;
1044 default:
1045 DRM_ERROR("Unsupported SVGA command: %u.\n", cmd_id);
1046 return -EINVAL;
1049 if (*size > size_remaining) {
1050 DRM_ERROR("Invalid SVGA command (size mismatch):"
1051 " %u.\n", cmd_id);
1052 return -EINVAL;
1055 if (unlikely(!sw_context->kernel)) {
1056 DRM_ERROR("Kernel only SVGA command: %u.\n", cmd_id);
1057 return -EPERM;
1060 if (cmd_id == SVGA_CMD_DEFINE_GMRFB)
1061 return vmw_cmd_check_define_gmrfb(dev_priv, sw_context, buf);
1063 return 0;
1066 typedef int (*vmw_cmd_func) (struct vmw_private *,
1067 struct vmw_sw_context *,
1068 SVGA3dCmdHeader *);
1070 #define VMW_CMD_DEF(cmd, func) \
1071 [cmd - SVGA_3D_CMD_BASE] = func
1073 static vmw_cmd_func vmw_cmd_funcs[SVGA_3D_CMD_MAX] = {
1074 VMW_CMD_DEF(SVGA_3D_CMD_SURFACE_DEFINE, &vmw_cmd_invalid),
1075 VMW_CMD_DEF(SVGA_3D_CMD_SURFACE_DESTROY, &vmw_cmd_invalid),
1076 VMW_CMD_DEF(SVGA_3D_CMD_SURFACE_COPY, &vmw_cmd_surface_copy_check),
1077 VMW_CMD_DEF(SVGA_3D_CMD_SURFACE_STRETCHBLT, &vmw_cmd_stretch_blt_check),
1078 VMW_CMD_DEF(SVGA_3D_CMD_SURFACE_DMA, &vmw_cmd_dma),
1079 VMW_CMD_DEF(SVGA_3D_CMD_CONTEXT_DEFINE, &vmw_cmd_invalid),
1080 VMW_CMD_DEF(SVGA_3D_CMD_CONTEXT_DESTROY, &vmw_cmd_invalid),
1081 VMW_CMD_DEF(SVGA_3D_CMD_SETTRANSFORM, &vmw_cmd_cid_check),
1082 VMW_CMD_DEF(SVGA_3D_CMD_SETZRANGE, &vmw_cmd_cid_check),
1083 VMW_CMD_DEF(SVGA_3D_CMD_SETRENDERSTATE, &vmw_cmd_cid_check),
1084 VMW_CMD_DEF(SVGA_3D_CMD_SETRENDERTARGET,
1085 &vmw_cmd_set_render_target_check),
1086 VMW_CMD_DEF(SVGA_3D_CMD_SETTEXTURESTATE, &vmw_cmd_tex_state),
1087 VMW_CMD_DEF(SVGA_3D_CMD_SETMATERIAL, &vmw_cmd_cid_check),
1088 VMW_CMD_DEF(SVGA_3D_CMD_SETLIGHTDATA, &vmw_cmd_cid_check),
1089 VMW_CMD_DEF(SVGA_3D_CMD_SETLIGHTENABLED, &vmw_cmd_cid_check),
1090 VMW_CMD_DEF(SVGA_3D_CMD_SETVIEWPORT, &vmw_cmd_cid_check),
1091 VMW_CMD_DEF(SVGA_3D_CMD_SETCLIPPLANE, &vmw_cmd_cid_check),
1092 VMW_CMD_DEF(SVGA_3D_CMD_CLEAR, &vmw_cmd_cid_check),
1093 VMW_CMD_DEF(SVGA_3D_CMD_PRESENT, &vmw_cmd_present_check),
1094 VMW_CMD_DEF(SVGA_3D_CMD_SHADER_DEFINE, &vmw_cmd_cid_check),
1095 VMW_CMD_DEF(SVGA_3D_CMD_SHADER_DESTROY, &vmw_cmd_cid_check),
1096 VMW_CMD_DEF(SVGA_3D_CMD_SET_SHADER, &vmw_cmd_set_shader),
1097 VMW_CMD_DEF(SVGA_3D_CMD_SET_SHADER_CONST, &vmw_cmd_cid_check),
1098 VMW_CMD_DEF(SVGA_3D_CMD_DRAW_PRIMITIVES, &vmw_cmd_draw),
1099 VMW_CMD_DEF(SVGA_3D_CMD_SETSCISSORRECT, &vmw_cmd_cid_check),
1100 VMW_CMD_DEF(SVGA_3D_CMD_BEGIN_QUERY, &vmw_cmd_begin_query),
1101 VMW_CMD_DEF(SVGA_3D_CMD_END_QUERY, &vmw_cmd_end_query),
1102 VMW_CMD_DEF(SVGA_3D_CMD_WAIT_FOR_QUERY, &vmw_cmd_wait_query),
1103 VMW_CMD_DEF(SVGA_3D_CMD_PRESENT_READBACK, &vmw_cmd_ok),
1104 VMW_CMD_DEF(SVGA_3D_CMD_BLIT_SURFACE_TO_SCREEN,
1105 &vmw_cmd_blt_surf_screen_check),
1106 VMW_CMD_DEF(SVGA_3D_CMD_SURFACE_DEFINE_V2, &vmw_cmd_invalid),
1107 VMW_CMD_DEF(SVGA_3D_CMD_GENERATE_MIPMAPS, &vmw_cmd_invalid),
1108 VMW_CMD_DEF(SVGA_3D_CMD_ACTIVATE_SURFACE, &vmw_cmd_invalid),
1109 VMW_CMD_DEF(SVGA_3D_CMD_DEACTIVATE_SURFACE, &vmw_cmd_invalid),
1112 static int vmw_cmd_check(struct vmw_private *dev_priv,
1113 struct vmw_sw_context *sw_context,
1114 void *buf, uint32_t *size)
1116 uint32_t cmd_id;
1117 uint32_t size_remaining = *size;
1118 SVGA3dCmdHeader *header = (SVGA3dCmdHeader *) buf;
1119 int ret;
1121 cmd_id = le32_to_cpu(((uint32_t *)buf)[0]);
1122 /* Handle any none 3D commands */
1123 if (unlikely(cmd_id < SVGA_CMD_MAX))
1124 return vmw_cmd_check_not_3d(dev_priv, sw_context, buf, size);
1127 cmd_id = le32_to_cpu(header->id);
1128 *size = le32_to_cpu(header->size) + sizeof(SVGA3dCmdHeader);
1130 cmd_id -= SVGA_3D_CMD_BASE;
1131 if (unlikely(*size > size_remaining))
1132 goto out_err;
1134 if (unlikely(cmd_id >= SVGA_3D_CMD_MAX - SVGA_3D_CMD_BASE))
1135 goto out_err;
1137 ret = vmw_cmd_funcs[cmd_id](dev_priv, sw_context, header);
1138 if (unlikely(ret != 0))
1139 goto out_err;
1141 return 0;
1142 out_err:
1143 DRM_ERROR("Illegal / Invalid SVGA3D command: %d\n",
1144 cmd_id + SVGA_3D_CMD_BASE);
1145 return -EINVAL;
1148 static int vmw_cmd_check_all(struct vmw_private *dev_priv,
1149 struct vmw_sw_context *sw_context,
1150 void *buf,
1151 uint32_t size)
1153 int32_t cur_size = size;
1154 int ret;
1156 sw_context->buf_start = buf;
1158 while (cur_size > 0) {
1159 size = cur_size;
1160 ret = vmw_cmd_check(dev_priv, sw_context, buf, &size);
1161 if (unlikely(ret != 0))
1162 return ret;
1163 buf = (void *)((unsigned long) buf + size);
1164 cur_size -= size;
1167 if (unlikely(cur_size != 0)) {
1168 DRM_ERROR("Command verifier out of sync.\n");
1169 return -EINVAL;
1172 return 0;
1175 static void vmw_free_relocations(struct vmw_sw_context *sw_context)
1177 sw_context->cur_reloc = 0;
1180 static void vmw_apply_relocations(struct vmw_sw_context *sw_context)
1182 uint32_t i;
1183 struct vmw_relocation *reloc;
1184 struct ttm_validate_buffer *validate;
1185 struct ttm_buffer_object *bo;
1187 for (i = 0; i < sw_context->cur_reloc; ++i) {
1188 reloc = &sw_context->relocs[i];
1189 validate = &sw_context->val_bufs[reloc->index].base;
1190 bo = validate->bo;
1191 switch (bo->mem.mem_type) {
1192 case TTM_PL_VRAM:
1193 reloc->location->offset += bo->offset;
1194 reloc->location->gmrId = SVGA_GMR_FRAMEBUFFER;
1195 break;
1196 case VMW_PL_GMR:
1197 reloc->location->gmrId = bo->mem.start;
1198 break;
1199 default:
1200 BUG();
1203 vmw_free_relocations(sw_context);
1207 * vmw_resource_list_unrefererence - Free up a resource list and unreference
1208 * all resources referenced by it.
1210 * @list: The resource list.
1212 static void vmw_resource_list_unreference(struct list_head *list)
1214 struct vmw_resource_val_node *val, *val_next;
1217 * Drop references to resources held during command submission.
1220 list_for_each_entry_safe(val, val_next, list, head) {
1221 list_del_init(&val->head);
1222 vmw_resource_unreference(&val->res);
1223 kfree(val);
1227 static void vmw_clear_validations(struct vmw_sw_context *sw_context)
1229 struct vmw_validate_buffer *entry, *next;
1230 struct vmw_resource_val_node *val;
1233 * Drop references to DMA buffers held during command submission.
1235 list_for_each_entry_safe(entry, next, &sw_context->validate_nodes,
1236 base.head) {
1237 list_del(&entry->base.head);
1238 ttm_bo_unref(&entry->base.bo);
1239 (void) drm_ht_remove_item(&sw_context->res_ht, &entry->hash);
1240 sw_context->cur_val_buf--;
1242 BUG_ON(sw_context->cur_val_buf != 0);
1244 list_for_each_entry(val, &sw_context->resource_list, head)
1245 (void) drm_ht_remove_item(&sw_context->res_ht, &val->hash);
1248 static int vmw_validate_single_buffer(struct vmw_private *dev_priv,
1249 struct ttm_buffer_object *bo)
1251 int ret;
1255 * Don't validate pinned buffers.
1258 if (bo == dev_priv->pinned_bo ||
1259 (bo == dev_priv->dummy_query_bo &&
1260 dev_priv->dummy_query_bo_pinned))
1261 return 0;
1264 * Put BO in VRAM if there is space, otherwise as a GMR.
1265 * If there is no space in VRAM and GMR ids are all used up,
1266 * start evicting GMRs to make room. If the DMA buffer can't be
1267 * used as a GMR, this will return -ENOMEM.
1270 ret = ttm_bo_validate(bo, &vmw_vram_gmr_placement, true, false);
1271 if (likely(ret == 0 || ret == -ERESTARTSYS))
1272 return ret;
1275 * If that failed, try VRAM again, this time evicting
1276 * previous contents.
1279 DRM_INFO("Falling through to VRAM.\n");
1280 ret = ttm_bo_validate(bo, &vmw_vram_placement, true, false);
1281 return ret;
1285 static int vmw_validate_buffers(struct vmw_private *dev_priv,
1286 struct vmw_sw_context *sw_context)
1288 struct vmw_validate_buffer *entry;
1289 int ret;
1291 list_for_each_entry(entry, &sw_context->validate_nodes, base.head) {
1292 ret = vmw_validate_single_buffer(dev_priv, entry->base.bo);
1293 if (unlikely(ret != 0))
1294 return ret;
1296 return 0;
1299 static int vmw_resize_cmd_bounce(struct vmw_sw_context *sw_context,
1300 uint32_t size)
1302 if (likely(sw_context->cmd_bounce_size >= size))
1303 return 0;
1305 if (sw_context->cmd_bounce_size == 0)
1306 sw_context->cmd_bounce_size = VMWGFX_CMD_BOUNCE_INIT_SIZE;
1308 while (sw_context->cmd_bounce_size < size) {
1309 sw_context->cmd_bounce_size =
1310 PAGE_ALIGN(sw_context->cmd_bounce_size +
1311 (sw_context->cmd_bounce_size >> 1));
1314 if (sw_context->cmd_bounce != NULL)
1315 vfree(sw_context->cmd_bounce);
1317 sw_context->cmd_bounce = vmalloc(sw_context->cmd_bounce_size);
1319 if (sw_context->cmd_bounce == NULL) {
1320 DRM_ERROR("Failed to allocate command bounce buffer.\n");
1321 sw_context->cmd_bounce_size = 0;
1322 return -ENOMEM;
1325 return 0;
1329 * vmw_execbuf_fence_commands - create and submit a command stream fence
1331 * Creates a fence object and submits a command stream marker.
1332 * If this fails for some reason, We sync the fifo and return NULL.
1333 * It is then safe to fence buffers with a NULL pointer.
1335 * If @p_handle is not NULL @file_priv must also not be NULL. Creates
1336 * a userspace handle if @p_handle is not NULL, otherwise not.
1339 int vmw_execbuf_fence_commands(struct drm_file *file_priv,
1340 struct vmw_private *dev_priv,
1341 struct vmw_fence_obj **p_fence,
1342 uint32_t *p_handle)
1344 uint32_t sequence;
1345 int ret;
1346 bool synced = false;
1348 /* p_handle implies file_priv. */
1349 BUG_ON(p_handle != NULL && file_priv == NULL);
1351 ret = vmw_fifo_send_fence(dev_priv, &sequence);
1352 if (unlikely(ret != 0)) {
1353 DRM_ERROR("Fence submission error. Syncing.\n");
1354 synced = true;
1357 if (p_handle != NULL)
1358 ret = vmw_user_fence_create(file_priv, dev_priv->fman,
1359 sequence,
1360 DRM_VMW_FENCE_FLAG_EXEC,
1361 p_fence, p_handle);
1362 else
1363 ret = vmw_fence_create(dev_priv->fman, sequence,
1364 DRM_VMW_FENCE_FLAG_EXEC,
1365 p_fence);
1367 if (unlikely(ret != 0 && !synced)) {
1368 (void) vmw_fallback_wait(dev_priv, false, false,
1369 sequence, false,
1370 VMW_FENCE_WAIT_TIMEOUT);
1371 *p_fence = NULL;
1374 return 0;
1378 * vmw_execbuf_copy_fence_user - copy fence object information to
1379 * user-space.
1381 * @dev_priv: Pointer to a vmw_private struct.
1382 * @vmw_fp: Pointer to the struct vmw_fpriv representing the calling file.
1383 * @ret: Return value from fence object creation.
1384 * @user_fence_rep: User space address of a struct drm_vmw_fence_rep to
1385 * which the information should be copied.
1386 * @fence: Pointer to the fenc object.
1387 * @fence_handle: User-space fence handle.
1389 * This function copies fence information to user-space. If copying fails,
1390 * The user-space struct drm_vmw_fence_rep::error member is hopefully
1391 * left untouched, and if it's preloaded with an -EFAULT by user-space,
1392 * the error will hopefully be detected.
1393 * Also if copying fails, user-space will be unable to signal the fence
1394 * object so we wait for it immediately, and then unreference the
1395 * user-space reference.
1397 void
1398 vmw_execbuf_copy_fence_user(struct vmw_private *dev_priv,
1399 struct vmw_fpriv *vmw_fp,
1400 int ret,
1401 struct drm_vmw_fence_rep __user *user_fence_rep,
1402 struct vmw_fence_obj *fence,
1403 uint32_t fence_handle)
1405 struct drm_vmw_fence_rep fence_rep;
1407 if (user_fence_rep == NULL)
1408 return;
1410 memset(&fence_rep, 0, sizeof(fence_rep));
1412 fence_rep.error = ret;
1413 if (ret == 0) {
1414 BUG_ON(fence == NULL);
1416 fence_rep.handle = fence_handle;
1417 fence_rep.seqno = fence->seqno;
1418 vmw_update_seqno(dev_priv, &dev_priv->fifo);
1419 fence_rep.passed_seqno = dev_priv->last_read_seqno;
1423 * copy_to_user errors will be detected by user space not
1424 * seeing fence_rep::error filled in. Typically
1425 * user-space would have pre-set that member to -EFAULT.
1427 ret = copy_to_user(user_fence_rep, &fence_rep,
1428 sizeof(fence_rep));
1431 * User-space lost the fence object. We need to sync
1432 * and unreference the handle.
1434 if (unlikely(ret != 0) && (fence_rep.error == 0)) {
1435 ttm_ref_object_base_unref(vmw_fp->tfile,
1436 fence_handle, TTM_REF_USAGE);
1437 DRM_ERROR("Fence copy error. Syncing.\n");
1438 (void) vmw_fence_obj_wait(fence, fence->signal_mask,
1439 false, false,
1440 VMW_FENCE_WAIT_TIMEOUT);
1444 int vmw_execbuf_process(struct drm_file *file_priv,
1445 struct vmw_private *dev_priv,
1446 void __user *user_commands,
1447 void *kernel_commands,
1448 uint32_t command_size,
1449 uint64_t throttle_us,
1450 struct drm_vmw_fence_rep __user *user_fence_rep,
1451 struct vmw_fence_obj **out_fence)
1453 struct vmw_sw_context *sw_context = &dev_priv->ctx;
1454 struct vmw_fence_obj *fence = NULL;
1455 struct vmw_resource *error_resource;
1456 struct list_head resource_list;
1457 struct ww_acquire_ctx ticket;
1458 uint32_t handle;
1459 void *cmd;
1460 int ret;
1462 ret = mutex_lock_interruptible(&dev_priv->cmdbuf_mutex);
1463 if (unlikely(ret != 0))
1464 return -ERESTARTSYS;
1466 if (kernel_commands == NULL) {
1467 sw_context->kernel = false;
1469 ret = vmw_resize_cmd_bounce(sw_context, command_size);
1470 if (unlikely(ret != 0))
1471 goto out_unlock;
1474 ret = copy_from_user(sw_context->cmd_bounce,
1475 user_commands, command_size);
1477 if (unlikely(ret != 0)) {
1478 ret = -EFAULT;
1479 DRM_ERROR("Failed copying commands.\n");
1480 goto out_unlock;
1482 kernel_commands = sw_context->cmd_bounce;
1483 } else
1484 sw_context->kernel = true;
1486 sw_context->tfile = vmw_fpriv(file_priv)->tfile;
1487 sw_context->cur_reloc = 0;
1488 sw_context->cur_val_buf = 0;
1489 sw_context->fence_flags = 0;
1490 INIT_LIST_HEAD(&sw_context->resource_list);
1491 sw_context->cur_query_bo = dev_priv->pinned_bo;
1492 sw_context->last_query_ctx = NULL;
1493 sw_context->needs_post_query_barrier = false;
1494 memset(sw_context->res_cache, 0, sizeof(sw_context->res_cache));
1495 INIT_LIST_HEAD(&sw_context->validate_nodes);
1496 INIT_LIST_HEAD(&sw_context->res_relocations);
1497 if (!sw_context->res_ht_initialized) {
1498 ret = drm_ht_create(&sw_context->res_ht, VMW_RES_HT_ORDER);
1499 if (unlikely(ret != 0))
1500 goto out_unlock;
1501 sw_context->res_ht_initialized = true;
1504 INIT_LIST_HEAD(&resource_list);
1505 ret = vmw_cmd_check_all(dev_priv, sw_context, kernel_commands,
1506 command_size);
1507 if (unlikely(ret != 0))
1508 goto out_err_nores;
1510 ret = vmw_resources_reserve(sw_context);
1511 if (unlikely(ret != 0))
1512 goto out_err_nores;
1514 ret = ttm_eu_reserve_buffers(&ticket, &sw_context->validate_nodes);
1515 if (unlikely(ret != 0))
1516 goto out_err;
1518 ret = vmw_validate_buffers(dev_priv, sw_context);
1519 if (unlikely(ret != 0))
1520 goto out_err;
1522 ret = vmw_resources_validate(sw_context);
1523 if (unlikely(ret != 0))
1524 goto out_err;
1526 if (throttle_us) {
1527 ret = vmw_wait_lag(dev_priv, &dev_priv->fifo.marker_queue,
1528 throttle_us);
1530 if (unlikely(ret != 0))
1531 goto out_err;
1534 cmd = vmw_fifo_reserve(dev_priv, command_size);
1535 if (unlikely(cmd == NULL)) {
1536 DRM_ERROR("Failed reserving fifo space for commands.\n");
1537 ret = -ENOMEM;
1538 goto out_err;
1541 vmw_apply_relocations(sw_context);
1542 memcpy(cmd, kernel_commands, command_size);
1544 vmw_resource_relocations_apply(cmd, &sw_context->res_relocations);
1545 vmw_resource_relocations_free(&sw_context->res_relocations);
1547 vmw_fifo_commit(dev_priv, command_size);
1549 vmw_query_bo_switch_commit(dev_priv, sw_context);
1550 ret = vmw_execbuf_fence_commands(file_priv, dev_priv,
1551 &fence,
1552 (user_fence_rep) ? &handle : NULL);
1554 * This error is harmless, because if fence submission fails,
1555 * vmw_fifo_send_fence will sync. The error will be propagated to
1556 * user-space in @fence_rep
1559 if (ret != 0)
1560 DRM_ERROR("Fence submission error. Syncing.\n");
1562 vmw_resource_list_unreserve(&sw_context->resource_list, false);
1563 ttm_eu_fence_buffer_objects(&ticket, &sw_context->validate_nodes,
1564 (void *) fence);
1566 if (unlikely(dev_priv->pinned_bo != NULL &&
1567 !dev_priv->query_cid_valid))
1568 __vmw_execbuf_release_pinned_bo(dev_priv, fence);
1570 vmw_clear_validations(sw_context);
1571 vmw_execbuf_copy_fence_user(dev_priv, vmw_fpriv(file_priv), ret,
1572 user_fence_rep, fence, handle);
1574 /* Don't unreference when handing fence out */
1575 if (unlikely(out_fence != NULL)) {
1576 *out_fence = fence;
1577 fence = NULL;
1578 } else if (likely(fence != NULL)) {
1579 vmw_fence_obj_unreference(&fence);
1582 list_splice_init(&sw_context->resource_list, &resource_list);
1583 mutex_unlock(&dev_priv->cmdbuf_mutex);
1586 * Unreference resources outside of the cmdbuf_mutex to
1587 * avoid deadlocks in resource destruction paths.
1589 vmw_resource_list_unreference(&resource_list);
1591 return 0;
1593 out_err:
1594 ttm_eu_backoff_reservation(&ticket, &sw_context->validate_nodes);
1595 out_err_nores:
1596 vmw_resource_list_unreserve(&sw_context->resource_list, true);
1597 vmw_resource_relocations_free(&sw_context->res_relocations);
1598 vmw_free_relocations(sw_context);
1599 vmw_clear_validations(sw_context);
1600 if (unlikely(dev_priv->pinned_bo != NULL &&
1601 !dev_priv->query_cid_valid))
1602 __vmw_execbuf_release_pinned_bo(dev_priv, NULL);
1603 out_unlock:
1604 list_splice_init(&sw_context->resource_list, &resource_list);
1605 error_resource = sw_context->error_resource;
1606 sw_context->error_resource = NULL;
1607 mutex_unlock(&dev_priv->cmdbuf_mutex);
1610 * Unreference resources outside of the cmdbuf_mutex to
1611 * avoid deadlocks in resource destruction paths.
1613 vmw_resource_list_unreference(&resource_list);
1614 if (unlikely(error_resource != NULL))
1615 vmw_resource_unreference(&error_resource);
1617 return ret;
1621 * vmw_execbuf_unpin_panic - Idle the fifo and unpin the query buffer.
1623 * @dev_priv: The device private structure.
1625 * This function is called to idle the fifo and unpin the query buffer
1626 * if the normal way to do this hits an error, which should typically be
1627 * extremely rare.
1629 static void vmw_execbuf_unpin_panic(struct vmw_private *dev_priv)
1631 DRM_ERROR("Can't unpin query buffer. Trying to recover.\n");
1633 (void) vmw_fallback_wait(dev_priv, false, true, 0, false, 10*HZ);
1634 vmw_bo_pin(dev_priv->pinned_bo, false);
1635 vmw_bo_pin(dev_priv->dummy_query_bo, false);
1636 dev_priv->dummy_query_bo_pinned = false;
1641 * __vmw_execbuf_release_pinned_bo - Flush queries and unpin the pinned
1642 * query bo.
1644 * @dev_priv: The device private structure.
1645 * @fence: If non-NULL should point to a struct vmw_fence_obj issued
1646 * _after_ a query barrier that flushes all queries touching the current
1647 * buffer pointed to by @dev_priv->pinned_bo
1649 * This function should be used to unpin the pinned query bo, or
1650 * as a query barrier when we need to make sure that all queries have
1651 * finished before the next fifo command. (For example on hardware
1652 * context destructions where the hardware may otherwise leak unfinished
1653 * queries).
1655 * This function does not return any failure codes, but make attempts
1656 * to do safe unpinning in case of errors.
1658 * The function will synchronize on the previous query barrier, and will
1659 * thus not finish until that barrier has executed.
1661 * the @dev_priv->cmdbuf_mutex needs to be held by the current thread
1662 * before calling this function.
1664 void __vmw_execbuf_release_pinned_bo(struct vmw_private *dev_priv,
1665 struct vmw_fence_obj *fence)
1667 int ret = 0;
1668 struct list_head validate_list;
1669 struct ttm_validate_buffer pinned_val, query_val;
1670 struct vmw_fence_obj *lfence = NULL;
1671 struct ww_acquire_ctx ticket;
1673 if (dev_priv->pinned_bo == NULL)
1674 goto out_unlock;
1676 INIT_LIST_HEAD(&validate_list);
1678 pinned_val.bo = ttm_bo_reference(dev_priv->pinned_bo);
1679 list_add_tail(&pinned_val.head, &validate_list);
1681 query_val.bo = ttm_bo_reference(dev_priv->dummy_query_bo);
1682 list_add_tail(&query_val.head, &validate_list);
1684 do {
1685 ret = ttm_eu_reserve_buffers(&ticket, &validate_list);
1686 } while (ret == -ERESTARTSYS);
1688 if (unlikely(ret != 0)) {
1689 vmw_execbuf_unpin_panic(dev_priv);
1690 goto out_no_reserve;
1693 if (dev_priv->query_cid_valid) {
1694 BUG_ON(fence != NULL);
1695 ret = vmw_fifo_emit_dummy_query(dev_priv, dev_priv->query_cid);
1696 if (unlikely(ret != 0)) {
1697 vmw_execbuf_unpin_panic(dev_priv);
1698 goto out_no_emit;
1700 dev_priv->query_cid_valid = false;
1703 vmw_bo_pin(dev_priv->pinned_bo, false);
1704 vmw_bo_pin(dev_priv->dummy_query_bo, false);
1705 dev_priv->dummy_query_bo_pinned = false;
1707 if (fence == NULL) {
1708 (void) vmw_execbuf_fence_commands(NULL, dev_priv, &lfence,
1709 NULL);
1710 fence = lfence;
1712 ttm_eu_fence_buffer_objects(&ticket, &validate_list, (void *) fence);
1713 if (lfence != NULL)
1714 vmw_fence_obj_unreference(&lfence);
1716 ttm_bo_unref(&query_val.bo);
1717 ttm_bo_unref(&pinned_val.bo);
1718 ttm_bo_unref(&dev_priv->pinned_bo);
1720 out_unlock:
1721 return;
1723 out_no_emit:
1724 ttm_eu_backoff_reservation(&ticket, &validate_list);
1725 out_no_reserve:
1726 ttm_bo_unref(&query_val.bo);
1727 ttm_bo_unref(&pinned_val.bo);
1728 ttm_bo_unref(&dev_priv->pinned_bo);
1732 * vmw_execbuf_release_pinned_bo - Flush queries and unpin the pinned
1733 * query bo.
1735 * @dev_priv: The device private structure.
1737 * This function should be used to unpin the pinned query bo, or
1738 * as a query barrier when we need to make sure that all queries have
1739 * finished before the next fifo command. (For example on hardware
1740 * context destructions where the hardware may otherwise leak unfinished
1741 * queries).
1743 * This function does not return any failure codes, but make attempts
1744 * to do safe unpinning in case of errors.
1746 * The function will synchronize on the previous query barrier, and will
1747 * thus not finish until that barrier has executed.
1749 void vmw_execbuf_release_pinned_bo(struct vmw_private *dev_priv)
1751 mutex_lock(&dev_priv->cmdbuf_mutex);
1752 if (dev_priv->query_cid_valid)
1753 __vmw_execbuf_release_pinned_bo(dev_priv, NULL);
1754 mutex_unlock(&dev_priv->cmdbuf_mutex);
1758 int vmw_execbuf_ioctl(struct drm_device *dev, void *data,
1759 struct drm_file *file_priv)
1761 struct vmw_private *dev_priv = vmw_priv(dev);
1762 struct drm_vmw_execbuf_arg *arg = (struct drm_vmw_execbuf_arg *)data;
1763 struct vmw_master *vmaster = vmw_master(file_priv->master);
1764 int ret;
1767 * This will allow us to extend the ioctl argument while
1768 * maintaining backwards compatibility:
1769 * We take different code paths depending on the value of
1770 * arg->version.
1773 if (unlikely(arg->version != DRM_VMW_EXECBUF_VERSION)) {
1774 DRM_ERROR("Incorrect execbuf version.\n");
1775 DRM_ERROR("You're running outdated experimental "
1776 "vmwgfx user-space drivers.");
1777 return -EINVAL;
1780 ret = ttm_read_lock(&vmaster->lock, true);
1781 if (unlikely(ret != 0))
1782 return ret;
1784 ret = vmw_execbuf_process(file_priv, dev_priv,
1785 (void __user *)(unsigned long)arg->commands,
1786 NULL, arg->command_size, arg->throttle_us,
1787 (void __user *)(unsigned long)arg->fence_rep,
1788 NULL);
1790 if (unlikely(ret != 0))
1791 goto out_unlock;
1793 vmw_kms_cursor_post_execbuf(dev_priv);
1795 out_unlock:
1796 ttm_read_unlock(&vmaster->lock);
1797 return ret;