drivers/gpu/drm/vmwgfx/vmwgfx_resource.c

   1 /**************************************************************************
   2  *
   3  * Copyright © 2009 VMware, Inc., Palo Alto, CA., USA
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  21  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  22  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  23  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  24  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include "vmwgfx_drv.h"
  29 #include <drm/vmwgfx_drm.h>
  30 #include <drm/ttm/ttm_object.h>
  31 #include <drm/ttm/ttm_placement.h>
  32 #include <drm/drmP.h>
  33 #include "vmwgfx_resource_priv.h"
  34
  35 #define VMW_RES_EVICT_ERR_COUNT 10
  36
  37 struct vmw_user_dma_buffer {
  38         struct ttm_prime_object prime;
  39         struct vmw_dma_buffer dma;
  40 };
  41
  42 struct vmw_bo_user_rep {
  43         uint32_t handle;
  44         uint64_t map_handle;
  45 };
  46
  47 struct vmw_stream {
  48         struct vmw_resource res;
  49         uint32_t stream_id;
  50 };
  51
  52 struct vmw_user_stream {
  53         struct ttm_base_object base;
  54         struct vmw_stream stream;
  55 };
  56
  57
  58 static uint64_t vmw_user_stream_size;
  59
  60 static const struct vmw_res_func vmw_stream_func = {
  61         .res_type = vmw_res_stream,
  62         .needs_backup = false,
  63         .may_evict = false,
  64         .type_name = "video streams",
  65         .backup_placement = NULL,
  66         .create = NULL,
  67         .destroy = NULL,
  68         .bind = NULL,
  69         .unbind = NULL
  70 };
  71
  72 static inline struct vmw_dma_buffer *
  73 vmw_dma_buffer(struct ttm_buffer_object *bo)
  74 {
  75         return container_of(bo, struct vmw_dma_buffer, base);
  76 }
  77
  78 static inline struct vmw_user_dma_buffer *
  79 vmw_user_dma_buffer(struct ttm_buffer_object *bo)
  80 {
  81         struct vmw_dma_buffer *vmw_bo = vmw_dma_buffer(bo);
  82         return container_of(vmw_bo, struct vmw_user_dma_buffer, dma);
  83 }
  84
  85 struct vmw_resource *vmw_resource_reference(struct vmw_resource *res)
  86 {
  87         kref_get(&res->kref);
  88         return res;
  89 }
  90
  91 struct vmw_resource *
  92 vmw_resource_reference_unless_doomed(struct vmw_resource *res)
  93 {
  94         return kref_get_unless_zero(&res->kref) ? res : NULL;
  95 }
  96
  97 /**
  98  * vmw_resource_release_id - release a resource id to the id manager.
  99  *
 100  * @res: Pointer to the resource.
 101  *
 102  * Release the resource id to the resource id manager and set it to -1
 103  */
 104 void vmw_resource_release_id(struct vmw_resource *res)
 105 {
 106         struct vmw_private *dev_priv = res->dev_priv;
 107         struct idr *idr = &dev_priv->res_idr[res->func->res_type];
 108
 109         write_lock(&dev_priv->resource_lock);
 110         if (res->id != -1)
 111                 idr_remove(idr, res->id);
 112         res->id = -1;
 113         write_unlock(&dev_priv->resource_lock);
 114 }
 115
 116 static void vmw_resource_release(struct kref *kref)
 117 {
 118         struct vmw_resource *res =
 119             container_of(kref, struct vmw_resource, kref);
 120         struct vmw_private *dev_priv = res->dev_priv;
 121         int id;
 122         struct idr *idr = &dev_priv->res_idr[res->func->res_type];
 123
 124         res->avail = false;
 125         list_del_init(&res->lru_head);
 126         write_unlock(&dev_priv->resource_lock);
 127         if (res->backup) {
 128                 struct ttm_buffer_object *bo = &res->backup->base;
 129
 130                 ttm_bo_reserve(bo, false, false, false, 0);
 131                 if (!list_empty(&res->mob_head) &&
 132                     res->func->unbind != NULL) {
 133                         struct ttm_validate_buffer val_buf;
 134
 135                         val_buf.bo = bo;
 136                         res->func->unbind(res, false, &val_buf);
 137                 }
 138                 res->backup_dirty = false;
 139                 list_del_init(&res->mob_head);
 140                 ttm_bo_unreserve(bo);
 141                 vmw_dmabuf_unreference(&res->backup);
 142         }
 143
 144         if (likely(res->hw_destroy != NULL)) {
 145                 res->hw_destroy(res);
 146                 mutex_lock(&dev_priv->binding_mutex);
 147                 vmw_context_binding_res_list_kill(&res->binding_head);
 148                 mutex_unlock(&dev_priv->binding_mutex);
 149         }
 150
 151         id = res->id;
 152         if (res->res_free != NULL)
 153                 res->res_free(res);
 154         else
 155                 kfree(res);
 156
 157         write_lock(&dev_priv->resource_lock);
 158
 159         if (id != -1)
 160                 idr_remove(idr, id);
 161 }
 162
 163 void vmw_resource_unreference(struct vmw_resource **p_res)
 164 {
 165         struct vmw_resource *res = *p_res;
 166         struct vmw_private *dev_priv = res->dev_priv;
 167
 168         *p_res = NULL;
 169         write_lock(&dev_priv->resource_lock);
 170         kref_put(&res->kref, vmw_resource_release);
 171         write_unlock(&dev_priv->resource_lock);
 172 }
 173
 174
 175 /**
 176  * vmw_resource_alloc_id - release a resource id to the id manager.
 177  *
 178  * @res: Pointer to the resource.
 179  *
 180  * Allocate the lowest free resource from the resource manager, and set
 181  * @res->id to that id. Returns 0 on success and -ENOMEM on failure.
 182  */
 183 int vmw_resource_alloc_id(struct vmw_resource *res)
 184 {
 185         struct vmw_private *dev_priv = res->dev_priv;
 186         int ret;
 187         struct idr *idr = &dev_priv->res_idr[res->func->res_type];
 188
 189         BUG_ON(res->id != -1);
 190
 191         idr_preload(GFP_KERNEL);
 192         write_lock(&dev_priv->resource_lock);
 193
 194         ret = idr_alloc(idr, res, 1, 0, GFP_NOWAIT);
 195         if (ret >= 0)
 196                 res->id = ret;
 197
 198         write_unlock(&dev_priv->resource_lock);
 199         idr_preload_end();
 200         return ret < 0 ? ret : 0;
 201 }
 202
 203 /**
 204  * vmw_resource_init - initialize a struct vmw_resource
 205  *
 206  * @dev_priv:       Pointer to a device private struct.
 207  * @res:            The struct vmw_resource to initialize.
 208  * @obj_type:       Resource object type.
 209  * @delay_id:       Boolean whether to defer device id allocation until
 210  *                  the first validation.
 211  * @res_free:       Resource destructor.
 212  * @func:           Resource function table.
 213  */
 214 int vmw_resource_init(struct vmw_private *dev_priv, struct vmw_resource *res,
 215                       bool delay_id,
 216                       void (*res_free) (struct vmw_resource *res),
 217                       const struct vmw_res_func *func)
 218 {
 219         kref_init(&res->kref);
 220         res->hw_destroy = NULL;
 221         res->res_free = res_free;
 222         res->avail = false;
 223         res->dev_priv = dev_priv;
 224         res->func = func;
 225         INIT_LIST_HEAD(&res->lru_head);
 226         INIT_LIST_HEAD(&res->mob_head);
 227         INIT_LIST_HEAD(&res->binding_head);
 228         res->id = -1;
 229         res->backup = NULL;
 230         res->backup_offset = 0;
 231         res->backup_dirty = false;
 232         res->res_dirty = false;
 233         if (delay_id)
 234                 return 0;
 235         else
 236                 return vmw_resource_alloc_id(res);
 237 }
 238
 239 /**
 240  * vmw_resource_activate
 241  *
 242  * @res:        Pointer to the newly created resource
 243  * @hw_destroy: Destroy function. NULL if none.
 244  *
 245  * Activate a resource after the hardware has been made aware of it.
 246  * Set tye destroy function to @destroy. Typically this frees the
 247  * resource and destroys the hardware resources associated with it.
 248  * Activate basically means that the function vmw_resource_lookup will
 249  * find it.
 250  */
 251 void vmw_resource_activate(struct vmw_resource *res,
 252                            void (*hw_destroy) (struct vmw_resource *))
 253 {
 254         struct vmw_private *dev_priv = res->dev_priv;
 255
 256         write_lock(&dev_priv->resource_lock);
 257         res->avail = true;
 258         res->hw_destroy = hw_destroy;
 259         write_unlock(&dev_priv->resource_lock);
 260 }
 261
 262 struct vmw_resource *vmw_resource_lookup(struct vmw_private *dev_priv,
 263                                          struct idr *idr, int id)
 264 {
 265         struct vmw_resource *res;
 266
 267         read_lock(&dev_priv->resource_lock);
 268         res = idr_find(idr, id);
 269         if (res && res->avail)
 270                 kref_get(&res->kref);
 271         else
 272                 res = NULL;
 273         read_unlock(&dev_priv->resource_lock);
 274
 275         if (unlikely(res == NULL))
 276                 return NULL;
 277
 278         return res;
 279 }
 280
 281 /**
 282  * vmw_user_resource_lookup_handle - lookup a struct resource from a
 283  * TTM user-space handle and perform basic type checks
 284  *
 285  * @dev_priv:     Pointer to a device private struct
 286  * @tfile:        Pointer to a struct ttm_object_file identifying the caller
 287  * @handle:       The TTM user-space handle
 288  * @converter:    Pointer to an object describing the resource type
 289  * @p_res:        On successful return the location pointed to will contain
 290  *                a pointer to a refcounted struct vmw_resource.
 291  *
 292  * If the handle can't be found or is associated with an incorrect resource
 293  * type, -EINVAL will be returned.
 294  */
 295 int vmw_user_resource_lookup_handle(struct vmw_private *dev_priv,
 296                                     struct ttm_object_file *tfile,
 297                                     uint32_t handle,
 298                                     const struct vmw_user_resource_conv
 299                                     *converter,
 300                                     struct vmw_resource **p_res)
 301 {
 302         struct ttm_base_object *base;
 303         struct vmw_resource *res;
 304         int ret = -EINVAL;
 305
 306         base = ttm_base_object_lookup(tfile, handle);
 307         if (unlikely(base == NULL))
 308                 return -EINVAL;
 309
 310         if (unlikely(ttm_base_object_type(base) != converter->object_type))
 311                 goto out_bad_resource;
 312
 313         res = converter->base_obj_to_res(base);
 314
 315         read_lock(&dev_priv->resource_lock);
 316         if (!res->avail || res->res_free != converter->res_free) {
 317                 read_unlock(&dev_priv->resource_lock);
 318                 goto out_bad_resource;
 319         }
 320
 321         kref_get(&res->kref);
 322         read_unlock(&dev_priv->resource_lock);
 323
 324         *p_res = res;
 325         ret = 0;
 326
 327 out_bad_resource:
 328         ttm_base_object_unref(&base);
 329
 330         return ret;
 331 }
 332
 333 /**
 334  * Helper function that looks either a surface or dmabuf.
 335  *
 336  * The pointer this pointed at by out_surf and out_buf needs to be null.
 337  */
 338 int vmw_user_lookup_handle(struct vmw_private *dev_priv,
 339                            struct ttm_object_file *tfile,
 340                            uint32_t handle,
 341                            struct vmw_surface **out_surf,
 342                            struct vmw_dma_buffer **out_buf)
 343 {
 344         struct vmw_resource *res;
 345         int ret;
 346
 347         BUG_ON(*out_surf || *out_buf);
 348
 349         ret = vmw_user_resource_lookup_handle(dev_priv, tfile, handle,
 350                                               user_surface_converter,
 351                                               &res);
 352         if (!ret) {
 353                 *out_surf = vmw_res_to_srf(res);
 354                 return 0;
 355         }
 356
 357         *out_surf = NULL;
 358         ret = vmw_user_dmabuf_lookup(tfile, handle, out_buf);
 359         return ret;
 360 }
 361
 362 /**
 363  * Buffer management.
 364  */
 365
 366 /**
 367  * vmw_dmabuf_acc_size - Calculate the pinned memory usage of buffers
 368  *
 369  * @dev_priv: Pointer to a struct vmw_private identifying the device.
 370  * @size: The requested buffer size.
 371  * @user: Whether this is an ordinary dma buffer or a user dma buffer.
 372  */
 373 static size_t vmw_dmabuf_acc_size(struct vmw_private *dev_priv, size_t size,
 374                                   bool user)
 375 {
 376         static size_t struct_size, user_struct_size;
 377         size_t num_pages = PAGE_ALIGN(size) >> PAGE_SHIFT;
 378         size_t page_array_size = ttm_round_pot(num_pages * sizeof(void *));
 379
 380         if (unlikely(struct_size == 0)) {
 381                 size_t backend_size = ttm_round_pot(vmw_tt_size);
 382
 383                 struct_size = backend_size +
 384                         ttm_round_pot(sizeof(struct vmw_dma_buffer));
 385                 user_struct_size = backend_size +
 386                         ttm_round_pot(sizeof(struct vmw_user_dma_buffer));
 387         }
 388
 389         if (dev_priv->map_mode == vmw_dma_alloc_coherent)
 390                 page_array_size +=
 391                         ttm_round_pot(num_pages * sizeof(dma_addr_t));
 392
 393         return ((user) ? user_struct_size : struct_size) +
 394                 page_array_size;
 395 }
 396
 397 void vmw_dmabuf_bo_free(struct ttm_buffer_object *bo)
 398 {
 399         struct vmw_dma_buffer *vmw_bo = vmw_dma_buffer(bo);
 400
 401         kfree(vmw_bo);
 402 }
 403
 404 static void vmw_user_dmabuf_destroy(struct ttm_buffer_object *bo)
 405 {
 406         struct vmw_user_dma_buffer *vmw_user_bo = vmw_user_dma_buffer(bo);
 407
 408         ttm_prime_object_kfree(vmw_user_bo, prime);
 409 }
 410
 411 int vmw_dmabuf_init(struct vmw_private *dev_priv,
 412                     struct vmw_dma_buffer *vmw_bo,
 413                     size_t size, struct ttm_placement *placement,
 414                     bool interruptible,
 415                     void (*bo_free) (struct ttm_buffer_object *bo))
 416 {
 417         struct ttm_bo_device *bdev = &dev_priv->bdev;
 418         size_t acc_size;
 419         int ret;
 420         bool user = (bo_free == &vmw_user_dmabuf_destroy);
 421
 422         BUG_ON(!bo_free && (!user && (bo_free != vmw_dmabuf_bo_free)));
 423
 424         acc_size = vmw_dmabuf_acc_size(dev_priv, size, user);
 425         memset(vmw_bo, 0, sizeof(*vmw_bo));
 426
 427         INIT_LIST_HEAD(&vmw_bo->res_list);
 428
 429         ret = ttm_bo_init(bdev, &vmw_bo->base, size,
 430                           ttm_bo_type_device, placement,
 431                           0, interruptible,
 432                           NULL, acc_size, NULL, bo_free);
 433         return ret;
 434 }
 435
 436 static void vmw_user_dmabuf_release(struct ttm_base_object **p_base)
 437 {
 438         struct vmw_user_dma_buffer *vmw_user_bo;
 439         struct ttm_base_object *base = *p_base;
 440         struct ttm_buffer_object *bo;
 441
 442         *p_base = NULL;
 443
 444         if (unlikely(base == NULL))
 445                 return;
 446
 447         vmw_user_bo = container_of(base, struct vmw_user_dma_buffer,
 448                                    prime.base);
 449         bo = &vmw_user_bo->dma.base;
 450         ttm_bo_unref(&bo);
 451 }
 452
 453 static void vmw_user_dmabuf_ref_obj_release(struct ttm_base_object *base,
 454                                             enum ttm_ref_type ref_type)
 455 {
 456         struct vmw_user_dma_buffer *user_bo;
 457         user_bo = container_of(base, struct vmw_user_dma_buffer, prime.base);
 458
 459         switch (ref_type) {
 460         case TTM_REF_SYNCCPU_WRITE:
 461                 ttm_bo_synccpu_write_release(&user_bo->dma.base);
 462                 break;
 463         default:
 464                 BUG();
 465         }
 466 }
 467
 468 /**
 469  * vmw_user_dmabuf_alloc - Allocate a user dma buffer
 470  *
 471  * @dev_priv: Pointer to a struct device private.
 472  * @tfile: Pointer to a struct ttm_object_file on which to register the user
 473  * object.
 474  * @size: Size of the dma buffer.
 475  * @shareable: Boolean whether the buffer is shareable with other open files.
 476  * @handle: Pointer to where the handle value should be assigned.
 477  * @p_dma_buf: Pointer to where the refcounted struct vmw_dma_buffer pointer
 478  * should be assigned.
 479  */
 480 int vmw_user_dmabuf_alloc(struct vmw_private *dev_priv,
 481                           struct ttm_object_file *tfile,
 482                           uint32_t size,
 483                           bool shareable,
 484                           uint32_t *handle,
 485                           struct vmw_dma_buffer **p_dma_buf)
 486 {
 487         struct vmw_user_dma_buffer *user_bo;
 488         struct ttm_buffer_object *tmp;
 489         int ret;
 490
 491         user_bo = kzalloc(sizeof(*user_bo), GFP_KERNEL);
 492         if (unlikely(user_bo == NULL)) {
 493                 DRM_ERROR("Failed to allocate a buffer.\n");
 494                 return -ENOMEM;
 495         }
 496
 497         ret = vmw_dmabuf_init(dev_priv, &user_bo->dma, size,
 498                               (dev_priv->has_mob) ?
 499                               &vmw_sys_placement :
 500                               &vmw_vram_sys_placement, true,
 501                               &vmw_user_dmabuf_destroy);
 502         if (unlikely(ret != 0))
 503                 return ret;
 504
 505         tmp = ttm_bo_reference(&user_bo->dma.base);
 506         ret = ttm_prime_object_init(tfile,
 507                                     size,
 508                                     &user_bo->prime,
 509                                     shareable,
 510                                     ttm_buffer_type,
 511                                     &vmw_user_dmabuf_release,
 512                                     &vmw_user_dmabuf_ref_obj_release);
 513         if (unlikely(ret != 0)) {
 514                 ttm_bo_unref(&tmp);
 515                 goto out_no_base_object;
 516         }
 517
 518         *p_dma_buf = &user_bo->dma;
 519         *handle = user_bo->prime.base.hash.key;
 520
 521 out_no_base_object:
 522         return ret;
 523 }
 524
 525 /**
 526  * vmw_user_dmabuf_verify_access - verify access permissions on this
 527  * buffer object.
 528  *
 529  * @bo: Pointer to the buffer object being accessed
 530  * @tfile: Identifying the caller.
 531  */
 532 int vmw_user_dmabuf_verify_access(struct ttm_buffer_object *bo,
 533                                   struct ttm_object_file *tfile)
 534 {
 535         struct vmw_user_dma_buffer *vmw_user_bo;
 536
 537         if (unlikely(bo->destroy != vmw_user_dmabuf_destroy))
 538                 return -EPERM;
 539
 540         vmw_user_bo = vmw_user_dma_buffer(bo);
 541         return (vmw_user_bo->prime.base.tfile == tfile ||
 542                 vmw_user_bo->prime.base.shareable) ? 0 : -EPERM;
 543 }
 544
 545 /**
 546  * vmw_user_dmabuf_synccpu_grab - Grab a struct vmw_user_dma_buffer for cpu
 547  * access, idling previous GPU operations on the buffer and optionally
 548  * blocking it for further command submissions.
 549  *
 550  * @user_bo: Pointer to the buffer object being grabbed for CPU access
 551  * @tfile: Identifying the caller.
 552  * @flags: Flags indicating how the grab should be performed.
 553  *
 554  * A blocking grab will be automatically released when @tfile is closed.
 555  */
 556 static int vmw_user_dmabuf_synccpu_grab(struct vmw_user_dma_buffer *user_bo,
 557                                         struct ttm_object_file *tfile,
 558                                         uint32_t flags)
 559 {
 560         struct ttm_buffer_object *bo = &user_bo->dma.base;
 561         bool existed;
 562         int ret;
 563
 564         if (flags & drm_vmw_synccpu_allow_cs) {
 565                 struct ttm_bo_device *bdev = bo->bdev;
 566
 567                 spin_lock(&bdev->fence_lock);
 568                 ret = ttm_bo_wait(bo, false, true,
 569                                   !!(flags & drm_vmw_synccpu_dontblock));
 570                 spin_unlock(&bdev->fence_lock);
 571                 return ret;
 572         }
 573
 574         ret = ttm_bo_synccpu_write_grab
 575                 (bo, !!(flags & drm_vmw_synccpu_dontblock));
 576         if (unlikely(ret != 0))
 577                 return ret;
 578
 579         ret = ttm_ref_object_add(tfile, &user_bo->prime.base,
 580                                  TTM_REF_SYNCCPU_WRITE, &existed);
 581         if (ret != 0 || existed)
 582                 ttm_bo_synccpu_write_release(&user_bo->dma.base);
 583
 584         return ret;
 585 }
 586
 587 /**
 588  * vmw_user_dmabuf_synccpu_release - Release a previous grab for CPU access,
 589  * and unblock command submission on the buffer if blocked.
 590  *
 591  * @handle: Handle identifying the buffer object.
 592  * @tfile: Identifying the caller.
 593  * @flags: Flags indicating the type of release.
 594  */
 595 static int vmw_user_dmabuf_synccpu_release(uint32_t handle,
 596                                            struct ttm_object_file *tfile,
 597                                            uint32_t flags)
 598 {
 599         if (!(flags & drm_vmw_synccpu_allow_cs))
 600                 return ttm_ref_object_base_unref(tfile, handle,
 601                                                  TTM_REF_SYNCCPU_WRITE);
 602
 603         return 0;
 604 }
 605
 606 /**
 607  * vmw_user_dmabuf_synccpu_release - ioctl function implementing the synccpu
 608  * functionality.
 609  *
 610  * @dev: Identifies the drm device.
 611  * @data: Pointer to the ioctl argument.
 612  * @file_priv: Identifies the caller.
 613  *
 614  * This function checks the ioctl arguments for validity and calls the
 615  * relevant synccpu functions.
 616  */
 617 int vmw_user_dmabuf_synccpu_ioctl(struct drm_device *dev, void *data,
 618                                   struct drm_file *file_priv)
 619 {
 620         struct drm_vmw_synccpu_arg *arg =
 621                 (struct drm_vmw_synccpu_arg *) data;
 622         struct vmw_dma_buffer *dma_buf;
 623         struct vmw_user_dma_buffer *user_bo;
 624         struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
 625         int ret;
 626
 627         if ((arg->flags & (drm_vmw_synccpu_read | drm_vmw_synccpu_write)) == 0
 628             || (arg->flags & ~(drm_vmw_synccpu_read | drm_vmw_synccpu_write |
 629                                drm_vmw_synccpu_dontblock |
 630                                drm_vmw_synccpu_allow_cs)) != 0) {
 631                 DRM_ERROR("Illegal synccpu flags.\n");
 632                 return -EINVAL;
 633         }
 634
 635         switch (arg->op) {
 636         case drm_vmw_synccpu_grab:
 637                 ret = vmw_user_dmabuf_lookup(tfile, arg->handle, &dma_buf);
 638                 if (unlikely(ret != 0))
 639                         return ret;
 640
 641                 user_bo = container_of(dma_buf, struct vmw_user_dma_buffer,
 642                                        dma);
 643                 ret = vmw_user_dmabuf_synccpu_grab(user_bo, tfile, arg->flags);
 644                 vmw_dmabuf_unreference(&dma_buf);
 645                 if (unlikely(ret != 0 && ret != -ERESTARTSYS &&
 646                              ret != -EBUSY)) {
 647                         DRM_ERROR("Failed synccpu grab on handle 0x%08x.\n",
 648                                   (unsigned int) arg->handle);
 649                         return ret;
 650                 }
 651                 break;
 652         case drm_vmw_synccpu_release:
 653                 ret = vmw_user_dmabuf_synccpu_release(arg->handle, tfile,
 654                                                       arg->flags);
 655                 if (unlikely(ret != 0)) {
 656                         DRM_ERROR("Failed synccpu release on handle 0x%08x.\n",
 657                                   (unsigned int) arg->handle);
 658                         return ret;
 659                 }
 660                 break;
 661         default:
 662                 DRM_ERROR("Invalid synccpu operation.\n");
 663                 return -EINVAL;
 664         }
 665
 666         return 0;
 667 }
 668
 669 int vmw_dmabuf_alloc_ioctl(struct drm_device *dev, void *data,
 670                            struct drm_file *file_priv)
 671 {
 672         struct vmw_private *dev_priv = vmw_priv(dev);
 673         union drm_vmw_alloc_dmabuf_arg *arg =
 674             (union drm_vmw_alloc_dmabuf_arg *)data;
 675         struct drm_vmw_alloc_dmabuf_req *req = &arg->req;
 676         struct drm_vmw_dmabuf_rep *rep = &arg->rep;
 677         struct vmw_dma_buffer *dma_buf;
 678         uint32_t handle;
 679         int ret;
 680
 681         ret = ttm_read_lock(&dev_priv->reservation_sem, true);
 682         if (unlikely(ret != 0))
 683                 return ret;
 684
 685         ret = vmw_user_dmabuf_alloc(dev_priv, vmw_fpriv(file_priv)->tfile,
 686                                     req->size, false, &handle, &dma_buf);
 687         if (unlikely(ret != 0))
 688                 goto out_no_dmabuf;
 689
 690         rep->handle = handle;
 691         rep->map_handle = drm_vma_node_offset_addr(&dma_buf->base.vma_node);
 692         rep->cur_gmr_id = handle;
 693         rep->cur_gmr_offset = 0;
 694
 695         vmw_dmabuf_unreference(&dma_buf);
 696
 697 out_no_dmabuf:
 698         ttm_read_unlock(&dev_priv->reservation_sem);
 699
 700         return ret;
 701 }
 702
 703 int vmw_dmabuf_unref_ioctl(struct drm_device *dev, void *data,
 704                            struct drm_file *file_priv)
 705 {
 706         struct drm_vmw_unref_dmabuf_arg *arg =
 707             (struct drm_vmw_unref_dmabuf_arg *)data;
 708
 709         return ttm_ref_object_base_unref(vmw_fpriv(file_priv)->tfile,
 710                                          arg->handle,
 711                                          TTM_REF_USAGE);
 712 }
 713
 714 int vmw_user_dmabuf_lookup(struct ttm_object_file *tfile,
 715                            uint32_t handle, struct vmw_dma_buffer **out)
 716 {
 717         struct vmw_user_dma_buffer *vmw_user_bo;
 718         struct ttm_base_object *base;
 719
 720         base = ttm_base_object_lookup(tfile, handle);
 721         if (unlikely(base == NULL)) {
 722                 printk(KERN_ERR "Invalid buffer object handle 0x%08lx.\n",
 723                        (unsigned long)handle);
 724                 return -ESRCH;
 725         }
 726
 727         if (unlikely(ttm_base_object_type(base) != ttm_buffer_type)) {
 728                 ttm_base_object_unref(&base);
 729                 printk(KERN_ERR "Invalid buffer object handle 0x%08lx.\n",
 730                        (unsigned long)handle);
 731                 return -EINVAL;
 732         }
 733
 734         vmw_user_bo = container_of(base, struct vmw_user_dma_buffer,
 735                                    prime.base);
 736         (void)ttm_bo_reference(&vmw_user_bo->dma.base);
 737         ttm_base_object_unref(&base);
 738         *out = &vmw_user_bo->dma;
 739
 740         return 0;
 741 }
 742
 743 int vmw_user_dmabuf_reference(struct ttm_object_file *tfile,
 744                               struct vmw_dma_buffer *dma_buf,
 745                               uint32_t *handle)
 746 {
 747         struct vmw_user_dma_buffer *user_bo;
 748
 749         if (dma_buf->base.destroy != vmw_user_dmabuf_destroy)
 750                 return -EINVAL;
 751
 752         user_bo = container_of(dma_buf, struct vmw_user_dma_buffer, dma);
 753
 754         *handle = user_bo->prime.base.hash.key;
 755         return ttm_ref_object_add(tfile, &user_bo->prime.base,
 756                                   TTM_REF_USAGE, NULL);
 757 }
 758
 759 /*
 760  * Stream management
 761  */
 762
 763 static void vmw_stream_destroy(struct vmw_resource *res)
 764 {
 765         struct vmw_private *dev_priv = res->dev_priv;
 766         struct vmw_stream *stream;
 767         int ret;
 768
 769         DRM_INFO("%s: unref\n", __func__);
 770         stream = container_of(res, struct vmw_stream, res);
 771
 772         ret = vmw_overlay_unref(dev_priv, stream->stream_id);
 773         WARN_ON(ret != 0);
 774 }
 775
 776 static int vmw_stream_init(struct vmw_private *dev_priv,
 777                            struct vmw_stream *stream,
 778                            void (*res_free) (struct vmw_resource *res))
 779 {
 780         struct vmw_resource *res = &stream->res;
 781         int ret;
 782
 783         ret = vmw_resource_init(dev_priv, res, false, res_free,
 784                                 &vmw_stream_func);
 785
 786         if (unlikely(ret != 0)) {
 787                 if (res_free == NULL)
 788                         kfree(stream);
 789                 else
 790                         res_free(&stream->res);
 791                 return ret;
 792         }
 793
 794         ret = vmw_overlay_claim(dev_priv, &stream->stream_id);
 795         if (ret) {
 796                 vmw_resource_unreference(&res);
 797                 return ret;
 798         }
 799
 800         DRM_INFO("%s: claimed\n", __func__);
 801
 802         vmw_resource_activate(&stream->res, vmw_stream_destroy);
 803         return 0;
 804 }
 805
 806 static void vmw_user_stream_free(struct vmw_resource *res)
 807 {
 808         struct vmw_user_stream *stream =
 809             container_of(res, struct vmw_user_stream, stream.res);
 810         struct vmw_private *dev_priv = res->dev_priv;
 811
 812         ttm_base_object_kfree(stream, base);
 813         ttm_mem_global_free(vmw_mem_glob(dev_priv),
 814                             vmw_user_stream_size);
 815 }
 816
 817 /**
 818  * This function is called when user space has no more references on the
 819  * base object. It releases the base-object's reference on the resource object.
 820  */
 821
 822 static void vmw_user_stream_base_release(struct ttm_base_object **p_base)
 823 {
 824         struct ttm_base_object *base = *p_base;
 825         struct vmw_user_stream *stream =
 826             container_of(base, struct vmw_user_stream, base);
 827         struct vmw_resource *res = &stream->stream.res;
 828
 829         *p_base = NULL;
 830         vmw_resource_unreference(&res);
 831 }
 832
 833 int vmw_stream_unref_ioctl(struct drm_device *dev, void *data,
 834                            struct drm_file *file_priv)
 835 {
 836         struct vmw_private *dev_priv = vmw_priv(dev);
 837         struct vmw_resource *res;
 838         struct vmw_user_stream *stream;
 839         struct drm_vmw_stream_arg *arg = (struct drm_vmw_stream_arg *)data;
 840         struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
 841         struct idr *idr = &dev_priv->res_idr[vmw_res_stream];
 842         int ret = 0;
 843
 844
 845         res = vmw_resource_lookup(dev_priv, idr, arg->stream_id);
 846         if (unlikely(res == NULL))
 847                 return -EINVAL;
 848
 849         if (res->res_free != &vmw_user_stream_free) {
 850                 ret = -EINVAL;
 851                 goto out;
 852         }
 853
 854         stream = container_of(res, struct vmw_user_stream, stream.res);
 855         if (stream->base.tfile != tfile) {
 856                 ret = -EINVAL;
 857                 goto out;
 858         }
 859
 860         ttm_ref_object_base_unref(tfile, stream->base.hash.key, TTM_REF_USAGE);
 861 out:
 862         vmw_resource_unreference(&res);
 863         return ret;
 864 }
 865
 866 int vmw_stream_claim_ioctl(struct drm_device *dev, void *data,
 867                            struct drm_file *file_priv)
 868 {
 869         struct vmw_private *dev_priv = vmw_priv(dev);
 870         struct vmw_user_stream *stream;
 871         struct vmw_resource *res;
 872         struct vmw_resource *tmp;
 873         struct drm_vmw_stream_arg *arg = (struct drm_vmw_stream_arg *)data;
 874         struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
 875         int ret;
 876
 877         /*
 878          * Approximate idr memory usage with 128 bytes. It will be limited
 879          * by maximum number_of streams anyway?
 880          */
 881
 882         if (unlikely(vmw_user_stream_size == 0))
 883                 vmw_user_stream_size = ttm_round_pot(sizeof(*stream)) + 128;
 884
 885         ret = ttm_read_lock(&dev_priv->reservation_sem, true);
 886         if (unlikely(ret != 0))
 887                 return ret;
 888
 889         ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv),
 890                                    vmw_user_stream_size,
 891                                    false, true);
 892         if (unlikely(ret != 0)) {
 893                 if (ret != -ERESTARTSYS)
 894                         DRM_ERROR("Out of graphics memory for stream"
 895                                   " creation.\n");
 896                 goto out_unlock;
 897         }
 898
 899
 900         stream = kmalloc(sizeof(*stream), GFP_KERNEL);
 901         if (unlikely(stream == NULL)) {
 902                 ttm_mem_global_free(vmw_mem_glob(dev_priv),
 903                                     vmw_user_stream_size);
 904                 ret = -ENOMEM;
 905                 goto out_unlock;
 906         }
 907
 908         res = &stream->stream.res;
 909         stream->base.shareable = false;
 910         stream->base.tfile = NULL;
 911
 912         /*
 913          * From here on, the destructor takes over resource freeing.
 914          */
 915
 916         ret = vmw_stream_init(dev_priv, &stream->stream, vmw_user_stream_free);
 917         if (unlikely(ret != 0))
 918                 goto out_unlock;
 919
 920         tmp = vmw_resource_reference(res);
 921         ret = ttm_base_object_init(tfile, &stream->base, false, VMW_RES_STREAM,
 922                                    &vmw_user_stream_base_release, NULL);
 923
 924         if (unlikely(ret != 0)) {
 925                 vmw_resource_unreference(&tmp);
 926                 goto out_err;
 927         }
 928
 929         arg->stream_id = res->id;
 930 out_err:
 931         vmw_resource_unreference(&res);
 932 out_unlock:
 933         ttm_read_unlock(&dev_priv->reservation_sem);
 934         return ret;
 935 }
 936
 937 int vmw_user_stream_lookup(struct vmw_private *dev_priv,
 938                            struct ttm_object_file *tfile,
 939                            uint32_t *inout_id, struct vmw_resource **out)
 940 {
 941         struct vmw_user_stream *stream;
 942         struct vmw_resource *res;
 943         int ret;
 944
 945         res = vmw_resource_lookup(dev_priv, &dev_priv->res_idr[vmw_res_stream],
 946                                   *inout_id);
 947         if (unlikely(res == NULL))
 948                 return -EINVAL;
 949
 950         if (res->res_free != &vmw_user_stream_free) {
 951                 ret = -EINVAL;
 952                 goto err_ref;
 953         }
 954
 955         stream = container_of(res, struct vmw_user_stream, stream.res);
 956         if (stream->base.tfile != tfile) {
 957                 ret = -EPERM;
 958                 goto err_ref;
 959         }
 960
 961         *inout_id = stream->stream.stream_id;
 962         *out = res;
 963         return 0;
 964 err_ref:
 965         vmw_resource_unreference(&res);
 966         return ret;
 967 }
 968
 969
 970 /**
 971  * vmw_dumb_create - Create a dumb kms buffer
 972  *
 973  * @file_priv: Pointer to a struct drm_file identifying the caller.
 974  * @dev: Pointer to the drm device.
 975  * @args: Pointer to a struct drm_mode_create_dumb structure
 976  *
 977  * This is a driver callback for the core drm create_dumb functionality.
 978  * Note that this is very similar to the vmw_dmabuf_alloc ioctl, except
 979  * that the arguments have a different format.
 980  */
 981 int vmw_dumb_create(struct drm_file *file_priv,
 982                     struct drm_device *dev,
 983                     struct drm_mode_create_dumb *args)
 984 {
 985         struct vmw_private *dev_priv = vmw_priv(dev);
 986         struct vmw_dma_buffer *dma_buf;
 987         int ret;
 988
 989         args->pitch = args->width * ((args->bpp + 7) / 8);
 990         args->size = args->pitch * args->height;
 991
 992         ret = ttm_read_lock(&dev_priv->reservation_sem, true);
 993         if (unlikely(ret != 0))
 994                 return ret;
 995
 996         ret = vmw_user_dmabuf_alloc(dev_priv, vmw_fpriv(file_priv)->tfile,
 997                                     args->size, false, &args->handle,
 998                                     &dma_buf);
 999         if (unlikely(ret != 0))
1000                 goto out_no_dmabuf;
1001
1002         vmw_dmabuf_unreference(&dma_buf);
1003 out_no_dmabuf:
1004         ttm_read_unlock(&dev_priv->reservation_sem);
1005         return ret;
1006 }
1007
1008 /**
1009  * vmw_dumb_map_offset - Return the address space offset of a dumb buffer
1010  *
1011  * @file_priv: Pointer to a struct drm_file identifying the caller.
1012  * @dev: Pointer to the drm device.
1013  * @handle: Handle identifying the dumb buffer.
1014  * @offset: The address space offset returned.
1015  *
1016  * This is a driver callback for the core drm dumb_map_offset functionality.
1017  */
1018 int vmw_dumb_map_offset(struct drm_file *file_priv,
1019                         struct drm_device *dev, uint32_t handle,
1020                         uint64_t *offset)
1021 {
1022         struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
1023         struct vmw_dma_buffer *out_buf;
1024         int ret;
1025
1026         ret = vmw_user_dmabuf_lookup(tfile, handle, &out_buf);
1027         if (ret != 0)
1028                 return -EINVAL;
1029
1030         *offset = drm_vma_node_offset_addr(&out_buf->base.vma_node);
1031         vmw_dmabuf_unreference(&out_buf);
1032         return 0;
1033 }
1034
1035 /**
1036  * vmw_dumb_destroy - Destroy a dumb boffer
1037  *
1038  * @file_priv: Pointer to a struct drm_file identifying the caller.
1039  * @dev: Pointer to the drm device.
1040  * @handle: Handle identifying the dumb buffer.
1041  *
1042  * This is a driver callback for the core drm dumb_destroy functionality.
1043  */
1044 int vmw_dumb_destroy(struct drm_file *file_priv,
1045                      struct drm_device *dev,
1046                      uint32_t handle)
1047 {
1048         return ttm_ref_object_base_unref(vmw_fpriv(file_priv)->tfile,
1049                                          handle, TTM_REF_USAGE);
1050 }
1051
1052 /**
1053  * vmw_resource_buf_alloc - Allocate a backup buffer for a resource.
1054  *
1055  * @res:            The resource for which to allocate a backup buffer.
1056  * @interruptible:  Whether any sleeps during allocation should be
1057  *                  performed while interruptible.
1058  */
1059 static int vmw_resource_buf_alloc(struct vmw_resource *res,
1060                                   bool interruptible)
1061 {
1062         unsigned long size =
1063                 (res->backup_size + PAGE_SIZE - 1) & PAGE_MASK;
1064         struct vmw_dma_buffer *backup;
1065         int ret;
1066
1067         if (likely(res->backup)) {
1068                 BUG_ON(res->backup->base.num_pages * PAGE_SIZE < size);
1069                 return 0;
1070         }
1071
1072         backup = kzalloc(sizeof(*backup), GFP_KERNEL);
1073         if (unlikely(backup == NULL))
1074                 return -ENOMEM;
1075
1076         ret = vmw_dmabuf_init(res->dev_priv, backup, res->backup_size,
1077                               res->func->backup_placement,
1078                               interruptible,
1079                               &vmw_dmabuf_bo_free);
1080         if (unlikely(ret != 0))
1081                 goto out_no_dmabuf;
1082
1083         res->backup = backup;
1084
1085 out_no_dmabuf:
1086         return ret;
1087 }
1088
1089 /**
1090  * vmw_resource_do_validate - Make a resource up-to-date and visible
1091  *                            to the device.
1092  *
1093  * @res:            The resource to make visible to the device.
1094  * @val_buf:        Information about a buffer possibly
1095  *                  containing backup data if a bind operation is needed.
1096  *
1097  * On hardware resource shortage, this function returns -EBUSY and
1098  * should be retried once resources have been freed up.
1099  */
1100 static int vmw_resource_do_validate(struct vmw_resource *res,
1101                                     struct ttm_validate_buffer *val_buf)
1102 {
1103         int ret = 0;
1104         const struct vmw_res_func *func = res->func;
1105
1106         if (unlikely(res->id == -1)) {
1107                 ret = func->create(res);
1108                 if (unlikely(ret != 0))
1109                         return ret;
1110         }
1111
1112         if (func->bind &&
1113             ((func->needs_backup && list_empty(&res->mob_head) &&
1114               val_buf->bo != NULL) ||
1115              (!func->needs_backup && val_buf->bo != NULL))) {
1116                 ret = func->bind(res, val_buf);
1117                 if (unlikely(ret != 0))
1118                         goto out_bind_failed;
1119                 if (func->needs_backup)
1120                         list_add_tail(&res->mob_head, &res->backup->res_list);
1121         }
1122
1123         /*
1124          * Only do this on write operations, and move to
1125          * vmw_resource_unreserve if it can be called after
1126          * backup buffers have been unreserved. Otherwise
1127          * sort out locking.
1128          */
1129         res->res_dirty = true;
1130
1131         return 0;
1132
1133 out_bind_failed:
1134         func->destroy(res);
1135
1136         return ret;
1137 }
1138
1139 /**
1140  * vmw_resource_unreserve - Unreserve a resource previously reserved for
1141  * command submission.
1142  *
1143  * @res:               Pointer to the struct vmw_resource to unreserve.
1144  * @new_backup:        Pointer to new backup buffer if command submission
1145  *                     switched.
1146  * @new_backup_offset: New backup offset if @new_backup is !NULL.
1147  *
1148  * Currently unreserving a resource means putting it back on the device's
1149  * resource lru list, so that it can be evicted if necessary.
1150  */
1151 void vmw_resource_unreserve(struct vmw_resource *res,
1152                             struct vmw_dma_buffer *new_backup,
1153                             unsigned long new_backup_offset)
1154 {
1155         struct vmw_private *dev_priv = res->dev_priv;
1156
1157         if (!list_empty(&res->lru_head))
1158                 return;
1159
1160         if (new_backup && new_backup != res->backup) {
1161
1162                 if (res->backup) {
1163                         lockdep_assert_held(&res->backup->base.resv->lock.base);
1164                         list_del_init(&res->mob_head);
1165                         vmw_dmabuf_unreference(&res->backup);
1166                 }
1167
1168                 res->backup = vmw_dmabuf_reference(new_backup);
1169                 lockdep_assert_held(&new_backup->base.resv->lock.base);
1170                 list_add_tail(&res->mob_head, &new_backup->res_list);
1171         }
1172         if (new_backup)
1173                 res->backup_offset = new_backup_offset;
1174
1175         if (!res->func->may_evict || res->id == -1)
1176                 return;
1177
1178         write_lock(&dev_priv->resource_lock);
1179         list_add_tail(&res->lru_head,
1180                       &res->dev_priv->res_lru[res->func->res_type]);
1181         write_unlock(&dev_priv->resource_lock);
1182 }
1183
1184 /**
1185  * vmw_resource_check_buffer - Check whether a backup buffer is needed
1186  *                             for a resource and in that case, allocate
1187  *                             one, reserve and validate it.
1188  *
1189  * @res:            The resource for which to allocate a backup buffer.
1190  * @interruptible:  Whether any sleeps during allocation should be
1191  *                  performed while interruptible.
1192  * @val_buf:        On successful return contains data about the
1193  *                  reserved and validated backup buffer.
1194  */
1195 static int
1196 vmw_resource_check_buffer(struct vmw_resource *res,
1197                           bool interruptible,
1198                           struct ttm_validate_buffer *val_buf)
1199 {
1200         struct list_head val_list;
1201         bool backup_dirty = false;
1202         int ret;
1203
1204         if (unlikely(res->backup == NULL)) {
1205                 ret = vmw_resource_buf_alloc(res, interruptible);
1206                 if (unlikely(ret != 0))
1207                         return ret;
1208         }
1209
1210         INIT_LIST_HEAD(&val_list);
1211         val_buf->bo = ttm_bo_reference(&res->backup->base);
1212         list_add_tail(&val_buf->head, &val_list);
1213         ret = ttm_eu_reserve_buffers(NULL, &val_list);
1214         if (unlikely(ret != 0))
1215                 goto out_no_reserve;
1216
1217         if (res->func->needs_backup && list_empty(&res->mob_head))
1218                 return 0;
1219
1220         backup_dirty = res->backup_dirty;
1221         ret = ttm_bo_validate(&res->backup->base,
1222                               res->func->backup_placement,
1223                               true, false);
1224
1225         if (unlikely(ret != 0))
1226                 goto out_no_validate;
1227
1228         return 0;
1229
1230 out_no_validate:
1231         ttm_eu_backoff_reservation(NULL, &val_list);
1232 out_no_reserve:
1233         ttm_bo_unref(&val_buf->bo);
1234         if (backup_dirty)
1235                 vmw_dmabuf_unreference(&res->backup);
1236
1237         return ret;
1238 }
1239
1240 /**
1241  * vmw_resource_reserve - Reserve a resource for command submission
1242  *
1243  * @res:            The resource to reserve.
1244  *
1245  * This function takes the resource off the LRU list and make sure
1246  * a backup buffer is present for guest-backed resources. However,
1247  * the buffer may not be bound to the resource at this point.
1248  *
1249  */
1250 int vmw_resource_reserve(struct vmw_resource *res, bool no_backup)
1251 {
1252         struct vmw_private *dev_priv = res->dev_priv;
1253         int ret;
1254
1255         write_lock(&dev_priv->resource_lock);
1256         list_del_init(&res->lru_head);
1257         write_unlock(&dev_priv->resource_lock);
1258
1259         if (res->func->needs_backup && res->backup == NULL &&
1260             !no_backup) {
1261                 ret = vmw_resource_buf_alloc(res, true);
1262                 if (unlikely(ret != 0))
1263                         return ret;
1264         }
1265
1266         return 0;
1267 }
1268
1269 /**
1270  * vmw_resource_backoff_reservation - Unreserve and unreference a
1271  *                                    backup buffer
1272  *.
1273  * @val_buf:        Backup buffer information.
1274  */
1275 static void
1276 vmw_resource_backoff_reservation(struct ttm_validate_buffer *val_buf)
1277 {
1278         struct list_head val_list;
1279
1280         if (likely(val_buf->bo == NULL))
1281                 return;
1282
1283         INIT_LIST_HEAD(&val_list);
1284         list_add_tail(&val_buf->head, &val_list);
1285         ttm_eu_backoff_reservation(NULL, &val_list);
1286         ttm_bo_unref(&val_buf->bo);
1287 }
1288
1289 /**
1290  * vmw_resource_do_evict - Evict a resource, and transfer its data
1291  *                         to a backup buffer.
1292  *
1293  * @res:            The resource to evict.
1294  * @interruptible:  Whether to wait interruptible.
1295  */
1296 int vmw_resource_do_evict(struct vmw_resource *res, bool interruptible)
1297 {
1298         struct ttm_validate_buffer val_buf;
1299         const struct vmw_res_func *func = res->func;
1300         int ret;
1301
1302         BUG_ON(!func->may_evict);
1303
1304         val_buf.bo = NULL;
1305         ret = vmw_resource_check_buffer(res, interruptible, &val_buf);
1306         if (unlikely(ret != 0))
1307                 return ret;
1308
1309         if (unlikely(func->unbind != NULL &&
1310                      (!func->needs_backup || !list_empty(&res->mob_head)))) {
1311                 ret = func->unbind(res, res->res_dirty, &val_buf);
1312                 if (unlikely(ret != 0))
1313                         goto out_no_unbind;
1314                 list_del_init(&res->mob_head);
1315         }
1316         ret = func->destroy(res);
1317         res->backup_dirty = true;
1318         res->res_dirty = false;
1319 out_no_unbind:
1320         vmw_resource_backoff_reservation(&val_buf);
1321
1322         return ret;
1323 }
1324
1325
1326 /**
1327  * vmw_resource_validate - Make a resource up-to-date and visible
1328  *                         to the device.
1329  *
1330  * @res:            The resource to make visible to the device.
1331  *
1332  * On succesful return, any backup DMA buffer pointed to by @res->backup will
1333  * be reserved and validated.
1334  * On hardware resource shortage, this function will repeatedly evict
1335  * resources of the same type until the validation succeeds.
1336  */
1337 int vmw_resource_validate(struct vmw_resource *res)
1338 {
1339         int ret;
1340         struct vmw_resource *evict_res;
1341         struct vmw_private *dev_priv = res->dev_priv;
1342         struct list_head *lru_list = &dev_priv->res_lru[res->func->res_type];
1343         struct ttm_validate_buffer val_buf;
1344         unsigned err_count = 0;
1345
1346         if (likely(!res->func->may_evict))
1347                 return 0;
1348
1349         val_buf.bo = NULL;
1350         if (res->backup)
1351                 val_buf.bo = &res->backup->base;
1352         do {
1353                 ret = vmw_resource_do_validate(res, &val_buf);
1354                 if (likely(ret != -EBUSY))
1355                         break;
1356
1357                 write_lock(&dev_priv->resource_lock);
1358                 if (list_empty(lru_list) || !res->func->may_evict) {
1359                         DRM_ERROR("Out of device device resources "
1360                                   "for %s.\n", res->func->type_name);
1361                         ret = -EBUSY;
1362                         write_unlock(&dev_priv->resource_lock);
1363                         break;
1364                 }
1365
1366                 evict_res = vmw_resource_reference
1367                         (list_first_entry(lru_list, struct vmw_resource,
1368                                           lru_head));
1369                 list_del_init(&evict_res->lru_head);
1370
1371                 write_unlock(&dev_priv->resource_lock);
1372
1373                 ret = vmw_resource_do_evict(evict_res, true);
1374                 if (unlikely(ret != 0)) {
1375                         write_lock(&dev_priv->resource_lock);
1376                         list_add_tail(&evict_res->lru_head, lru_list);
1377                         write_unlock(&dev_priv->resource_lock);
1378                         if (ret == -ERESTARTSYS ||
1379                             ++err_count > VMW_RES_EVICT_ERR_COUNT) {
1380                                 vmw_resource_unreference(&evict_res);
1381                                 goto out_no_validate;
1382                         }
1383                 }
1384
1385                 vmw_resource_unreference(&evict_res);
1386         } while (1);
1387
1388         if (unlikely(ret != 0))
1389                 goto out_no_validate;
1390         else if (!res->func->needs_backup && res->backup) {
1391                 list_del_init(&res->mob_head);
1392                 vmw_dmabuf_unreference(&res->backup);
1393         }
1394
1395         return 0;
1396
1397 out_no_validate:
1398         return ret;
1399 }
1400
1401 /**
1402  * vmw_fence_single_bo - Utility function to fence a single TTM buffer
1403  *                       object without unreserving it.
1404  *
1405  * @bo:             Pointer to the struct ttm_buffer_object to fence.
1406  * @fence:          Pointer to the fence. If NULL, this function will
1407  *                  insert a fence into the command stream..
1408  *
1409  * Contrary to the ttm_eu version of this function, it takes only
1410  * a single buffer object instead of a list, and it also doesn't
1411  * unreserve the buffer object, which needs to be done separately.
1412  */
1413 void vmw_fence_single_bo(struct ttm_buffer_object *bo,
1414                          struct vmw_fence_obj *fence)
1415 {
1416         struct ttm_bo_device *bdev = bo->bdev;
1417         struct ttm_bo_driver *driver = bdev->driver;
1418         struct vmw_fence_obj *old_fence_obj;
1419         struct vmw_private *dev_priv =
1420                 container_of(bdev, struct vmw_private, bdev);
1421
1422         if (fence == NULL)
1423                 vmw_execbuf_fence_commands(NULL, dev_priv, &fence, NULL);
1424         else
1425                 driver->sync_obj_ref(fence);
1426
1427         spin_lock(&bdev->fence_lock);
1428
1429         old_fence_obj = bo->sync_obj;
1430         bo->sync_obj = fence;
1431
1432         spin_unlock(&bdev->fence_lock);
1433
1434         if (old_fence_obj)
1435                 vmw_fence_obj_unreference(&old_fence_obj);
1436 }
1437
1438 /**
1439  * vmw_resource_move_notify - TTM move_notify_callback
1440  *
1441  * @bo:             The TTM buffer object about to move.
1442  * @mem:            The truct ttm_mem_reg indicating to what memory
1443  *                  region the move is taking place.
1444  *
1445  * Evicts the Guest Backed hardware resource if the backup
1446  * buffer is being moved out of MOB memory.
1447  * Note that this function should not race with the resource
1448  * validation code as long as it accesses only members of struct
1449  * resource that remain static while bo::res is !NULL and
1450  * while we have @bo reserved. struct resource::backup is *not* a
1451  * static member. The resource validation code will take care
1452  * to set @bo::res to NULL, while having @bo reserved when the
1453  * buffer is no longer bound to the resource, so @bo:res can be
1454  * used to determine whether there is a need to unbind and whether
1455  * it is safe to unbind.
1456  */
1457 void vmw_resource_move_notify(struct ttm_buffer_object *bo,
1458                               struct ttm_mem_reg *mem)
1459 {
1460         struct vmw_dma_buffer *dma_buf;
1461
1462         if (mem == NULL)
1463                 return;
1464
1465         if (bo->destroy != vmw_dmabuf_bo_free &&
1466             bo->destroy != vmw_user_dmabuf_destroy)
1467                 return;
1468
1469         dma_buf = container_of(bo, struct vmw_dma_buffer, base);
1470
1471         if (mem->mem_type != VMW_PL_MOB) {
1472                 struct vmw_resource *res, *n;
1473                 struct ttm_bo_device *bdev = bo->bdev;
1474                 struct ttm_validate_buffer val_buf;
1475
1476                 val_buf.bo = bo;
1477
1478                 list_for_each_entry_safe(res, n, &dma_buf->res_list, mob_head) {
1479
1480                         if (unlikely(res->func->unbind == NULL))
1481                                 continue;
1482
1483                         (void) res->func->unbind(res, true, &val_buf);
1484                         res->backup_dirty = true;
1485                         res->res_dirty = false;
1486                         list_del_init(&res->mob_head);
1487                 }
1488
1489                 spin_lock(&bdev->fence_lock);
1490                 (void) ttm_bo_wait(bo, false, false, false);
1491                 spin_unlock(&bdev->fence_lock);
1492         }
1493 }
1494
1495 /**
1496  * vmw_resource_needs_backup - Return whether a resource needs a backup buffer.
1497  *
1498  * @res:            The resource being queried.
1499  */
1500 bool vmw_resource_needs_backup(const struct vmw_resource *res)
1501 {
1502         return res->func->needs_backup;
1503 }
1504
1505 /**
1506  * vmw_resource_evict_type - Evict all resources of a specific type
1507  *
1508  * @dev_priv:       Pointer to a device private struct
1509  * @type:           The resource type to evict
1510  *
1511  * To avoid thrashing starvation or as part of the hibernation sequence,
1512  * try to evict all evictable resources of a specific type.
1513  */
1514 static void vmw_resource_evict_type(struct vmw_private *dev_priv,
1515                                     enum vmw_res_type type)
1516 {
1517         struct list_head *lru_list = &dev_priv->res_lru[type];
1518         struct vmw_resource *evict_res;
1519         unsigned err_count = 0;
1520         int ret;
1521
1522         do {
1523                 write_lock(&dev_priv->resource_lock);
1524
1525                 if (list_empty(lru_list))
1526                         goto out_unlock;
1527
1528                 evict_res = vmw_resource_reference(
1529                         list_first_entry(lru_list, struct vmw_resource,
1530                                          lru_head));
1531                 list_del_init(&evict_res->lru_head);
1532                 write_unlock(&dev_priv->resource_lock);
1533
1534                 ret = vmw_resource_do_evict(evict_res, false);
1535                 if (unlikely(ret != 0)) {
1536                         write_lock(&dev_priv->resource_lock);
1537                         list_add_tail(&evict_res->lru_head, lru_list);
1538                         write_unlock(&dev_priv->resource_lock);
1539                         if (++err_count > VMW_RES_EVICT_ERR_COUNT) {
1540                                 vmw_resource_unreference(&evict_res);
1541                                 return;
1542                         }
1543                 }
1544
1545                 vmw_resource_unreference(&evict_res);
1546         } while (1);
1547
1548 out_unlock:
1549         write_unlock(&dev_priv->resource_lock);
1550 }
1551
1552 /**
1553  * vmw_resource_evict_all - Evict all evictable resources
1554  *
1555  * @dev_priv:       Pointer to a device private struct
1556  *
1557  * To avoid thrashing starvation or as part of the hibernation sequence,
1558  * evict all evictable resources. In particular this means that all
1559  * guest-backed resources that are registered with the device are
1560  * evicted and the OTable becomes clean.
1561  */
1562 void vmw_resource_evict_all(struct vmw_private *dev_priv)
1563 {
1564         enum vmw_res_type type;
1565
1566         mutex_lock(&dev_priv->cmdbuf_mutex);
1567
1568         for (type = 0; type < vmw_res_max; ++type)
1569                 vmw_resource_evict_type(dev_priv, type);
1570
1571         mutex_unlock(&dev_priv->cmdbuf_mutex);
1572 }