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