577 lines · c
1// SPDX-License-Identifier: GPL-2.0 OR MIT2/**************************************************************************3 * Copyright 2014-2015 VMware, Inc., Palo Alto, CA., USA4 *5 * Permission is hereby granted, free of charge, to any person obtaining a6 * copy of this software and associated documentation files (the7 * "Software"), to deal in the Software without restriction, including8 * without limitation the rights to use, copy, modify, merge, publish,9 * distribute, sub license, and/or sell copies of the Software, and to10 * permit persons to whom the Software is furnished to do so, subject to11 * the following conditions:12 *13 * The above copyright notice and this permission notice (including the14 * next paragraph) shall be included in all copies or substantial portions15 * of the Software.16 *17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,19 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL20 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,21 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR22 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE23 * USE OR OTHER DEALINGS IN THE SOFTWARE.24 *25 **************************************************************************/26 27#include "vmwgfx_bo.h"28#include "vmwgfx_drv.h"29#include "vmwgfx_resource_priv.h"30#include "vmwgfx_so.h"31#include "vmwgfx_binding.h"32 33/*34 * The currently only reason we need to keep track of views is that if we35 * destroy a hardware surface, all views pointing to it must also be destroyed,36 * otherwise the device will error.37 * So in particular if a surface is evicted, we must destroy all views pointing38 * to it, and all context bindings of that view. Similarly we must restore39 * the view bindings, views and surfaces pointed to by the views when a40 * context is referenced in the command stream.41 */42 43/**44 * struct vmw_view - view metadata45 *46 * @rcu: RCU callback head47 * @res: The struct vmw_resource we derive from48 * @ctx: Non-refcounted pointer to the context this view belongs to.49 * @srf: Refcounted pointer to the surface pointed to by this view.50 * @cotable: Refcounted pointer to the cotable holding this view.51 * @srf_head: List head for the surface-to-view list.52 * @cotable_head: List head for the cotable-to_view list.53 * @view_type: View type.54 * @view_id: User-space per context view id. Currently used also as per55 * context device view id.56 * @cmd_size: Size of the SVGA3D define view command that we've copied from the57 * command stream.58 * @committed: Whether the view is actually created or pending creation at the59 * device level.60 * @cmd: The SVGA3D define view command copied from the command stream.61 */62struct vmw_view {63 struct rcu_head rcu;64 struct vmw_resource res;65 struct vmw_resource *ctx; /* Immutable */66 struct vmw_resource *srf; /* Immutable */67 struct vmw_resource *cotable; /* Immutable */68 struct list_head srf_head; /* Protected by binding_mutex */69 struct list_head cotable_head; /* Protected by binding_mutex */70 unsigned view_type; /* Immutable */71 unsigned view_id; /* Immutable */72 u32 cmd_size; /* Immutable */73 bool committed; /* Protected by binding_mutex */74 u32 cmd[]; /* Immutable */75};76 77static int vmw_view_create(struct vmw_resource *res);78static int vmw_view_destroy(struct vmw_resource *res);79static void vmw_hw_view_destroy(struct vmw_resource *res);80static void vmw_view_commit_notify(struct vmw_resource *res,81 enum vmw_cmdbuf_res_state state);82 83static const struct vmw_res_func vmw_view_func = {84 .res_type = vmw_res_view,85 .needs_guest_memory = false,86 .may_evict = false,87 .type_name = "DX view",88 .domain = VMW_BO_DOMAIN_SYS,89 .busy_domain = VMW_BO_DOMAIN_SYS,90 .create = vmw_view_create,91 .commit_notify = vmw_view_commit_notify,92};93 94/**95 * struct vmw_view_define - view define command body stub96 *97 * @view_id: The device id of the view being defined98 * @sid: The surface id of the view being defined99 *100 * This generic struct is used by the code to change @view_id and @sid of a101 * saved view define command.102 */103struct vmw_view_define {104 uint32 view_id;105 uint32 sid;106};107 108/**109 * vmw_view - Convert a struct vmw_resource to a struct vmw_view110 *111 * @res: Pointer to the resource to convert.112 *113 * Returns a pointer to a struct vmw_view.114 */115static struct vmw_view *vmw_view(struct vmw_resource *res)116{117 return container_of(res, struct vmw_view, res);118}119 120/**121 * vmw_view_commit_notify - Notify that a view operation has been committed to122 * hardware from a user-supplied command stream.123 *124 * @res: Pointer to the view resource.125 * @state: Indicating whether a creation or removal has been committed.126 *127 */128static void vmw_view_commit_notify(struct vmw_resource *res,129 enum vmw_cmdbuf_res_state state)130{131 struct vmw_view *view = vmw_view(res);132 struct vmw_private *dev_priv = res->dev_priv;133 134 mutex_lock(&dev_priv->binding_mutex);135 if (state == VMW_CMDBUF_RES_ADD) {136 struct vmw_surface *srf = vmw_res_to_srf(view->srf);137 138 list_add_tail(&view->srf_head, &srf->view_list);139 vmw_cotable_add_resource(view->cotable, &view->cotable_head);140 view->committed = true;141 res->id = view->view_id;142 143 } else {144 list_del_init(&view->cotable_head);145 list_del_init(&view->srf_head);146 view->committed = false;147 res->id = -1;148 }149 mutex_unlock(&dev_priv->binding_mutex);150}151 152/**153 * vmw_view_create - Create a hardware view.154 *155 * @res: Pointer to the view resource.156 *157 * Create a hardware view. Typically used if that view has previously been158 * destroyed by an eviction operation.159 */160static int vmw_view_create(struct vmw_resource *res)161{162 struct vmw_view *view = vmw_view(res);163 struct vmw_surface *srf = vmw_res_to_srf(view->srf);164 struct vmw_private *dev_priv = res->dev_priv;165 struct {166 SVGA3dCmdHeader header;167 struct vmw_view_define body;168 } *cmd;169 170 mutex_lock(&dev_priv->binding_mutex);171 if (!view->committed) {172 mutex_unlock(&dev_priv->binding_mutex);173 return 0;174 }175 176 cmd = VMW_CMD_CTX_RESERVE(res->dev_priv, view->cmd_size, view->ctx->id);177 if (!cmd) {178 mutex_unlock(&dev_priv->binding_mutex);179 return -ENOMEM;180 }181 182 memcpy(cmd, &view->cmd, view->cmd_size);183 WARN_ON(cmd->body.view_id != view->view_id);184 /* Sid may have changed due to surface eviction. */185 WARN_ON(view->srf->id == SVGA3D_INVALID_ID);186 cmd->body.sid = view->srf->id;187 vmw_cmd_commit(res->dev_priv, view->cmd_size);188 res->id = view->view_id;189 list_add_tail(&view->srf_head, &srf->view_list);190 vmw_cotable_add_resource(view->cotable, &view->cotable_head);191 mutex_unlock(&dev_priv->binding_mutex);192 193 return 0;194}195 196/**197 * vmw_view_destroy - Destroy a hardware view.198 *199 * @res: Pointer to the view resource.200 *201 * Destroy a hardware view. Typically used on unexpected termination of the202 * owning process or if the surface the view is pointing to is destroyed.203 */204static int vmw_view_destroy(struct vmw_resource *res)205{206 struct vmw_private *dev_priv = res->dev_priv;207 struct vmw_view *view = vmw_view(res);208 struct {209 SVGA3dCmdHeader header;210 union vmw_view_destroy body;211 } *cmd;212 213 lockdep_assert_held_once(&dev_priv->binding_mutex);214 vmw_binding_res_list_scrub(&res->binding_head);215 216 if (!view->committed || res->id == -1)217 return 0;218 219 cmd = VMW_CMD_CTX_RESERVE(dev_priv, sizeof(*cmd), view->ctx->id);220 if (!cmd)221 return -ENOMEM;222 223 cmd->header.id = vmw_view_destroy_cmds[view->view_type];224 cmd->header.size = sizeof(cmd->body);225 cmd->body.view_id = view->view_id;226 vmw_cmd_commit(dev_priv, sizeof(*cmd));227 res->id = -1;228 list_del_init(&view->cotable_head);229 list_del_init(&view->srf_head);230 231 return 0;232}233 234/**235 * vmw_hw_view_destroy - Destroy a hardware view as part of resource cleanup.236 *237 * @res: Pointer to the view resource.238 *239 * Destroy a hardware view if it's still present.240 */241static void vmw_hw_view_destroy(struct vmw_resource *res)242{243 struct vmw_private *dev_priv = res->dev_priv;244 245 mutex_lock(&dev_priv->binding_mutex);246 WARN_ON(vmw_view_destroy(res));247 res->id = -1;248 mutex_unlock(&dev_priv->binding_mutex);249}250 251/**252 * vmw_view_key - Compute a view key suitable for the cmdbuf resource manager253 *254 * @user_key: The user-space id used for the view.255 * @view_type: The view type.256 *257 * Destroy a hardware view if it's still present.258 */259static u32 vmw_view_key(u32 user_key, enum vmw_view_type view_type)260{261 return user_key | (view_type << 20);262}263 264/**265 * vmw_view_id_ok - Basic view id and type range checks.266 *267 * @user_key: The user-space id used for the view.268 * @view_type: The view type.269 *270 * Checks that the view id and type (typically provided by user-space) is271 * valid.272 */273static bool vmw_view_id_ok(u32 user_key, enum vmw_view_type view_type)274{275 return (user_key < SVGA_COTABLE_MAX_IDS &&276 view_type < vmw_view_max);277}278 279/**280 * vmw_view_res_free - resource res_free callback for view resources281 *282 * @res: Pointer to a struct vmw_resource283 *284 * Frees memory held by the struct vmw_view.285 */286static void vmw_view_res_free(struct vmw_resource *res)287{288 struct vmw_view *view = vmw_view(res);289 290 vmw_resource_unreference(&view->cotable);291 vmw_resource_unreference(&view->srf);292 kfree_rcu(view, rcu);293}294 295/**296 * vmw_view_add - Create a view resource and stage it for addition297 * as a command buffer managed resource.298 *299 * @man: Pointer to the compat shader manager identifying the shader namespace.300 * @ctx: Pointer to a struct vmw_resource identifying the active context.301 * @srf: Pointer to a struct vmw_resource identifying the surface the view302 * points to.303 * @view_type: The view type deduced from the view create command.304 * @user_key: The key that is used to identify the shader. The key is305 * unique to the view type and to the context.306 * @cmd: Pointer to the view create command in the command stream.307 * @cmd_size: Size of the view create command in the command stream.308 * @list: Caller's list of staged command buffer resource actions.309 */310int vmw_view_add(struct vmw_cmdbuf_res_manager *man,311 struct vmw_resource *ctx,312 struct vmw_resource *srf,313 enum vmw_view_type view_type,314 u32 user_key,315 const void *cmd,316 size_t cmd_size,317 struct list_head *list)318{319 static const size_t vmw_view_define_sizes[] = {320 [vmw_view_sr] = sizeof(SVGA3dCmdDXDefineShaderResourceView),321 [vmw_view_rt] = sizeof(SVGA3dCmdDXDefineRenderTargetView),322 [vmw_view_ds] = sizeof(SVGA3dCmdDXDefineDepthStencilView),323 [vmw_view_ua] = sizeof(SVGA3dCmdDXDefineUAView)324 };325 326 struct vmw_private *dev_priv = ctx->dev_priv;327 struct vmw_resource *res;328 struct vmw_view *view;329 size_t size;330 int ret;331 332 if (cmd_size != vmw_view_define_sizes[view_type] +333 sizeof(SVGA3dCmdHeader)) {334 VMW_DEBUG_USER("Illegal view create command size.\n");335 return -EINVAL;336 }337 338 if (!vmw_view_id_ok(user_key, view_type)) {339 VMW_DEBUG_USER("Illegal view add view id.\n");340 return -EINVAL;341 }342 343 size = offsetof(struct vmw_view, cmd) + cmd_size;344 345 view = kmalloc(size, GFP_KERNEL);346 if (!view) {347 return -ENOMEM;348 }349 350 res = &view->res;351 view->ctx = ctx;352 view->srf = vmw_resource_reference(srf);353 view->cotable = vmw_resource_reference354 (vmw_context_cotable(ctx, vmw_view_cotables[view_type]));355 view->view_type = view_type;356 view->view_id = user_key;357 view->cmd_size = cmd_size;358 view->committed = false;359 INIT_LIST_HEAD(&view->srf_head);360 INIT_LIST_HEAD(&view->cotable_head);361 memcpy(&view->cmd, cmd, cmd_size);362 ret = vmw_resource_init(dev_priv, res, true,363 vmw_view_res_free, &vmw_view_func);364 if (ret)365 goto out_resource_init;366 367 ret = vmw_cmdbuf_res_add(man, vmw_cmdbuf_res_view,368 vmw_view_key(user_key, view_type),369 res, list);370 if (ret)371 goto out_resource_init;372 373 res->id = view->view_id;374 res->hw_destroy = vmw_hw_view_destroy;375 376out_resource_init:377 vmw_resource_unreference(&res);378 379 return ret;380}381 382/**383 * vmw_view_remove - Stage a view for removal.384 *385 * @man: Pointer to the view manager identifying the shader namespace.386 * @user_key: The key that is used to identify the view. The key is387 * unique to the view type.388 * @view_type: View type389 * @list: Caller's list of staged command buffer resource actions.390 * @res_p: If the resource is in an already committed state, points to the391 * struct vmw_resource on successful return. The pointer will be392 * non ref-counted.393 */394int vmw_view_remove(struct vmw_cmdbuf_res_manager *man,395 u32 user_key, enum vmw_view_type view_type,396 struct list_head *list,397 struct vmw_resource **res_p)398{399 if (!vmw_view_id_ok(user_key, view_type)) {400 VMW_DEBUG_USER("Illegal view remove view id.\n");401 return -EINVAL;402 }403 404 return vmw_cmdbuf_res_remove(man, vmw_cmdbuf_res_view,405 vmw_view_key(user_key, view_type),406 list, res_p);407}408 409/**410 * vmw_view_cotable_list_destroy - Evict all views belonging to a cotable.411 *412 * @dev_priv: Pointer to a device private struct.413 * @list: List of views belonging to a cotable.414 * @readback: Unused. Needed for function interface only.415 *416 * This function evicts all views belonging to a cotable.417 * It must be called with the binding_mutex held, and the caller must hold418 * a reference to the view resource. This is typically called before the419 * cotable is paged out.420 */421void vmw_view_cotable_list_destroy(struct vmw_private *dev_priv,422 struct list_head *list,423 bool readback)424{425 struct vmw_view *entry, *next;426 427 lockdep_assert_held_once(&dev_priv->binding_mutex);428 429 list_for_each_entry_safe(entry, next, list, cotable_head)430 WARN_ON(vmw_view_destroy(&entry->res));431}432 433/**434 * vmw_view_surface_list_destroy - Evict all views pointing to a surface435 *436 * @dev_priv: Pointer to a device private struct.437 * @list: List of views pointing to a surface.438 *439 * This function evicts all views pointing to a surface. This is typically440 * called before the surface is evicted.441 */442void vmw_view_surface_list_destroy(struct vmw_private *dev_priv,443 struct list_head *list)444{445 struct vmw_view *entry, *next;446 447 lockdep_assert_held_once(&dev_priv->binding_mutex);448 449 list_for_each_entry_safe(entry, next, list, srf_head)450 WARN_ON(vmw_view_destroy(&entry->res));451}452 453/**454 * vmw_view_srf - Return a non-refcounted pointer to the surface a view is455 * pointing to.456 *457 * @res: pointer to a view resource.458 *459 * Note that the view itself is holding a reference, so as long460 * the view resource is alive, the surface resource will be.461 */462struct vmw_resource *vmw_view_srf(struct vmw_resource *res)463{464 return vmw_view(res)->srf;465}466 467/**468 * vmw_view_lookup - Look up a view.469 *470 * @man: The context's cmdbuf ref manager.471 * @view_type: The view type.472 * @user_key: The view user id.473 *474 * returns a refcounted pointer to a view or an error pointer if not found.475 */476struct vmw_resource *vmw_view_lookup(struct vmw_cmdbuf_res_manager *man,477 enum vmw_view_type view_type,478 u32 user_key)479{480 return vmw_cmdbuf_res_lookup(man, vmw_cmdbuf_res_view,481 vmw_view_key(user_key, view_type));482}483 484/**485 * vmw_view_dirtying - Return whether a view type is dirtying its resource486 * @res: Pointer to the view487 *488 * Each time a resource is put on the validation list as the result of a489 * view pointing to it, we need to determine whether that resource will490 * be dirtied (written to by the GPU) as a result of the corresponding491 * GPU operation. Currently only rendertarget-, depth-stencil and unordered492 * access views are capable of dirtying its resource.493 *494 * Return: Whether the view type of @res dirties the resource it points to.495 */496u32 vmw_view_dirtying(struct vmw_resource *res)497{498 static u32 view_is_dirtying[vmw_view_max] = {499 [vmw_view_rt] = VMW_RES_DIRTY_SET,500 [vmw_view_ds] = VMW_RES_DIRTY_SET,501 [vmw_view_ua] = VMW_RES_DIRTY_SET,502 };503 504 /* Update this function as we add more view types */505 BUILD_BUG_ON(vmw_view_max != 4);506 return view_is_dirtying[vmw_view(res)->view_type];507}508 509const u32 vmw_view_destroy_cmds[] = {510 [vmw_view_sr] = SVGA_3D_CMD_DX_DESTROY_SHADERRESOURCE_VIEW,511 [vmw_view_rt] = SVGA_3D_CMD_DX_DESTROY_RENDERTARGET_VIEW,512 [vmw_view_ds] = SVGA_3D_CMD_DX_DESTROY_DEPTHSTENCIL_VIEW,513 [vmw_view_ua] = SVGA_3D_CMD_DX_DESTROY_UA_VIEW,514};515 516const SVGACOTableType vmw_view_cotables[] = {517 [vmw_view_sr] = SVGA_COTABLE_SRVIEW,518 [vmw_view_rt] = SVGA_COTABLE_RTVIEW,519 [vmw_view_ds] = SVGA_COTABLE_DSVIEW,520 [vmw_view_ua] = SVGA_COTABLE_UAVIEW,521};522 523const SVGACOTableType vmw_so_cotables[] = {524 [vmw_so_el] = SVGA_COTABLE_ELEMENTLAYOUT,525 [vmw_so_bs] = SVGA_COTABLE_BLENDSTATE,526 [vmw_so_ds] = SVGA_COTABLE_DEPTHSTENCIL,527 [vmw_so_rs] = SVGA_COTABLE_RASTERIZERSTATE,528 [vmw_so_ss] = SVGA_COTABLE_SAMPLER,529 [vmw_so_so] = SVGA_COTABLE_STREAMOUTPUT,530 [vmw_so_max]= SVGA_COTABLE_MAX531};532 533 534/* To remove unused function warning */535static void vmw_so_build_asserts(void) __attribute__((used));536 537 538/*539 * This function is unused at run-time, and only used to dump various build540 * asserts important for code optimization assumptions.541 */542static void vmw_so_build_asserts(void)543{544 /* Assert that our vmw_view_cmd_to_type() function is correct. */545 BUILD_BUG_ON(SVGA_3D_CMD_DX_DESTROY_SHADERRESOURCE_VIEW !=546 SVGA_3D_CMD_DX_DEFINE_SHADERRESOURCE_VIEW + 1);547 BUILD_BUG_ON(SVGA_3D_CMD_DX_DEFINE_RENDERTARGET_VIEW !=548 SVGA_3D_CMD_DX_DEFINE_SHADERRESOURCE_VIEW + 2);549 BUILD_BUG_ON(SVGA_3D_CMD_DX_DESTROY_RENDERTARGET_VIEW !=550 SVGA_3D_CMD_DX_DEFINE_SHADERRESOURCE_VIEW + 3);551 BUILD_BUG_ON(SVGA_3D_CMD_DX_DEFINE_DEPTHSTENCIL_VIEW !=552 SVGA_3D_CMD_DX_DEFINE_SHADERRESOURCE_VIEW + 4);553 BUILD_BUG_ON(SVGA_3D_CMD_DX_DESTROY_DEPTHSTENCIL_VIEW !=554 SVGA_3D_CMD_DX_DEFINE_SHADERRESOURCE_VIEW + 5);555 556 /* Assert that our "one body fits all" assumption is valid */557 BUILD_BUG_ON(sizeof(union vmw_view_destroy) != sizeof(u32));558 559 /* Assert that the view key space can hold all view ids. */560 BUILD_BUG_ON(SVGA_COTABLE_MAX_IDS >= ((1 << 20) - 1));561 562 /*563 * Assert that the offset of sid in all view define commands564 * is what we assume it to be.565 */566 BUILD_BUG_ON(offsetof(struct vmw_view_define, sid) !=567 offsetof(SVGA3dCmdDXDefineShaderResourceView, sid));568 BUILD_BUG_ON(offsetof(struct vmw_view_define, sid) !=569 offsetof(SVGA3dCmdDXDefineRenderTargetView, sid));570 BUILD_BUG_ON(offsetof(struct vmw_view_define, sid) !=571 offsetof(SVGA3dCmdDXDefineDepthStencilView, sid));572 BUILD_BUG_ON(offsetof(struct vmw_view_define, sid) !=573 offsetof(SVGA3dCmdDXDefineUAView, sid));574 BUILD_BUG_ON(offsetof(struct vmw_view_define, sid) !=575 offsetof(SVGA3dCmdDXDefineDepthStencilView_v2, sid));576}577