drivers/gpu/drm/vmwgfx/vmwgfx_validation.c

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