drivers/gpu/drm/vmwgfx/vmwgfx_validation.c

   1 // SPDX-License-Identifier: GPL-2.0 OR MIT
   2 /**************************************************************************
   3  *
   4  * Copyright © 2018 VMware, Inc., Palo Alto, CA., USA
   5  * All Rights Reserved.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sub license, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  22  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  23  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  24  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  25  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  **************************************************************************/
  28 #include <linux/slab.h>
  29 #include "vmwgfx_validation.h"
  30 #include "vmwgfx_drv.h"
  31
  32 /**
  33  * struct vmw_validation_bo_node - Buffer object validation metadata.
  34  * @base: Metadata used for TTM reservation- and validation.
  35  * @hash: A hash entry used for the duplicate detection hash table.
  36  * @as_mob: Validate as mob.
  37  * @cpu_blit: Validate for cpu blit access.
  38  *
  39  * Bit fields are used since these structures are allocated and freed in
  40  * large numbers and space conservation is desired.
  41  */
  42 struct vmw_validation_bo_node {
  43         struct ttm_validate_buffer base;
  44         struct drm_hash_item hash;
  45         u32 as_mob : 1;
  46         u32 cpu_blit : 1;
  47 };
  48
  49 /**
  50  * struct vmw_validation_res_node - Resource validation metadata.
  51  * @head: List head for the resource validation list.
  52  * @hash: A hash entry used for the duplicate detection hash table.
  53  * @res: Reference counted resource pointer.
  54  * @new_backup: Non ref-counted pointer to new backup buffer to be assigned
  55  * to a resource.
  56  * @new_backup_offset: Offset into the new backup mob for resources that can
  57  * share MOBs.
  58  * @no_buffer_needed: Kernel does not need to allocate a MOB during validation,
  59  * the command stream provides a mob bind operation.
  60  * @switching_backup: The validation process is switching backup MOB.
  61  * @first_usage: True iff the resource has been seen only once in the current
  62  * validation batch.
  63  * @reserved: Whether the resource is currently reserved by this process.
  64  * @private: Optionally additional memory for caller-private data.
  65  *
  66  * Bit fields are used since these structures are allocated and freed in
  67  * large numbers and space conservation is desired.
  68  */
  69 struct vmw_validation_res_node {
  70         struct list_head head;
  71         struct drm_hash_item hash;
  72         struct vmw_resource *res;
  73         struct vmw_buffer_object *new_backup;
  74         unsigned long new_backup_offset;
  75         u32 no_buffer_needed : 1;
  76         u32 switching_backup : 1;
  77         u32 first_usage : 1;
  78         u32 reserved : 1;
  79         u32 dirty : 1;
  80         u32 dirty_set : 1;
  81         unsigned long private[0];
  82 };
  83
  84 /**
  85  * vmw_validation_mem_alloc - Allocate kernel memory from the validation
  86  * context based allocator
  87  * @ctx: The validation context
  88  * @size: The number of bytes to allocated.
  89  *
  90  * The memory allocated may not exceed PAGE_SIZE, and the returned
  91  * address is aligned to sizeof(long). All memory allocated this way is
  92  * reclaimed after validation when calling any of the exported functions:
  93  * vmw_validation_unref_lists()
  94  * vmw_validation_revert()
  95  * vmw_validation_done()
  96  *
  97  * Return: Pointer to the allocated memory on success. NULL on failure.
  98  */
  99 void *vmw_validation_mem_alloc(struct vmw_validation_context *ctx,
 100                                unsigned int size)
 101 {
 102         void *addr;
 103
 104         size = vmw_validation_align(size);
 105         if (size > PAGE_SIZE)
 106                 return NULL;
 107
 108         if (ctx->mem_size_left < size) {
 109                 struct page *page;
 110
 111                 if (ctx->vm && ctx->vm_size_left < PAGE_SIZE) {
 112                         int ret = ctx->vm->reserve_mem(ctx->vm, ctx->vm->gran);
 113
 114                         if (ret)
 115                                 return NULL;
 116
 117                         ctx->vm_size_left += ctx->vm->gran;
 118                         ctx->total_mem += ctx->vm->gran;
 119                 }
 120
 121                 page = alloc_page(GFP_KERNEL | __GFP_ZERO);
 122                 if (!page)
 123                         return NULL;
 124
 125                 if (ctx->vm)
 126                         ctx->vm_size_left -= PAGE_SIZE;
 127
 128                 list_add_tail(&page->lru, &ctx->page_list);
 129                 ctx->page_address = page_address(page);
 130                 ctx->mem_size_left = PAGE_SIZE;
 131         }
 132
 133         addr = (void *) (ctx->page_address + (PAGE_SIZE - ctx->mem_size_left));
 134         ctx->mem_size_left -= size;
 135
 136         return addr;
 137 }
 138
 139 /**
 140  * vmw_validation_mem_free - Free all memory allocated using
 141  * vmw_validation_mem_alloc()
 142  * @ctx: The validation context
 143  *
 144  * All memory previously allocated for this context using
 145  * vmw_validation_mem_alloc() is freed.
 146  */
 147 static void vmw_validation_mem_free(struct vmw_validation_context *ctx)
 148 {
 149         struct page *entry, *next;
 150
 151         list_for_each_entry_safe(entry, next, &ctx->page_list, lru) {
 152                 list_del_init(&entry->lru);
 153                 __free_page(entry);
 154         }
 155
 156         ctx->mem_size_left = 0;
 157         if (ctx->vm && ctx->total_mem) {
 158                 ctx->vm->unreserve_mem(ctx->vm, ctx->total_mem);
 159                 ctx->total_mem = 0;
 160                 ctx->vm_size_left = 0;
 161         }
 162 }
 163
 164 /**
 165  * vmw_validation_find_bo_dup - Find a duplicate buffer object entry in the
 166  * validation context's lists.
 167  * @ctx: The validation context to search.
 168  * @vbo: The buffer object to search for.
 169  *
 170  * Return: Pointer to the struct vmw_validation_bo_node referencing the
 171  * duplicate, or NULL if none found.
 172  */
 173 static struct vmw_validation_bo_node *
 174 vmw_validation_find_bo_dup(struct vmw_validation_context *ctx,
 175                            struct vmw_buffer_object *vbo)
 176 {
 177         struct  vmw_validation_bo_node *bo_node = NULL;
 178
 179         if (!ctx->merge_dups)
 180                 return NULL;
 181
 182         if (ctx->ht) {
 183                 struct drm_hash_item *hash;
 184
 185                 if (!drm_ht_find_item(ctx->ht, (unsigned long) vbo, &hash))
 186                         bo_node = container_of(hash, typeof(*bo_node), hash);
 187         } else {
 188                 struct  vmw_validation_bo_node *entry;
 189
 190                 list_for_each_entry(entry, &ctx->bo_list, base.head) {
 191                         if (entry->base.bo == &vbo->base) {
 192                                 bo_node = entry;
 193                                 break;
 194                         }
 195                 }
 196         }
 197
 198         return bo_node;
 199 }
 200
 201 /**
 202  * vmw_validation_find_res_dup - Find a duplicate resource entry in the
 203  * validation context's lists.
 204  * @ctx: The validation context to search.
 205  * @vbo: The buffer object to search for.
 206  *
 207  * Return: Pointer to the struct vmw_validation_bo_node referencing the
 208  * duplicate, or NULL if none found.
 209  */
 210 static struct vmw_validation_res_node *
 211 vmw_validation_find_res_dup(struct vmw_validation_context *ctx,
 212                             struct vmw_resource *res)
 213 {
 214         struct  vmw_validation_res_node *res_node = NULL;
 215
 216         if (!ctx->merge_dups)
 217                 return NULL;
 218
 219         if (ctx->ht) {
 220                 struct drm_hash_item *hash;
 221
 222                 if (!drm_ht_find_item(ctx->ht, (unsigned long) res, &hash))
 223                         res_node = container_of(hash, typeof(*res_node), hash);
 224         } else {
 225                 struct  vmw_validation_res_node *entry;
 226
 227                 list_for_each_entry(entry, &ctx->resource_ctx_list, head) {
 228                         if (entry->res == res) {
 229                                 res_node = entry;
 230                                 goto out;
 231                         }
 232                 }
 233
 234                 list_for_each_entry(entry, &ctx->resource_list, head) {
 235                         if (entry->res == res) {
 236                                 res_node = entry;
 237                                 break;
 238                         }
 239                 }
 240
 241         }
 242 out:
 243         return res_node;
 244 }
 245
 246 /**
 247  * vmw_validation_add_bo - Add a buffer object to the validation context.
 248  * @ctx: The validation context.
 249  * @vbo: The buffer object.
 250  * @as_mob: Validate as mob, otherwise suitable for GMR operations.
 251  * @cpu_blit: Validate in a page-mappable location.
 252  *
 253  * Return: Zero on success, negative error code otherwise.
 254  */
 255 int vmw_validation_add_bo(struct vmw_validation_context *ctx,
 256                           struct vmw_buffer_object *vbo,
 257                           bool as_mob,
 258                           bool cpu_blit)
 259 {
 260         struct vmw_validation_bo_node *bo_node;
 261
 262         bo_node = vmw_validation_find_bo_dup(ctx, vbo);
 263         if (bo_node) {
 264                 if (bo_node->as_mob != as_mob ||
 265                     bo_node->cpu_blit != cpu_blit) {
 266                         DRM_ERROR("Inconsistent buffer usage.\n");
 267                         return -EINVAL;
 268                 }
 269         } else {
 270                 struct ttm_validate_buffer *val_buf;
 271                 int ret;
 272
 273                 bo_node = vmw_validation_mem_alloc(ctx, sizeof(*bo_node));
 274                 if (!bo_node)
 275                         return -ENOMEM;
 276
 277                 if (ctx->ht) {
 278                         bo_node->hash.key = (unsigned long) vbo;
 279                         ret = drm_ht_insert_item(ctx->ht, &bo_node->hash);
 280                         if (ret) {
 281                                 DRM_ERROR("Failed to initialize a buffer "
 282                                           "validation entry.\n");
 283                                 return ret;
 284                         }
 285                 }
 286                 val_buf = &bo_node->base;
 287                 val_buf->bo = ttm_bo_get_unless_zero(&vbo->base);
 288                 if (!val_buf->bo)
 289                         return -ESRCH;
 290                 val_buf->num_shared = 0;
 291                 list_add_tail(&val_buf->head, &ctx->bo_list);
 292                 bo_node->as_mob = as_mob;
 293                 bo_node->cpu_blit = cpu_blit;
 294         }
 295
 296         return 0;
 297 }
 298
 299 /**
 300  * vmw_validation_add_resource - Add a resource to the validation context.
 301  * @ctx: The validation context.
 302  * @res: The resource.
 303  * @priv_size: Size of private, additional metadata.
 304  * @dirty: Whether to change dirty status.
 305  * @p_node: Output pointer of additional metadata address.
 306  * @first_usage: Whether this was the first time this resource was seen.
 307  *
 308  * Return: Zero on success, negative error code otherwise.
 309  */
 310 int vmw_validation_add_resource(struct vmw_validation_context *ctx,
 311                                 struct vmw_resource *res,
 312                                 size_t priv_size,
 313                                 u32 dirty,
 314                                 void **p_node,
 315                                 bool *first_usage)
 316 {
 317         struct vmw_validation_res_node *node;
 318         int ret;
 319
 320         node = vmw_validation_find_res_dup(ctx, res);
 321         if (node) {
 322                 node->first_usage = 0;
 323                 goto out_fill;
 324         }
 325
 326         node = vmw_validation_mem_alloc(ctx, sizeof(*node) + priv_size);
 327         if (!node) {
 328                 VMW_DEBUG_USER("Failed to allocate a resource validation entry.\n");
 329                 return -ENOMEM;
 330         }
 331
 332         if (ctx->ht) {
 333                 node->hash.key = (unsigned long) res;
 334                 ret = drm_ht_insert_item(ctx->ht, &node->hash);
 335                 if (ret) {
 336                         DRM_ERROR("Failed to initialize a resource validation "
 337                                   "entry.\n");
 338                         return ret;
 339                 }
 340         }
 341         node->res = vmw_resource_reference_unless_doomed(res);
 342         if (!node->res)
 343                 return -ESRCH;
 344
 345         node->first_usage = 1;
 346         if (!res->dev_priv->has_mob) {
 347                 list_add_tail(&node->head, &ctx->resource_list);
 348         } else {
 349                 switch (vmw_res_type(res)) {
 350                 case vmw_res_context:
 351                 case vmw_res_dx_context:
 352                         list_add(&node->head, &ctx->resource_ctx_list);
 353                         break;
 354                 case vmw_res_cotable:
 355                         list_add_tail(&node->head, &ctx->resource_ctx_list);
 356                         break;
 357                 default:
 358                         list_add_tail(&node->head, &ctx->resource_list);
 359                         break;
 360                 }
 361         }
 362
 363 out_fill:
 364         if (dirty) {
 365                 node->dirty_set = 1;
 366                 /* Overwriting previous information here is intentional! */
 367                 node->dirty = (dirty & VMW_RES_DIRTY_SET) ? 1 : 0;
 368         }
 369         if (first_usage)
 370                 *first_usage = node->first_usage;
 371         if (p_node)
 372                 *p_node = &node->private;
 373
 374         return 0;
 375 }
 376
 377 /**
 378  * vmw_validation_res_set_dirty - Register a resource dirty set or clear during
 379  * validation.
 380  * @ctx: The validation context.
 381  * @val_private: The additional meta-data pointer returned when the
 382  * resource was registered with the validation context. Used to identify
 383  * the resource.
 384  * @dirty: Dirty information VMW_RES_DIRTY_XX
 385  */
 386 void vmw_validation_res_set_dirty(struct vmw_validation_context *ctx,
 387                                   void *val_private, u32 dirty)
 388 {
 389         struct vmw_validation_res_node *val;
 390
 391         if (!dirty)
 392                 return;
 393
 394         val = container_of(val_private, typeof(*val), private);
 395         val->dirty_set = 1;
 396         /* Overwriting previous information here is intentional! */
 397         val->dirty = (dirty & VMW_RES_DIRTY_SET) ? 1 : 0;
 398 }
 399
 400 /**
 401  * vmw_validation_res_switch_backup - Register a backup MOB switch during
 402  * validation.
 403  * @ctx: The validation context.
 404  * @val_private: The additional meta-data pointer returned when the
 405  * resource was registered with the validation context. Used to identify
 406  * the resource.
 407  * @vbo: The new backup buffer object MOB. This buffer object needs to have
 408  * already been registered with the validation context.
 409  * @backup_offset: Offset into the new backup MOB.
 410  */
 411 void vmw_validation_res_switch_backup(struct vmw_validation_context *ctx,
 412                                       void *val_private,
 413                                       struct vmw_buffer_object *vbo,
 414                                       unsigned long backup_offset)
 415 {
 416         struct vmw_validation_res_node *val;
 417
 418         val = container_of(val_private, typeof(*val), private);
 419
 420         val->switching_backup = 1;
 421         if (val->first_usage)
 422                 val->no_buffer_needed = 1;
 423
 424         val->new_backup = vbo;
 425         val->new_backup_offset = backup_offset;
 426 }
 427
 428 /**
 429  * vmw_validation_res_reserve - Reserve all resources registered with this
 430  * validation context.
 431  * @ctx: The validation context.
 432  * @intr: Use interruptible waits when possible.
 433  *
 434  * Return: Zero on success, -ERESTARTSYS if interrupted. Negative error
 435  * code on failure.
 436  */
 437 int vmw_validation_res_reserve(struct vmw_validation_context *ctx,
 438                                bool intr)
 439 {
 440         struct vmw_validation_res_node *val;
 441         int ret = 0;
 442
 443         list_splice_init(&ctx->resource_ctx_list, &ctx->resource_list);
 444
 445         list_for_each_entry(val, &ctx->resource_list, head) {
 446                 struct vmw_resource *res = val->res;
 447
 448                 ret = vmw_resource_reserve(res, intr, val->no_buffer_needed);
 449                 if (ret)
 450                         goto out_unreserve;
 451
 452                 val->reserved = 1;
 453                 if (res->backup) {
 454                         struct vmw_buffer_object *vbo = res->backup;
 455
 456                         ret = vmw_validation_add_bo
 457                                 (ctx, vbo, vmw_resource_needs_backup(res),
 458                                  false);
 459                         if (ret)
 460                                 goto out_unreserve;
 461                 }
 462         }
 463
 464         return 0;
 465
 466 out_unreserve:
 467         vmw_validation_res_unreserve(ctx, true);
 468         return ret;
 469 }
 470
 471 /**
 472  * vmw_validation_res_unreserve - Unreserve all reserved resources
 473  * registered with this validation context.
 474  * @ctx: The validation context.
 475  * @backoff: Whether this is a backoff- of a commit-type operation. This
 476  * is used to determine whether to switch backup MOBs or not.
 477  */
 478 void vmw_validation_res_unreserve(struct vmw_validation_context *ctx,
 479                                  bool backoff)
 480 {
 481         struct vmw_validation_res_node *val;
 482
 483         list_splice_init(&ctx->resource_ctx_list, &ctx->resource_list);
 484         if (backoff)
 485                 list_for_each_entry(val, &ctx->resource_list, head) {
 486                         if (val->reserved)
 487                                 vmw_resource_unreserve(val->res,
 488                                                        false, false, false,
 489                                                        NULL, 0);
 490                 }
 491         else
 492                 list_for_each_entry(val, &ctx->resource_list, head) {
 493                         if (val->reserved)
 494                                 vmw_resource_unreserve(val->res,
 495                                                        val->dirty_set,
 496                                                        val->dirty,
 497                                                        val->switching_backup,
 498                                                        val->new_backup,
 499                                                        val->new_backup_offset);
 500                 }
 501 }
 502
 503 /**
 504  * vmw_validation_bo_validate_single - Validate a single buffer object.
 505  * @bo: The TTM buffer object base.
 506  * @interruptible: Whether to perform waits interruptible if possible.
 507  * @validate_as_mob: Whether to validate in MOB memory.
 508  *
 509  * Return: Zero on success, -ERESTARTSYS if interrupted. Negative error
 510  * code on failure.
 511  */
 512 int vmw_validation_bo_validate_single(struct ttm_buffer_object *bo,
 513                                       bool interruptible,
 514                                       bool validate_as_mob)
 515 {
 516         struct vmw_buffer_object *vbo =
 517                 container_of(bo, struct vmw_buffer_object, base);
 518         struct ttm_operation_ctx ctx = {
 519                 .interruptible = interruptible,
 520                 .no_wait_gpu = false
 521         };
 522         int ret;
 523
 524         if (vbo->pin_count > 0)
 525                 return 0;
 526
 527         if (validate_as_mob)
 528                 return ttm_bo_validate(bo, &vmw_mob_placement, &ctx);
 529
 530         /**
 531          * Put BO in VRAM if there is space, otherwise as a GMR.
 532          * If there is no space in VRAM and GMR ids are all used up,
 533          * start evicting GMRs to make room. If the DMA buffer can't be
 534          * used as a GMR, this will return -ENOMEM.
 535          */
 536
 537         ret = ttm_bo_validate(bo, &vmw_vram_gmr_placement, &ctx);
 538         if (ret == 0 || ret == -ERESTARTSYS)
 539                 return ret;
 540
 541         /**
 542          * If that failed, try VRAM again, this time evicting
 543          * previous contents.
 544          */
 545
 546         ret = ttm_bo_validate(bo, &vmw_vram_placement, &ctx);
 547         return ret;
 548 }
 549
 550 /**
 551  * vmw_validation_bo_validate - Validate all buffer objects registered with
 552  * the validation context.
 553  * @ctx: The validation context.
 554  * @intr: Whether to perform waits interruptible if possible.
 555  *
 556  * Return: Zero on success, -ERESTARTSYS if interrupted,
 557  * negative error code on failure.
 558  */
 559 int vmw_validation_bo_validate(struct vmw_validation_context *ctx, bool intr)
 560 {
 561         struct vmw_validation_bo_node *entry;
 562         int ret;
 563
 564         list_for_each_entry(entry, &ctx->bo_list, base.head) {
 565                 if (entry->cpu_blit) {
 566                         struct ttm_operation_ctx ctx = {
 567                                 .interruptible = intr,
 568                                 .no_wait_gpu = false
 569                         };
 570
 571                         ret = ttm_bo_validate(entry->base.bo,
 572                                               &vmw_nonfixed_placement, &ctx);
 573                 } else {
 574                         ret = vmw_validation_bo_validate_single
 575                         (entry->base.bo, intr, entry->as_mob);
 576                 }
 577                 if (ret)
 578                         return ret;
 579         }
 580         return 0;
 581 }
 582
 583 /**
 584  * vmw_validation_res_validate - Validate all resources registered with the
 585  * validation context.
 586  * @ctx: The validation context.
 587  * @intr: Whether to perform waits interruptible if possible.
 588  *
 589  * Before this function is called, all resource backup buffers must have
 590  * been validated.
 591  *
 592  * Return: Zero on success, -ERESTARTSYS if interrupted,
 593  * negative error code on failure.
 594  */
 595 int vmw_validation_res_validate(struct vmw_validation_context *ctx, bool intr)
 596 {
 597         struct vmw_validation_res_node *val;
 598         int ret;
 599
 600         list_for_each_entry(val, &ctx->resource_list, head) {
 601                 struct vmw_resource *res = val->res;
 602                 struct vmw_buffer_object *backup = res->backup;
 603
 604                 ret = vmw_resource_validate(res, intr);
 605                 if (ret) {
 606                         if (ret != -ERESTARTSYS)
 607                                 DRM_ERROR("Failed to validate resource.\n");
 608                         return ret;
 609                 }
 610
 611                 /* Check if the resource switched backup buffer */
 612                 if (backup && res->backup && (backup != res->backup)) {
 613                         struct vmw_buffer_object *vbo = res->backup;
 614
 615                         ret = vmw_validation_add_bo
 616                                 (ctx, vbo, vmw_resource_needs_backup(res),
 617                                  false);
 618                         if (ret)
 619                                 return ret;
 620                 }
 621         }
 622         return 0;
 623 }
 624
 625 /**
 626  * vmw_validation_drop_ht - Reset the hash table used for duplicate finding
 627  * and unregister it from this validation context.
 628  * @ctx: The validation context.
 629  *
 630  * The hash table used for duplicate finding is an expensive resource and
 631  * may be protected by mutexes that may cause deadlocks during resource
 632  * unreferencing if held. After resource- and buffer object registering,
 633  * there is no longer any use for this hash table, so allow freeing it
 634  * either to shorten any mutex locking time, or before resources- and
 635  * buffer objects are freed during validation context cleanup.
 636  */
 637 void vmw_validation_drop_ht(struct vmw_validation_context *ctx)
 638 {
 639         struct vmw_validation_bo_node *entry;
 640         struct vmw_validation_res_node *val;
 641
 642         if (!ctx->ht)
 643                 return;
 644
 645         list_for_each_entry(entry, &ctx->bo_list, base.head)
 646                 (void) drm_ht_remove_item(ctx->ht, &entry->hash);
 647
 648         list_for_each_entry(val, &ctx->resource_list, head)
 649                 (void) drm_ht_remove_item(ctx->ht, &val->hash);
 650
 651         list_for_each_entry(val, &ctx->resource_ctx_list, head)
 652                 (void) drm_ht_remove_item(ctx->ht, &val->hash);
 653
 654         ctx->ht = NULL;
 655 }
 656
 657 /**
 658  * vmw_validation_unref_lists - Unregister previously registered buffer
 659  * object and resources.
 660  * @ctx: The validation context.
 661  *
 662  * Note that this function may cause buffer object- and resource destructors
 663  * to be invoked.
 664  */
 665 void vmw_validation_unref_lists(struct vmw_validation_context *ctx)
 666 {
 667         struct vmw_validation_bo_node *entry;
 668         struct vmw_validation_res_node *val;
 669
 670         list_for_each_entry(entry, &ctx->bo_list, base.head) {
 671                 ttm_bo_put(entry->base.bo);
 672                 entry->base.bo = NULL;
 673         }
 674
 675         list_splice_init(&ctx->resource_ctx_list, &ctx->resource_list);
 676         list_for_each_entry(val, &ctx->resource_list, head)
 677                 vmw_resource_unreference(&val->res);
 678
 679         /*
 680          * No need to detach each list entry since they are all freed with
 681          * vmw_validation_free_mem. Just make the inaccessible.
 682          */
 683         INIT_LIST_HEAD(&ctx->bo_list);
 684         INIT_LIST_HEAD(&ctx->resource_list);
 685
 686         vmw_validation_mem_free(ctx);
 687 }
 688
 689 /**
 690  * vmw_validation_prepare - Prepare a validation context for command
 691  * submission.
 692  * @ctx: The validation context.
 693  * @mutex: The mutex used to protect resource reservation.
 694  * @intr: Whether to perform waits interruptible if possible.
 695  *
 696  * Note that the single reservation mutex @mutex is an unfortunate
 697  * construct. Ideally resource reservation should be moved to per-resource
 698  * ww_mutexes.
 699  * If this functions doesn't return Zero to indicate success, all resources
 700  * are left unreserved but still referenced.
 701  * Return: Zero on success, -ERESTARTSYS if interrupted, negative error code
 702  * on error.
 703  */
 704 int vmw_validation_prepare(struct vmw_validation_context *ctx,
 705                            struct mutex *mutex,
 706                            bool intr)
 707 {
 708         int ret = 0;
 709
 710         if (mutex) {
 711                 if (intr)
 712                         ret = mutex_lock_interruptible(mutex);
 713                 else
 714                         mutex_lock(mutex);
 715                 if (ret)
 716                         return -ERESTARTSYS;
 717         }
 718
 719         ctx->res_mutex = mutex;
 720         ret = vmw_validation_res_reserve(ctx, intr);
 721         if (ret)
 722                 goto out_no_res_reserve;
 723
 724         ret = vmw_validation_bo_reserve(ctx, intr);
 725         if (ret)
 726                 goto out_no_bo_reserve;
 727
 728         ret = vmw_validation_bo_validate(ctx, intr);
 729         if (ret)
 730                 goto out_no_validate;
 731
 732         ret = vmw_validation_res_validate(ctx, intr);
 733         if (ret)
 734                 goto out_no_validate;
 735
 736         return 0;
 737
 738 out_no_validate:
 739         vmw_validation_bo_backoff(ctx);
 740 out_no_bo_reserve:
 741         vmw_validation_res_unreserve(ctx, true);
 742 out_no_res_reserve:
 743         if (mutex)
 744                 mutex_unlock(mutex);
 745
 746         return ret;
 747 }
 748
 749 /**
 750  * vmw_validation_revert - Revert validation actions if command submission
 751  * failed.
 752  *
 753  * @ctx: The validation context.
 754  *
 755  * The caller still needs to unref resources after a call to this function.
 756  */
 757 void vmw_validation_revert(struct vmw_validation_context *ctx)
 758 {
 759         vmw_validation_bo_backoff(ctx);
 760         vmw_validation_res_unreserve(ctx, true);
 761         if (ctx->res_mutex)
 762                 mutex_unlock(ctx->res_mutex);
 763         vmw_validation_unref_lists(ctx);
 764 }
 765
 766 /**
 767  * vmw_validation_cone - Commit validation actions after command submission
 768  * success.
 769  * @ctx: The validation context.
 770  * @fence: Fence with which to fence all buffer objects taking part in the
 771  * command submission.
 772  *
 773  * The caller does NOT need to unref resources after a call to this function.
 774  */
 775 void vmw_validation_done(struct vmw_validation_context *ctx,
 776                          struct vmw_fence_obj *fence)
 777 {
 778         vmw_validation_bo_fence(ctx, fence);
 779         vmw_validation_res_unreserve(ctx, false);
 780         if (ctx->res_mutex)
 781                 mutex_unlock(ctx->res_mutex);
 782         vmw_validation_unref_lists(ctx);
 783 }
 784
 785 /**
 786  * vmw_validation_preload_bo - Preload the validation memory allocator for a
 787  * call to vmw_validation_add_bo().
 788  * @ctx: Pointer to the validation context.
 789  *
 790  * Iff this function returns successfully, the next call to
 791  * vmw_validation_add_bo() is guaranteed not to sleep. An error is not fatal
 792  * but voids the guarantee.
 793  *
 794  * Returns: Zero if successful, %-EINVAL otherwise.
 795  */
 796 int vmw_validation_preload_bo(struct vmw_validation_context *ctx)
 797 {
 798         unsigned int size = sizeof(struct vmw_validation_bo_node);
 799
 800         if (!vmw_validation_mem_alloc(ctx, size))
 801                 return -ENOMEM;
 802
 803         ctx->mem_size_left += size;
 804         return 0;
 805 }
 806
 807 /**
 808  * vmw_validation_preload_res - Preload the validation memory allocator for a
 809  * call to vmw_validation_add_res().
 810  * @ctx: Pointer to the validation context.
 811  * @size: Size of the validation node extra data. See below.
 812  *
 813  * Iff this function returns successfully, the next call to
 814  * vmw_validation_add_res() with the same or smaller @size is guaranteed not to
 815  * sleep. An error is not fatal but voids the guarantee.
 816  *
 817  * Returns: Zero if successful, %-EINVAL otherwise.
 818  */
 819 int vmw_validation_preload_res(struct vmw_validation_context *ctx,
 820                                unsigned int size)
 821 {
 822         size = vmw_validation_align(sizeof(struct vmw_validation_res_node) +
 823                                     size) +
 824                 vmw_validation_align(sizeof(struct vmw_validation_bo_node));
 825         if (!vmw_validation_mem_alloc(ctx, size))
 826                 return -ENOMEM;
 827
 828         ctx->mem_size_left += size;
 829         return 0;
 830 }