root/drivers/gpu/drm/vmwgfx/vmwgfx_so.c

DEFINITIONS

1. vmw_view_commit_notify
2. vmw_view_create
3. vmw_view_destroy
4. vmw_hw_view_destroy
5. vmw_view_key
6. vmw_view_id_ok
7. vmw_view_res_free
8. vmw_view_add
9. vmw_view_remove
10. vmw_view_cotable_list_destroy
11. vmw_view_surface_list_destroy
12. vmw_view_srf
13. vmw_view_lookup
14. vmw_view_dirtying
15. vmw_so_build_asserts

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