intel/intel_bufmgr_gem.c

   1 /**************************************************************************
   2  *
   3  * Copyright © 2007 Red Hat Inc.
   4  * Copyright © 2007-2012 Intel Corporation
   5  * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND., USA
   6  * All Rights Reserved.
   7  *
   8  * Permission is hereby granted, free of charge, to any person obtaining a
   9  * copy of this software and associated documentation files (the
  10  * "Software"), to deal in the Software without restriction, including
  11  * without limitation the rights to use, copy, modify, merge, publish,
  12  * distribute, sub license, and/or sell copies of the Software, and to
  13  * permit persons to whom the Software is furnished to do so, subject to
  14  * the following conditions:
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  19  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  22  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  *
  24  * The above copyright notice and this permission notice (including the
  25  * next paragraph) shall be included in all copies or substantial portions
  26  * of the Software.
  27  *
  28  *
  29  **************************************************************************/
  30 /*
  31  * Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com>
  32  *          Keith Whitwell <keithw-at-tungstengraphics-dot-com>
  33  *          Eric Anholt <eric@anholt.net>
  34  *          Dave Airlie <airlied@linux.ie>
  35  */
  36
  37 #ifdef HAVE_CONFIG_H
  38 #include "config.h"
  39 #endif
  40
  41 #include <xf86drm.h>
  42 #include <xf86atomic.h>
  43 #include <fcntl.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47 #include <unistd.h>
  48 #include <assert.h>
  49 #include <pthread.h>
  50 #include <sys/ioctl.h>
  51 #include <sys/stat.h>
  52 #include <sys/types.h>
  53 #include <stdbool.h>
  54
  55 #include "errno.h"
  56 #ifndef ETIME
  57 #define ETIME ETIMEDOUT
  58 #endif
  59 #include "libdrm_macros.h"
  60 #include "libdrm_lists.h"
  61 #include "intel_bufmgr.h"
  62 #include "intel_bufmgr_priv.h"
  63 #include "intel_chipset.h"
  64 #include "string.h"
  65
  66 #include "i915_drm.h"
  67
  68 #ifdef HAVE_VALGRIND
  69 #include <valgrind.h>
  70 #include <memcheck.h>
  71 #define VG(x) x
  72 #else
  73 #define VG(x)
  74 #endif
  75
  76 #define memclear(s) memset(&s, 0, sizeof(s))
  77
  78 #define DBG(...) do {                                   \
  79         if (bufmgr_gem->bufmgr.debug)                   \
  80                 fprintf(stderr, __VA_ARGS__);           \
  81 } while (0)
  82
  83 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
  84 #define MAX2(A, B) ((A) > (B) ? (A) : (B))
  85
  86 typedef struct _drm_intel_bo_gem drm_intel_bo_gem;
  87
  88 struct drm_intel_gem_bo_bucket {
  89         drmMMListHead head;
  90         unsigned long size;
  91 };
  92
  93 typedef struct _drm_intel_bufmgr_gem {
  94         drm_intel_bufmgr bufmgr;
  95
  96         atomic_t refcount;
  97
  98         int fd;
  99
 100         int max_relocs;
 101
 102         pthread_mutex_t lock;
 103
 104         struct drm_i915_gem_exec_object *exec_objects;
 105         struct drm_i915_gem_exec_object2 *exec2_objects;
 106         drm_intel_bo **exec_bos;
 107         int exec_size;
 108         int exec_count;
 109
 110         /** Array of lists of cached gem objects of power-of-two sizes */
 111         struct drm_intel_gem_bo_bucket cache_bucket[14 * 4];
 112         int num_buckets;
 113         time_t time;
 114
 115         drmMMListHead managers;
 116
 117         drmMMListHead named;
 118         drmMMListHead vma_cache;
 119         int vma_count, vma_open, vma_max;
 120
 121         uint64_t gtt_size;
 122         int available_fences;
 123         int pci_device;
 124         int gen;
 125         unsigned int has_bsd : 1;
 126         unsigned int has_blt : 1;
 127         unsigned int has_relaxed_fencing : 1;
 128         unsigned int has_llc : 1;
 129         unsigned int has_wait_timeout : 1;
 130         unsigned int bo_reuse : 1;
 131         unsigned int no_exec : 1;
 132         unsigned int has_vebox : 1;
 133         bool fenced_relocs;
 134
 135         struct {
 136                 void *ptr;
 137                 uint32_t handle;
 138         } userptr_active;
 139
 140 } drm_intel_bufmgr_gem;
 141
 142 #define DRM_INTEL_RELOC_FENCE (1<<0)
 143
 144 typedef struct _drm_intel_reloc_target_info {
 145         drm_intel_bo *bo;
 146         int flags;
 147 } drm_intel_reloc_target;
 148
 149 struct _drm_intel_bo_gem {
 150         drm_intel_bo bo;
 151
 152         atomic_t refcount;
 153         uint32_t gem_handle;
 154         const char *name;
 155
 156         /**
 157          * Kenel-assigned global name for this object
 158          *
 159          * List contains both flink named and prime fd'd objects
 160          */
 161         unsigned int global_name;
 162         drmMMListHead name_list;
 163
 164         /**
 165          * Index of the buffer within the validation list while preparing a
 166          * batchbuffer execution.
 167          */
 168         int validate_index;
 169
 170         /**
 171          * Current tiling mode
 172          */
 173         uint32_t tiling_mode;
 174         uint32_t swizzle_mode;
 175         unsigned long stride;
 176
 177         time_t free_time;
 178
 179         /** Array passed to the DRM containing relocation information. */
 180         struct drm_i915_gem_relocation_entry *relocs;
 181         /**
 182          * Array of info structs corresponding to relocs[i].target_handle etc
 183          */
 184         drm_intel_reloc_target *reloc_target_info;
 185         /** Number of entries in relocs */
 186         int reloc_count;
 187         /** Mapped address for the buffer, saved across map/unmap cycles */
 188         void *mem_virtual;
 189         /** GTT virtual address for the buffer, saved across map/unmap cycles */
 190         void *gtt_virtual;
 191         /**
 192          * Virtual address of the buffer allocated by user, used for userptr
 193          * objects only.
 194          */
 195         void *user_virtual;
 196         int map_count;
 197         drmMMListHead vma_list;
 198
 199         /** BO cache list */
 200         drmMMListHead head;
 201
 202         /**
 203          * Boolean of whether this BO and its children have been included in
 204          * the current drm_intel_bufmgr_check_aperture_space() total.
 205          */
 206         bool included_in_check_aperture;
 207
 208         /**
 209          * Boolean of whether this buffer has been used as a relocation
 210          * target and had its size accounted for, and thus can't have any
 211          * further relocations added to it.
 212          */
 213         bool used_as_reloc_target;
 214
 215         /**
 216          * Boolean of whether we have encountered an error whilst building the relocation tree.
 217          */
 218         bool has_error;
 219
 220         /**
 221          * Boolean of whether this buffer can be re-used
 222          */
 223         bool reusable;
 224
 225         /**
 226          * Boolean of whether the GPU is definitely not accessing the buffer.
 227          *
 228          * This is only valid when reusable, since non-reusable
 229          * buffers are those that have been shared wth other
 230          * processes, so we don't know their state.
 231          */
 232         bool idle;
 233
 234         /**
 235          * Boolean of whether this buffer was allocated with userptr
 236          */
 237         bool is_userptr;
 238
 239         /**
 240          * Size in bytes of this buffer and its relocation descendents.
 241          *
 242          * Used to avoid costly tree walking in
 243          * drm_intel_bufmgr_check_aperture in the common case.
 244          */
 245         int reloc_tree_size;
 246
 247         /**
 248          * Number of potential fence registers required by this buffer and its
 249          * relocations.
 250          */
 251         int reloc_tree_fences;
 252
 253         /** Flags that we may need to do the SW_FINSIH ioctl on unmap. */
 254         bool mapped_cpu_write;
 255 };
 256
 257 static unsigned int
 258 drm_intel_gem_estimate_batch_space(drm_intel_bo ** bo_array, int count);
 259
 260 static unsigned int
 261 drm_intel_gem_compute_batch_space(drm_intel_bo ** bo_array, int count);
 262
 263 static int
 264 drm_intel_gem_bo_get_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
 265                             uint32_t * swizzle_mode);
 266
 267 static int
 268 drm_intel_gem_bo_set_tiling_internal(drm_intel_bo *bo,
 269                                      uint32_t tiling_mode,
 270                                      uint32_t stride);
 271
 272 static void drm_intel_gem_bo_unreference_locked_timed(drm_intel_bo *bo,
 273                                                       time_t time);
 274
 275 static void drm_intel_gem_bo_unreference(drm_intel_bo *bo);
 276
 277 static void drm_intel_gem_bo_free(drm_intel_bo *bo);
 278
 279 static unsigned long
 280 drm_intel_gem_bo_tile_size(drm_intel_bufmgr_gem *bufmgr_gem, unsigned long size,
 281                            uint32_t *tiling_mode)
 282 {
 283         unsigned long min_size, max_size;
 284         unsigned long i;
 285
 286         if (*tiling_mode == I915_TILING_NONE)
 287                 return size;
 288
 289         /* 965+ just need multiples of page size for tiling */
 290         if (bufmgr_gem->gen >= 4)
 291                 return ROUND_UP_TO(size, 4096);
 292
 293         /* Older chips need powers of two, of at least 512k or 1M */
 294         if (bufmgr_gem->gen == 3) {
 295                 min_size = 1024*1024;
 296                 max_size = 128*1024*1024;
 297         } else {
 298                 min_size = 512*1024;
 299                 max_size = 64*1024*1024;
 300         }
 301
 302         if (size > max_size) {
 303                 *tiling_mode = I915_TILING_NONE;
 304                 return size;
 305         }
 306
 307         /* Do we need to allocate every page for the fence? */
 308         if (bufmgr_gem->has_relaxed_fencing)
 309                 return ROUND_UP_TO(size, 4096);
 310
 311         for (i = min_size; i < size; i <<= 1)
 312                 ;
 313
 314         return i;
 315 }
 316
 317 /*
 318  * Round a given pitch up to the minimum required for X tiling on a
 319  * given chip.  We use 512 as the minimum to allow for a later tiling
 320  * change.
 321  */
 322 static unsigned long
 323 drm_intel_gem_bo_tile_pitch(drm_intel_bufmgr_gem *bufmgr_gem,
 324                             unsigned long pitch, uint32_t *tiling_mode)
 325 {
 326         unsigned long tile_width;
 327         unsigned long i;
 328
 329         /* If untiled, then just align it so that we can do rendering
 330          * to it with the 3D engine.
 331          */
 332         if (*tiling_mode == I915_TILING_NONE)
 333                 return ALIGN(pitch, 64);
 334
 335         if (*tiling_mode == I915_TILING_X
 336                         || (IS_915(bufmgr_gem->pci_device)
 337                             && *tiling_mode == I915_TILING_Y))
 338                 tile_width = 512;
 339         else
 340                 tile_width = 128;
 341
 342         /* 965 is flexible */
 343         if (bufmgr_gem->gen >= 4)
 344                 return ROUND_UP_TO(pitch, tile_width);
 345
 346         /* The older hardware has a maximum pitch of 8192 with tiled
 347          * surfaces, so fallback to untiled if it's too large.
 348          */
 349         if (pitch > 8192) {
 350                 *tiling_mode = I915_TILING_NONE;
 351                 return ALIGN(pitch, 64);
 352         }
 353
 354         /* Pre-965 needs power of two tile width */
 355         for (i = tile_width; i < pitch; i <<= 1)
 356                 ;
 357
 358         return i;
 359 }
 360
 361 static struct drm_intel_gem_bo_bucket *
 362 drm_intel_gem_bo_bucket_for_size(drm_intel_bufmgr_gem *bufmgr_gem,
 363                                  unsigned long size)
 364 {
 365         int i;
 366
 367         for (i = 0; i < bufmgr_gem->num_buckets; i++) {
 368                 struct drm_intel_gem_bo_bucket *bucket =
 369                     &bufmgr_gem->cache_bucket[i];
 370                 if (bucket->size >= size) {
 371                         return bucket;
 372                 }
 373         }
 374
 375         return NULL;
 376 }
 377
 378 static void
 379 drm_intel_gem_dump_validation_list(drm_intel_bufmgr_gem *bufmgr_gem)
 380 {
 381         int i, j;
 382
 383         for (i = 0; i < bufmgr_gem->exec_count; i++) {
 384                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
 385                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 386
 387                 if (bo_gem->relocs == NULL) {
 388                         DBG("%2d: %d (%s)\n", i, bo_gem->gem_handle,
 389                             bo_gem->name);
 390                         continue;
 391                 }
 392
 393                 for (j = 0; j < bo_gem->reloc_count; j++) {
 394                         drm_intel_bo *target_bo = bo_gem->reloc_target_info[j].bo;
 395                         drm_intel_bo_gem *target_gem =
 396                             (drm_intel_bo_gem *) target_bo;
 397
 398                         DBG("%2d: %d (%s)@0x%08llx -> "
 399                             "%d (%s)@0x%08lx + 0x%08x\n",
 400                             i,
 401                             bo_gem->gem_handle, bo_gem->name,
 402                             (unsigned long long)bo_gem->relocs[j].offset,
 403                             target_gem->gem_handle,
 404                             target_gem->name,
 405                             target_bo->offset64,
 406                             bo_gem->relocs[j].delta);
 407                 }
 408         }
 409 }
 410
 411 static inline void
 412 drm_intel_gem_bo_reference(drm_intel_bo *bo)
 413 {
 414         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 415
 416         atomic_inc(&bo_gem->refcount);
 417 }
 418
 419 /**
 420  * Adds the given buffer to the list of buffers to be validated (moved into the
 421  * appropriate memory type) with the next batch submission.
 422  *
 423  * If a buffer is validated multiple times in a batch submission, it ends up
 424  * with the intersection of the memory type flags and the union of the
 425  * access flags.
 426  */
 427 static void
 428 drm_intel_add_validate_buffer(drm_intel_bo *bo)
 429 {
 430         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 431         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 432         int index;
 433
 434         if (bo_gem->validate_index != -1)
 435                 return;
 436
 437         /* Extend the array of validation entries as necessary. */
 438         if (bufmgr_gem->exec_count == bufmgr_gem->exec_size) {
 439                 int new_size = bufmgr_gem->exec_size * 2;
 440
 441                 if (new_size == 0)
 442                         new_size = 5;
 443
 444                 bufmgr_gem->exec_objects =
 445                     realloc(bufmgr_gem->exec_objects,
 446                             sizeof(*bufmgr_gem->exec_objects) * new_size);
 447                 bufmgr_gem->exec_bos =
 448                     realloc(bufmgr_gem->exec_bos,
 449                             sizeof(*bufmgr_gem->exec_bos) * new_size);
 450                 bufmgr_gem->exec_size = new_size;
 451         }
 452
 453         index = bufmgr_gem->exec_count;
 454         bo_gem->validate_index = index;
 455         /* Fill in array entry */
 456         bufmgr_gem->exec_objects[index].handle = bo_gem->gem_handle;
 457         bufmgr_gem->exec_objects[index].relocation_count = bo_gem->reloc_count;
 458         bufmgr_gem->exec_objects[index].relocs_ptr = (uintptr_t) bo_gem->relocs;
 459         bufmgr_gem->exec_objects[index].alignment = bo->align;
 460         bufmgr_gem->exec_objects[index].offset = 0;
 461         bufmgr_gem->exec_bos[index] = bo;
 462         bufmgr_gem->exec_count++;
 463 }
 464
 465 static void
 466 drm_intel_add_validate_buffer2(drm_intel_bo *bo, int need_fence)
 467 {
 468         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 469         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 470         int index;
 471
 472         if (bo_gem->validate_index != -1) {
 473                 if (need_fence)
 474                         bufmgr_gem->exec2_objects[bo_gem->validate_index].flags |=
 475                                 EXEC_OBJECT_NEEDS_FENCE;
 476                 return;
 477         }
 478
 479         /* Extend the array of validation entries as necessary. */
 480         if (bufmgr_gem->exec_count == bufmgr_gem->exec_size) {
 481                 int new_size = bufmgr_gem->exec_size * 2;
 482
 483                 if (new_size == 0)
 484                         new_size = 5;
 485
 486                 bufmgr_gem->exec2_objects =
 487                         realloc(bufmgr_gem->exec2_objects,
 488                                 sizeof(*bufmgr_gem->exec2_objects) * new_size);
 489                 bufmgr_gem->exec_bos =
 490                         realloc(bufmgr_gem->exec_bos,
 491                                 sizeof(*bufmgr_gem->exec_bos) * new_size);
 492                 bufmgr_gem->exec_size = new_size;
 493         }
 494
 495         index = bufmgr_gem->exec_count;
 496         bo_gem->validate_index = index;
 497         /* Fill in array entry */
 498         bufmgr_gem->exec2_objects[index].handle = bo_gem->gem_handle;
 499         bufmgr_gem->exec2_objects[index].relocation_count = bo_gem->reloc_count;
 500         bufmgr_gem->exec2_objects[index].relocs_ptr = (uintptr_t)bo_gem->relocs;
 501         bufmgr_gem->exec2_objects[index].alignment = bo->align;
 502         bufmgr_gem->exec2_objects[index].offset = 0;
 503         bufmgr_gem->exec_bos[index] = bo;
 504         bufmgr_gem->exec2_objects[index].flags = 0;
 505         bufmgr_gem->exec2_objects[index].rsvd1 = 0;
 506         bufmgr_gem->exec2_objects[index].rsvd2 = 0;
 507         if (need_fence) {
 508                 bufmgr_gem->exec2_objects[index].flags |=
 509                         EXEC_OBJECT_NEEDS_FENCE;
 510         }
 511         bufmgr_gem->exec_count++;
 512 }
 513
 514 #define RELOC_BUF_SIZE(x) ((I915_RELOC_HEADER + x * I915_RELOC0_STRIDE) * \
 515         sizeof(uint32_t))
 516
 517 static void
 518 drm_intel_bo_gem_set_in_aperture_size(drm_intel_bufmgr_gem *bufmgr_gem,
 519                                       drm_intel_bo_gem *bo_gem,
 520                                       unsigned int alignment)
 521 {
 522         unsigned int size;
 523
 524         assert(!bo_gem->used_as_reloc_target);
 525
 526         /* The older chipsets are far-less flexible in terms of tiling,
 527          * and require tiled buffer to be size aligned in the aperture.
 528          * This means that in the worst possible case we will need a hole
 529          * twice as large as the object in order for it to fit into the
 530          * aperture. Optimal packing is for wimps.
 531          */
 532         size = bo_gem->bo.size;
 533         if (bufmgr_gem->gen < 4 && bo_gem->tiling_mode != I915_TILING_NONE) {
 534                 unsigned int min_size;
 535
 536                 if (bufmgr_gem->has_relaxed_fencing) {
 537                         if (bufmgr_gem->gen == 3)
 538                                 min_size = 1024*1024;
 539                         else
 540                                 min_size = 512*1024;
 541
 542                         while (min_size < size)
 543                                 min_size *= 2;
 544                 } else
 545                         min_size = size;
 546
 547                 /* Account for worst-case alignment. */
 548                 alignment = MAX2(alignment, min_size);
 549         }
 550
 551         bo_gem->reloc_tree_size = size + alignment;
 552 }
 553
 554 static int
 555 drm_intel_setup_reloc_list(drm_intel_bo *bo)
 556 {
 557         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 558         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 559         unsigned int max_relocs = bufmgr_gem->max_relocs;
 560
 561         if (bo->size / 4 < max_relocs)
 562                 max_relocs = bo->size / 4;
 563
 564         bo_gem->relocs = malloc(max_relocs *
 565                                 sizeof(struct drm_i915_gem_relocation_entry));
 566         bo_gem->reloc_target_info = malloc(max_relocs *
 567                                            sizeof(drm_intel_reloc_target));
 568         if (bo_gem->relocs == NULL || bo_gem->reloc_target_info == NULL) {
 569                 bo_gem->has_error = true;
 570
 571                 free (bo_gem->relocs);
 572                 bo_gem->relocs = NULL;
 573
 574                 free (bo_gem->reloc_target_info);
 575                 bo_gem->reloc_target_info = NULL;
 576
 577                 return 1;
 578         }
 579
 580         return 0;
 581 }
 582
 583 static int
 584 drm_intel_gem_bo_busy(drm_intel_bo *bo)
 585 {
 586         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 587         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 588         struct drm_i915_gem_busy busy;
 589         int ret;
 590
 591         if (bo_gem->reusable && bo_gem->idle)
 592                 return false;
 593
 594         memclear(busy);
 595         busy.handle = bo_gem->gem_handle;
 596
 597         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_BUSY, &busy);
 598         if (ret == 0) {
 599                 bo_gem->idle = !busy.busy;
 600                 return busy.busy;
 601         } else {
 602                 return false;
 603         }
 604         return (ret == 0 && busy.busy);
 605 }
 606
 607 static int
 608 drm_intel_gem_bo_madvise_internal(drm_intel_bufmgr_gem *bufmgr_gem,
 609                                   drm_intel_bo_gem *bo_gem, int state)
 610 {
 611         struct drm_i915_gem_madvise madv;
 612
 613         memclear(madv);
 614         madv.handle = bo_gem->gem_handle;
 615         madv.madv = state;
 616         madv.retained = 1;
 617         drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_MADVISE, &madv);
 618
 619         return madv.retained;
 620 }
 621
 622 static int
 623 drm_intel_gem_bo_madvise(drm_intel_bo *bo, int madv)
 624 {
 625         return drm_intel_gem_bo_madvise_internal
 626                 ((drm_intel_bufmgr_gem *) bo->bufmgr,
 627                  (drm_intel_bo_gem *) bo,
 628                  madv);
 629 }
 630
 631 /* drop the oldest entries that have been purged by the kernel */
 632 static void
 633 drm_intel_gem_bo_cache_purge_bucket(drm_intel_bufmgr_gem *bufmgr_gem,
 634                                     struct drm_intel_gem_bo_bucket *bucket)
 635 {
 636         while (!DRMLISTEMPTY(&bucket->head)) {
 637                 drm_intel_bo_gem *bo_gem;
 638
 639                 bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
 640                                       bucket->head.next, head);
 641                 if (drm_intel_gem_bo_madvise_internal
 642                     (bufmgr_gem, bo_gem, I915_MADV_DONTNEED))
 643                         break;
 644
 645                 DRMLISTDEL(&bo_gem->head);
 646                 drm_intel_gem_bo_free(&bo_gem->bo);
 647         }
 648 }
 649
 650 static drm_intel_bo *
 651 drm_intel_gem_bo_alloc_internal(drm_intel_bufmgr *bufmgr,
 652                                 const char *name,
 653                                 unsigned long size,
 654                                 unsigned long flags,
 655                                 uint32_t tiling_mode,
 656                                 unsigned long stride,
 657                                 unsigned int alignment)
 658 {
 659         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
 660         drm_intel_bo_gem *bo_gem;
 661         unsigned int page_size = getpagesize();
 662         int ret;
 663         struct drm_intel_gem_bo_bucket *bucket;
 664         bool alloc_from_cache;
 665         unsigned long bo_size;
 666         bool for_render = false;
 667
 668         if (flags & BO_ALLOC_FOR_RENDER)
 669                 for_render = true;
 670
 671         /* Round the allocated size up to a power of two number of pages. */
 672         bucket = drm_intel_gem_bo_bucket_for_size(bufmgr_gem, size);
 673
 674         /* If we don't have caching at this size, don't actually round the
 675          * allocation up.
 676          */
 677         if (bucket == NULL) {
 678                 bo_size = size;
 679                 if (bo_size < page_size)
 680                         bo_size = page_size;
 681         } else {
 682                 bo_size = bucket->size;
 683         }
 684
 685         pthread_mutex_lock(&bufmgr_gem->lock);
 686         /* Get a buffer out of the cache if available */
 687 retry:
 688         alloc_from_cache = false;
 689         if (bucket != NULL && !DRMLISTEMPTY(&bucket->head)) {
 690                 if (for_render) {
 691                         /* Allocate new render-target BOs from the tail (MRU)
 692                          * of the list, as it will likely be hot in the GPU
 693                          * cache and in the aperture for us.
 694                          */
 695                         bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
 696                                               bucket->head.prev, head);
 697                         DRMLISTDEL(&bo_gem->head);
 698                         alloc_from_cache = true;
 699                         bo_gem->bo.align = alignment;
 700                 } else {
 701                         assert(alignment == 0);
 702                         /* For non-render-target BOs (where we're probably
 703                          * going to map it first thing in order to fill it
 704                          * with data), check if the last BO in the cache is
 705                          * unbusy, and only reuse in that case. Otherwise,
 706                          * allocating a new buffer is probably faster than
 707                          * waiting for the GPU to finish.
 708                          */
 709                         bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
 710                                               bucket->head.next, head);
 711                         if (!drm_intel_gem_bo_busy(&bo_gem->bo)) {
 712                                 alloc_from_cache = true;
 713                                 DRMLISTDEL(&bo_gem->head);
 714                         }
 715                 }
 716
 717                 if (alloc_from_cache) {
 718                         if (!drm_intel_gem_bo_madvise_internal
 719                             (bufmgr_gem, bo_gem, I915_MADV_WILLNEED)) {
 720                                 drm_intel_gem_bo_free(&bo_gem->bo);
 721                                 drm_intel_gem_bo_cache_purge_bucket(bufmgr_gem,
 722                                                                     bucket);
 723                                 goto retry;
 724                         }
 725
 726                         if (drm_intel_gem_bo_set_tiling_internal(&bo_gem->bo,
 727                                                                  tiling_mode,
 728                                                                  stride)) {
 729                                 drm_intel_gem_bo_free(&bo_gem->bo);
 730                                 goto retry;
 731                         }
 732                 }
 733         }
 734         pthread_mutex_unlock(&bufmgr_gem->lock);
 735
 736         if (!alloc_from_cache) {
 737                 struct drm_i915_gem_create create;
 738
 739                 bo_gem = calloc(1, sizeof(*bo_gem));
 740                 if (!bo_gem)
 741                         return NULL;
 742
 743                 bo_gem->bo.size = bo_size;
 744
 745                 memclear(create);
 746                 create.size = bo_size;
 747
 748                 ret = drmIoctl(bufmgr_gem->fd,
 749                                DRM_IOCTL_I915_GEM_CREATE,
 750                                &create);
 751                 bo_gem->gem_handle = create.handle;
 752                 bo_gem->bo.handle = bo_gem->gem_handle;
 753                 if (ret != 0) {
 754                         free(bo_gem);
 755                         return NULL;
 756                 }
 757                 bo_gem->bo.bufmgr = bufmgr;
 758                 bo_gem->bo.align = alignment;
 759
 760                 bo_gem->tiling_mode = I915_TILING_NONE;
 761                 bo_gem->swizzle_mode = I915_BIT_6_SWIZZLE_NONE;
 762                 bo_gem->stride = 0;
 763
 764                 /* drm_intel_gem_bo_free calls DRMLISTDEL() for an uninitialized
 765                    list (vma_list), so better set the list head here */
 766                 DRMINITLISTHEAD(&bo_gem->name_list);
 767                 DRMINITLISTHEAD(&bo_gem->vma_list);
 768                 if (drm_intel_gem_bo_set_tiling_internal(&bo_gem->bo,
 769                                                          tiling_mode,
 770                                                          stride)) {
 771                     drm_intel_gem_bo_free(&bo_gem->bo);
 772                     return NULL;
 773                 }
 774         }
 775
 776         bo_gem->name = name;
 777         atomic_set(&bo_gem->refcount, 1);
 778         bo_gem->validate_index = -1;
 779         bo_gem->reloc_tree_fences = 0;
 780         bo_gem->used_as_reloc_target = false;
 781         bo_gem->has_error = false;
 782         bo_gem->reusable = true;
 783
 784         drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem, alignment);
 785
 786         DBG("bo_create: buf %d (%s) %ldb\n",
 787             bo_gem->gem_handle, bo_gem->name, size);
 788
 789         return &bo_gem->bo;
 790 }
 791
 792 static drm_intel_bo *
 793 drm_intel_gem_bo_alloc_for_render(drm_intel_bufmgr *bufmgr,
 794                                   const char *name,
 795                                   unsigned long size,
 796                                   unsigned int alignment)
 797 {
 798         return drm_intel_gem_bo_alloc_internal(bufmgr, name, size,
 799                                                BO_ALLOC_FOR_RENDER,
 800                                                I915_TILING_NONE, 0,
 801                                                alignment);
 802 }
 803
 804 static drm_intel_bo *
 805 drm_intel_gem_bo_alloc(drm_intel_bufmgr *bufmgr,
 806                        const char *name,
 807                        unsigned long size,
 808                        unsigned int alignment)
 809 {
 810         return drm_intel_gem_bo_alloc_internal(bufmgr, name, size, 0,
 811                                                I915_TILING_NONE, 0, 0);
 812 }
 813
 814 static drm_intel_bo *
 815 drm_intel_gem_bo_alloc_tiled(drm_intel_bufmgr *bufmgr, const char *name,
 816                              int x, int y, int cpp, uint32_t *tiling_mode,
 817                              unsigned long *pitch, unsigned long flags)
 818 {
 819         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
 820         unsigned long size, stride;
 821         uint32_t tiling;
 822
 823         do {
 824                 unsigned long aligned_y, height_alignment;
 825
 826                 tiling = *tiling_mode;
 827
 828                 /* If we're tiled, our allocations are in 8 or 32-row blocks,
 829                  * so failure to align our height means that we won't allocate
 830                  * enough pages.
 831                  *
 832                  * If we're untiled, we still have to align to 2 rows high
 833                  * because the data port accesses 2x2 blocks even if the
 834                  * bottom row isn't to be rendered, so failure to align means
 835                  * we could walk off the end of the GTT and fault.  This is
 836                  * documented on 965, and may be the case on older chipsets
 837                  * too so we try to be careful.
 838                  */
 839                 aligned_y = y;
 840                 height_alignment = 2;
 841
 842                 if ((bufmgr_gem->gen == 2) && tiling != I915_TILING_NONE)
 843                         height_alignment = 16;
 844                 else if (tiling == I915_TILING_X
 845                         || (IS_915(bufmgr_gem->pci_device)
 846                             && tiling == I915_TILING_Y))
 847                         height_alignment = 8;
 848                 else if (tiling == I915_TILING_Y)
 849                         height_alignment = 32;
 850                 aligned_y = ALIGN(y, height_alignment);
 851
 852                 stride = x * cpp;
 853                 stride = drm_intel_gem_bo_tile_pitch(bufmgr_gem, stride, tiling_mode);
 854                 size = stride * aligned_y;
 855                 size = drm_intel_gem_bo_tile_size(bufmgr_gem, size, tiling_mode);
 856         } while (*tiling_mode != tiling);
 857         *pitch = stride;
 858
 859         if (tiling == I915_TILING_NONE)
 860                 stride = 0;
 861
 862         return drm_intel_gem_bo_alloc_internal(bufmgr, name, size, flags,
 863                                                tiling, stride, 0);
 864 }
 865
 866 static drm_intel_bo *
 867 drm_intel_gem_bo_alloc_userptr(drm_intel_bufmgr *bufmgr,
 868                                 const char *name,
 869                                 void *addr,
 870                                 uint32_t tiling_mode,
 871                                 uint32_t stride,
 872                                 unsigned long size,
 873                                 unsigned long flags)
 874 {
 875         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
 876         drm_intel_bo_gem *bo_gem;
 877         int ret;
 878         struct drm_i915_gem_userptr userptr;
 879
 880         /* Tiling with userptr surfaces is not supported
 881          * on all hardware so refuse it for time being.
 882          */
 883         if (tiling_mode != I915_TILING_NONE)
 884                 return NULL;
 885
 886         bo_gem = calloc(1, sizeof(*bo_gem));
 887         if (!bo_gem)
 888                 return NULL;
 889
 890         bo_gem->bo.size = size;
 891
 892         memclear(userptr);
 893         userptr.user_ptr = (__u64)((unsigned long)addr);
 894         userptr.user_size = size;
 895         userptr.flags = flags;
 896
 897         ret = drmIoctl(bufmgr_gem->fd,
 898                         DRM_IOCTL_I915_GEM_USERPTR,
 899                         &userptr);
 900         if (ret != 0) {
 901                 DBG("bo_create_userptr: "
 902                     "ioctl failed with user ptr %p size 0x%lx, "
 903                     "user flags 0x%lx\n", addr, size, flags);
 904                 free(bo_gem);
 905                 return NULL;
 906         }
 907
 908         bo_gem->gem_handle = userptr.handle;
 909         bo_gem->bo.handle = bo_gem->gem_handle;
 910         bo_gem->bo.bufmgr    = bufmgr;
 911         bo_gem->is_userptr   = true;
 912         bo_gem->bo.virtual   = addr;
 913         /* Save the address provided by user */
 914         bo_gem->user_virtual = addr;
 915         bo_gem->tiling_mode  = I915_TILING_NONE;
 916         bo_gem->swizzle_mode = I915_BIT_6_SWIZZLE_NONE;
 917         bo_gem->stride       = 0;
 918
 919         DRMINITLISTHEAD(&bo_gem->name_list);
 920         DRMINITLISTHEAD(&bo_gem->vma_list);
 921
 922         bo_gem->name = name;
 923         atomic_set(&bo_gem->refcount, 1);
 924         bo_gem->validate_index = -1;
 925         bo_gem->reloc_tree_fences = 0;
 926         bo_gem->used_as_reloc_target = false;
 927         bo_gem->has_error = false;
 928         bo_gem->reusable = false;
 929
 930         drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem, 0);
 931
 932         DBG("bo_create_userptr: "
 933             "ptr %p buf %d (%s) size %ldb, stride 0x%x, tile mode %d\n",
 934                 addr, bo_gem->gem_handle, bo_gem->name,
 935                 size, stride, tiling_mode);
 936
 937         return &bo_gem->bo;
 938 }
 939
 940 static bool
 941 has_userptr(drm_intel_bufmgr_gem *bufmgr_gem)
 942 {
 943         int ret;
 944         void *ptr;
 945         long pgsz;
 946         struct drm_i915_gem_userptr userptr;
 947
 948         pgsz = sysconf(_SC_PAGESIZE);
 949         assert(pgsz > 0);
 950
 951         ret = posix_memalign(&ptr, pgsz, pgsz);
 952         if (ret) {
 953                 DBG("Failed to get a page (%ld) for userptr detection!\n",
 954                         pgsz);
 955                 return false;
 956         }
 957
 958         memclear(userptr);
 959         userptr.user_ptr = (__u64)(unsigned long)ptr;
 960         userptr.user_size = pgsz;
 961
 962 retry:
 963         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_USERPTR, &userptr);
 964         if (ret) {
 965                 if (errno == ENODEV && userptr.flags == 0) {
 966                         userptr.flags = I915_USERPTR_UNSYNCHRONIZED;
 967                         goto retry;
 968                 }
 969                 free(ptr);
 970                 return false;
 971         }
 972
 973         /* We don't release the userptr bo here as we want to keep the
 974          * kernel mm tracking alive for our lifetime. The first time we
 975          * create a userptr object the kernel has to install a mmu_notifer
 976          * which is a heavyweight operation (e.g. it requires taking all
 977          * mm_locks and stop_machine()).
 978          */
 979
 980         bufmgr_gem->userptr_active.ptr = ptr;
 981         bufmgr_gem->userptr_active.handle = userptr.handle;
 982
 983         return true;
 984 }
 985
 986 static drm_intel_bo *
 987 check_bo_alloc_userptr(drm_intel_bufmgr *bufmgr,
 988                        const char *name,
 989                        void *addr,
 990                        uint32_t tiling_mode,
 991                        uint32_t stride,
 992                        unsigned long size,
 993                        unsigned long flags)
 994 {
 995         if (has_userptr((drm_intel_bufmgr_gem *)bufmgr))
 996                 bufmgr->bo_alloc_userptr = drm_intel_gem_bo_alloc_userptr;
 997         else
 998                 bufmgr->bo_alloc_userptr = NULL;
 999
1000         return drm_intel_bo_alloc_userptr(bufmgr, name, addr,
1001                                           tiling_mode, stride, size, flags);
1002 }
1003
1004 /**
1005  * Returns a drm_intel_bo wrapping the given buffer object handle.
1006  *
1007  * This can be used when one application needs to pass a buffer object
1008  * to another.
1009  */
1010 drm_intel_bo *
1011 drm_intel_bo_gem_create_from_name(drm_intel_bufmgr *bufmgr,
1012                                   const char *name,
1013                                   unsigned int handle)
1014 {
1015         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
1016         drm_intel_bo_gem *bo_gem;
1017         int ret;
1018         struct drm_gem_open open_arg;
1019         struct drm_i915_gem_get_tiling get_tiling;
1020         drmMMListHead *list;
1021
1022         /* At the moment most applications only have a few named bo.
1023          * For instance, in a DRI client only the render buffers passed
1024          * between X and the client are named. And since X returns the
1025          * alternating names for the front/back buffer a linear search
1026          * provides a sufficiently fast match.
1027          */
1028         pthread_mutex_lock(&bufmgr_gem->lock);
1029         for (list = bufmgr_gem->named.next;
1030              list != &bufmgr_gem->named;
1031              list = list->next) {
1032                 bo_gem = DRMLISTENTRY(drm_intel_bo_gem, list, name_list);
1033                 if (bo_gem->global_name == handle) {
1034                         drm_intel_gem_bo_reference(&bo_gem->bo);
1035                         pthread_mutex_unlock(&bufmgr_gem->lock);
1036                         return &bo_gem->bo;
1037                 }
1038         }
1039
1040         memclear(open_arg);
1041         open_arg.name = handle;
1042         ret = drmIoctl(bufmgr_gem->fd,
1043                        DRM_IOCTL_GEM_OPEN,
1044                        &open_arg);
1045         if (ret != 0) {
1046                 DBG("Couldn't reference %s handle 0x%08x: %s\n",
1047                     name, handle, strerror(errno));
1048                 pthread_mutex_unlock(&bufmgr_gem->lock);
1049                 return NULL;
1050         }
1051         /* Now see if someone has used a prime handle to get this
1052          * object from the kernel before by looking through the list
1053          * again for a matching gem_handle
1054          */
1055         for (list = bufmgr_gem->named.next;
1056              list != &bufmgr_gem->named;
1057              list = list->next) {
1058                 bo_gem = DRMLISTENTRY(drm_intel_bo_gem, list, name_list);
1059                 if (bo_gem->gem_handle == open_arg.handle) {
1060                         drm_intel_gem_bo_reference(&bo_gem->bo);
1061                         pthread_mutex_unlock(&bufmgr_gem->lock);
1062                         return &bo_gem->bo;
1063                 }
1064         }
1065
1066         bo_gem = calloc(1, sizeof(*bo_gem));
1067         if (!bo_gem) {
1068                 pthread_mutex_unlock(&bufmgr_gem->lock);
1069                 return NULL;
1070         }
1071
1072         bo_gem->bo.size = open_arg.size;
1073         bo_gem->bo.offset = 0;
1074         bo_gem->bo.offset64 = 0;
1075         bo_gem->bo.virtual = NULL;
1076         bo_gem->bo.bufmgr = bufmgr;
1077         bo_gem->name = name;
1078         atomic_set(&bo_gem->refcount, 1);
1079         bo_gem->validate_index = -1;
1080         bo_gem->gem_handle = open_arg.handle;
1081         bo_gem->bo.handle = open_arg.handle;
1082         bo_gem->global_name = handle;
1083         bo_gem->reusable = false;
1084
1085         memclear(get_tiling);
1086         get_tiling.handle = bo_gem->gem_handle;
1087         ret = drmIoctl(bufmgr_gem->fd,
1088                        DRM_IOCTL_I915_GEM_GET_TILING,
1089                        &get_tiling);
1090         if (ret != 0) {
1091                 drm_intel_gem_bo_unreference(&bo_gem->bo);
1092                 pthread_mutex_unlock(&bufmgr_gem->lock);
1093                 return NULL;
1094         }
1095         bo_gem->tiling_mode = get_tiling.tiling_mode;
1096         bo_gem->swizzle_mode = get_tiling.swizzle_mode;
1097         /* XXX stride is unknown */
1098         drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem, 0);
1099
1100         DRMINITLISTHEAD(&bo_gem->vma_list);
1101         DRMLISTADDTAIL(&bo_gem->name_list, &bufmgr_gem->named);
1102         pthread_mutex_unlock(&bufmgr_gem->lock);
1103         DBG("bo_create_from_handle: %d (%s)\n", handle, bo_gem->name);
1104
1105         return &bo_gem->bo;
1106 }
1107
1108 static void
1109 drm_intel_gem_bo_free(drm_intel_bo *bo)
1110 {
1111         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1112         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1113         struct drm_gem_close close;
1114         int ret;
1115
1116         DRMLISTDEL(&bo_gem->vma_list);
1117         if (bo_gem->mem_virtual) {
1118                 VG(VALGRIND_FREELIKE_BLOCK(bo_gem->mem_virtual, 0));
1119                 drm_munmap(bo_gem->mem_virtual, bo_gem->bo.size);
1120                 bufmgr_gem->vma_count--;
1121         }
1122         if (bo_gem->gtt_virtual) {
1123                 drm_munmap(bo_gem->gtt_virtual, bo_gem->bo.size);
1124                 bufmgr_gem->vma_count--;
1125         }
1126
1127         /* Close this object */
1128         memclear(close);
1129         close.handle = bo_gem->gem_handle;
1130         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_GEM_CLOSE, &close);
1131         if (ret != 0) {
1132                 DBG("DRM_IOCTL_GEM_CLOSE %d failed (%s): %s\n",
1133                     bo_gem->gem_handle, bo_gem->name, strerror(errno));
1134         }
1135         free(bo);
1136 }
1137
1138 static void
1139 drm_intel_gem_bo_mark_mmaps_incoherent(drm_intel_bo *bo)
1140 {
1141 #if HAVE_VALGRIND
1142         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1143
1144         if (bo_gem->mem_virtual)
1145                 VALGRIND_MAKE_MEM_NOACCESS(bo_gem->mem_virtual, bo->size);
1146
1147         if (bo_gem->gtt_virtual)
1148                 VALGRIND_MAKE_MEM_NOACCESS(bo_gem->gtt_virtual, bo->size);
1149 #endif
1150 }
1151
1152 /** Frees all cached buffers significantly older than @time. */
1153 static void
1154 drm_intel_gem_cleanup_bo_cache(drm_intel_bufmgr_gem *bufmgr_gem, time_t time)
1155 {
1156         int i;
1157
1158         if (bufmgr_gem->time == time)
1159                 return;
1160
1161         for (i = 0; i < bufmgr_gem->num_buckets; i++) {
1162                 struct drm_intel_gem_bo_bucket *bucket =
1163                     &bufmgr_gem->cache_bucket[i];
1164
1165                 while (!DRMLISTEMPTY(&bucket->head)) {
1166                         drm_intel_bo_gem *bo_gem;
1167
1168                         bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
1169                                               bucket->head.next, head);
1170                         if (time - bo_gem->free_time <= 1)
1171                                 break;
1172
1173                         DRMLISTDEL(&bo_gem->head);
1174
1175                         drm_intel_gem_bo_free(&bo_gem->bo);
1176                 }
1177         }
1178
1179         bufmgr_gem->time = time;
1180 }
1181
1182 static void drm_intel_gem_bo_purge_vma_cache(drm_intel_bufmgr_gem *bufmgr_gem)
1183 {
1184         int limit;
1185
1186         DBG("%s: cached=%d, open=%d, limit=%d\n", __FUNCTION__,
1187             bufmgr_gem->vma_count, bufmgr_gem->vma_open, bufmgr_gem->vma_max);
1188
1189         if (bufmgr_gem->vma_max < 0)
1190                 return;
1191
1192         /* We may need to evict a few entries in order to create new mmaps */
1193         limit = bufmgr_gem->vma_max - 2*bufmgr_gem->vma_open;
1194         if (limit < 0)
1195                 limit = 0;
1196
1197         while (bufmgr_gem->vma_count > limit) {
1198                 drm_intel_bo_gem *bo_gem;
1199
1200                 bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
1201                                       bufmgr_gem->vma_cache.next,
1202                                       vma_list);
1203                 assert(bo_gem->map_count == 0);
1204                 DRMLISTDELINIT(&bo_gem->vma_list);
1205
1206                 if (bo_gem->mem_virtual) {
1207                         drm_munmap(bo_gem->mem_virtual, bo_gem->bo.size);
1208                         bo_gem->mem_virtual = NULL;
1209                         bufmgr_gem->vma_count--;
1210                 }
1211                 if (bo_gem->gtt_virtual) {
1212                         drm_munmap(bo_gem->gtt_virtual, bo_gem->bo.size);
1213                         bo_gem->gtt_virtual = NULL;
1214                         bufmgr_gem->vma_count--;
1215                 }
1216         }
1217 }
1218
1219 static void drm_intel_gem_bo_close_vma(drm_intel_bufmgr_gem *bufmgr_gem,
1220                                        drm_intel_bo_gem *bo_gem)
1221 {
1222         bufmgr_gem->vma_open--;
1223         DRMLISTADDTAIL(&bo_gem->vma_list, &bufmgr_gem->vma_cache);
1224         if (bo_gem->mem_virtual)
1225                 bufmgr_gem->vma_count++;
1226         if (bo_gem->gtt_virtual)
1227                 bufmgr_gem->vma_count++;
1228         drm_intel_gem_bo_purge_vma_cache(bufmgr_gem);
1229 }
1230
1231 static void drm_intel_gem_bo_open_vma(drm_intel_bufmgr_gem *bufmgr_gem,
1232                                       drm_intel_bo_gem *bo_gem)
1233 {
1234         bufmgr_gem->vma_open++;
1235         DRMLISTDEL(&bo_gem->vma_list);
1236         if (bo_gem->mem_virtual)
1237                 bufmgr_gem->vma_count--;
1238         if (bo_gem->gtt_virtual)
1239                 bufmgr_gem->vma_count--;
1240         drm_intel_gem_bo_purge_vma_cache(bufmgr_gem);
1241 }
1242
1243 static void
1244 drm_intel_gem_bo_unreference_final(drm_intel_bo *bo, time_t time)
1245 {
1246         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1247         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1248         struct drm_intel_gem_bo_bucket *bucket;
1249         int i;
1250
1251         /* Unreference all the target buffers */
1252         for (i = 0; i < bo_gem->reloc_count; i++) {
1253                 if (bo_gem->reloc_target_info[i].bo != bo) {
1254                         drm_intel_gem_bo_unreference_locked_timed(bo_gem->
1255                                                                   reloc_target_info[i].bo,
1256                                                                   time);
1257                 }
1258         }
1259         bo_gem->reloc_count = 0;
1260         bo_gem->used_as_reloc_target = false;
1261
1262         DBG("bo_unreference final: %d (%s)\n",
1263             bo_gem->gem_handle, bo_gem->name);
1264
1265         /* release memory associated with this object */
1266         if (bo_gem->reloc_target_info) {
1267                 free(bo_gem->reloc_target_info);
1268                 bo_gem->reloc_target_info = NULL;
1269         }
1270         if (bo_gem->relocs) {
1271                 free(bo_gem->relocs);
1272                 bo_gem->relocs = NULL;
1273         }
1274
1275         /* Clear any left-over mappings */
1276         if (bo_gem->map_count) {
1277                 DBG("bo freed with non-zero map-count %d\n", bo_gem->map_count);
1278                 bo_gem->map_count = 0;
1279                 drm_intel_gem_bo_close_vma(bufmgr_gem, bo_gem);
1280                 drm_intel_gem_bo_mark_mmaps_incoherent(bo);
1281         }
1282
1283         DRMLISTDEL(&bo_gem->name_list);
1284
1285         bucket = drm_intel_gem_bo_bucket_for_size(bufmgr_gem, bo->size);
1286         /* Put the buffer into our internal cache for reuse if we can. */
1287         if (bufmgr_gem->bo_reuse && bo_gem->reusable && bucket != NULL &&
1288             drm_intel_gem_bo_madvise_internal(bufmgr_gem, bo_gem,
1289                                               I915_MADV_DONTNEED)) {
1290                 bo_gem->free_time = time;
1291
1292                 bo_gem->name = NULL;
1293                 bo_gem->validate_index = -1;
1294
1295                 DRMLISTADDTAIL(&bo_gem->head, &bucket->head);
1296         } else {
1297                 drm_intel_gem_bo_free(bo);
1298         }
1299 }
1300
1301 static void drm_intel_gem_bo_unreference_locked_timed(drm_intel_bo *bo,
1302                                                       time_t time)
1303 {
1304         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1305
1306         assert(atomic_read(&bo_gem->refcount) > 0);
1307         if (atomic_dec_and_test(&bo_gem->refcount))
1308                 drm_intel_gem_bo_unreference_final(bo, time);
1309 }
1310
1311 static void drm_intel_gem_bo_unreference(drm_intel_bo *bo)
1312 {
1313         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1314
1315         assert(atomic_read(&bo_gem->refcount) > 0);
1316
1317         if (atomic_add_unless(&bo_gem->refcount, -1, 1)) {
1318                 drm_intel_bufmgr_gem *bufmgr_gem =
1319                     (drm_intel_bufmgr_gem *) bo->bufmgr;
1320                 struct timespec time;
1321
1322                 clock_gettime(CLOCK_MONOTONIC, &time);
1323
1324                 pthread_mutex_lock(&bufmgr_gem->lock);
1325
1326                 if (atomic_dec_and_test(&bo_gem->refcount)) {
1327                         drm_intel_gem_bo_unreference_final(bo, time.tv_sec);
1328                         drm_intel_gem_cleanup_bo_cache(bufmgr_gem, time.tv_sec);
1329                 }
1330
1331                 pthread_mutex_unlock(&bufmgr_gem->lock);
1332         }
1333 }
1334
1335 static int drm_intel_gem_bo_map(drm_intel_bo *bo, int write_enable)
1336 {
1337         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1338         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1339         struct drm_i915_gem_set_domain set_domain;
1340         int ret;
1341
1342         if (bo_gem->is_userptr) {
1343                 /* Return the same user ptr */
1344                 bo->virtual = bo_gem->user_virtual;
1345                 return 0;
1346         }
1347
1348         pthread_mutex_lock(&bufmgr_gem->lock);
1349
1350         if (bo_gem->map_count++ == 0)
1351                 drm_intel_gem_bo_open_vma(bufmgr_gem, bo_gem);
1352
1353         if (!bo_gem->mem_virtual) {
1354                 struct drm_i915_gem_mmap mmap_arg;
1355
1356                 DBG("bo_map: %d (%s), map_count=%d\n",
1357                     bo_gem->gem_handle, bo_gem->name, bo_gem->map_count);
1358
1359                 memclear(mmap_arg);
1360                 mmap_arg.handle = bo_gem->gem_handle;
1361                 mmap_arg.size = bo->size;
1362                 ret = drmIoctl(bufmgr_gem->fd,
1363                                DRM_IOCTL_I915_GEM_MMAP,
1364                                &mmap_arg);
1365                 if (ret != 0) {
1366                         ret = -errno;
1367                         DBG("%s:%d: Error mapping buffer %d (%s): %s .\n",
1368                             __FILE__, __LINE__, bo_gem->gem_handle,
1369                             bo_gem->name, strerror(errno));
1370                         if (--bo_gem->map_count == 0)
1371                                 drm_intel_gem_bo_close_vma(bufmgr_gem, bo_gem);
1372                         pthread_mutex_unlock(&bufmgr_gem->lock);
1373                         return ret;
1374                 }
1375                 VG(VALGRIND_MALLOCLIKE_BLOCK(mmap_arg.addr_ptr, mmap_arg.size, 0, 1));
1376                 bo_gem->mem_virtual = (void *)(uintptr_t) mmap_arg.addr_ptr;
1377         }
1378         DBG("bo_map: %d (%s) -> %p\n", bo_gem->gem_handle, bo_gem->name,
1379             bo_gem->mem_virtual);
1380         bo->virtual = bo_gem->mem_virtual;
1381
1382         memclear(set_domain);
1383         set_domain.handle = bo_gem->gem_handle;
1384         set_domain.read_domains = I915_GEM_DOMAIN_CPU;
1385         if (write_enable)
1386                 set_domain.write_domain = I915_GEM_DOMAIN_CPU;
1387         else
1388                 set_domain.write_domain = 0;
1389         ret = drmIoctl(bufmgr_gem->fd,
1390                        DRM_IOCTL_I915_GEM_SET_DOMAIN,
1391                        &set_domain);
1392         if (ret != 0) {
1393                 DBG("%s:%d: Error setting to CPU domain %d: %s\n",
1394                     __FILE__, __LINE__, bo_gem->gem_handle,
1395                     strerror(errno));
1396         }
1397
1398         if (write_enable)
1399                 bo_gem->mapped_cpu_write = true;
1400
1401         drm_intel_gem_bo_mark_mmaps_incoherent(bo);
1402         VG(VALGRIND_MAKE_MEM_DEFINED(bo_gem->mem_virtual, bo->size));
1403         pthread_mutex_unlock(&bufmgr_gem->lock);
1404
1405         return 0;
1406 }
1407
1408 static int
1409 map_gtt(drm_intel_bo *bo)
1410 {
1411         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1412         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1413         int ret;
1414
1415         if (bo_gem->is_userptr)
1416                 return -EINVAL;
1417
1418         if (bo_gem->map_count++ == 0)
1419                 drm_intel_gem_bo_open_vma(bufmgr_gem, bo_gem);
1420
1421         /* Get a mapping of the buffer if we haven't before. */
1422         if (bo_gem->gtt_virtual == NULL) {
1423                 struct drm_i915_gem_mmap_gtt mmap_arg;
1424
1425                 DBG("bo_map_gtt: mmap %d (%s), map_count=%d\n",
1426                     bo_gem->gem_handle, bo_gem->name, bo_gem->map_count);
1427
1428                 memclear(mmap_arg);
1429                 mmap_arg.handle = bo_gem->gem_handle;
1430
1431                 /* Get the fake offset back... */
1432                 ret = drmIoctl(bufmgr_gem->fd,
1433                                DRM_IOCTL_I915_GEM_MMAP_GTT,
1434                                &mmap_arg);
1435                 if (ret != 0) {
1436                         ret = -errno;
1437                         DBG("%s:%d: Error preparing buffer map %d (%s): %s .\n",
1438                             __FILE__, __LINE__,
1439                             bo_gem->gem_handle, bo_gem->name,
1440                             strerror(errno));
1441                         if (--bo_gem->map_count == 0)
1442                                 drm_intel_gem_bo_close_vma(bufmgr_gem, bo_gem);
1443                         return ret;
1444                 }
1445
1446                 /* and mmap it */
1447                 bo_gem->gtt_virtual = drm_mmap(0, bo->size, PROT_READ | PROT_WRITE,
1448                                                MAP_SHARED, bufmgr_gem->fd,
1449                                                mmap_arg.offset);
1450                 if (bo_gem->gtt_virtual == MAP_FAILED) {
1451                         bo_gem->gtt_virtual = NULL;
1452                         ret = -errno;
1453                         DBG("%s:%d: Error mapping buffer %d (%s): %s .\n",
1454                             __FILE__, __LINE__,
1455                             bo_gem->gem_handle, bo_gem->name,
1456                             strerror(errno));
1457                         if (--bo_gem->map_count == 0)
1458                                 drm_intel_gem_bo_close_vma(bufmgr_gem, bo_gem);
1459                         return ret;
1460                 }
1461         }
1462
1463         bo->virtual = bo_gem->gtt_virtual;
1464
1465         DBG("bo_map_gtt: %d (%s) -> %p\n", bo_gem->gem_handle, bo_gem->name,
1466             bo_gem->gtt_virtual);
1467
1468         return 0;
1469 }
1470
1471 int
1472 drm_intel_gem_bo_map_gtt(drm_intel_bo *bo)
1473 {
1474         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1475         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1476         struct drm_i915_gem_set_domain set_domain;
1477         int ret;
1478
1479         pthread_mutex_lock(&bufmgr_gem->lock);
1480
1481         ret = map_gtt(bo);
1482         if (ret) {
1483                 pthread_mutex_unlock(&bufmgr_gem->lock);
1484                 return ret;
1485         }
1486
1487         /* Now move it to the GTT domain so that the GPU and CPU
1488          * caches are flushed and the GPU isn't actively using the
1489          * buffer.
1490          *
1491          * The pagefault handler does this domain change for us when
1492          * it has unbound the BO from the GTT, but it's up to us to
1493          * tell it when we're about to use things if we had done
1494          * rendering and it still happens to be bound to the GTT.
1495          */
1496         memclear(set_domain);
1497         set_domain.handle = bo_gem->gem_handle;
1498         set_domain.read_domains = I915_GEM_DOMAIN_GTT;
1499         set_domain.write_domain = I915_GEM_DOMAIN_GTT;
1500         ret = drmIoctl(bufmgr_gem->fd,
1501                        DRM_IOCTL_I915_GEM_SET_DOMAIN,
1502                        &set_domain);
1503         if (ret != 0) {
1504                 DBG("%s:%d: Error setting domain %d: %s\n",
1505                     __FILE__, __LINE__, bo_gem->gem_handle,
1506                     strerror(errno));
1507         }
1508
1509         drm_intel_gem_bo_mark_mmaps_incoherent(bo);
1510         VG(VALGRIND_MAKE_MEM_DEFINED(bo_gem->gtt_virtual, bo->size));
1511         pthread_mutex_unlock(&bufmgr_gem->lock);
1512
1513         return 0;
1514 }
1515
1516 /**
1517  * Performs a mapping of the buffer object like the normal GTT
1518  * mapping, but avoids waiting for the GPU to be done reading from or
1519  * rendering to the buffer.
1520  *
1521  * This is used in the implementation of GL_ARB_map_buffer_range: The
1522  * user asks to create a buffer, then does a mapping, fills some
1523  * space, runs a drawing command, then asks to map it again without
1524  * synchronizing because it guarantees that it won't write over the
1525  * data that the GPU is busy using (or, more specifically, that if it
1526  * does write over the data, it acknowledges that rendering is
1527  * undefined).
1528  */
1529
1530 int
1531 drm_intel_gem_bo_map_unsynchronized(drm_intel_bo *bo)
1532 {
1533         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1534 #ifdef HAVE_VALGRIND
1535         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1536 #endif
1537         int ret;
1538
1539         /* If the CPU cache isn't coherent with the GTT, then use a
1540          * regular synchronized mapping.  The problem is that we don't
1541          * track where the buffer was last used on the CPU side in
1542          * terms of drm_intel_bo_map vs drm_intel_gem_bo_map_gtt, so
1543          * we would potentially corrupt the buffer even when the user
1544          * does reasonable things.
1545          */
1546         if (!bufmgr_gem->has_llc)
1547                 return drm_intel_gem_bo_map_gtt(bo);
1548
1549         pthread_mutex_lock(&bufmgr_gem->lock);
1550
1551         ret = map_gtt(bo);
1552         if (ret == 0) {
1553                 drm_intel_gem_bo_mark_mmaps_incoherent(bo);
1554                 VG(VALGRIND_MAKE_MEM_DEFINED(bo_gem->gtt_virtual, bo->size));
1555         }
1556
1557         pthread_mutex_unlock(&bufmgr_gem->lock);
1558
1559         return ret;
1560 }
1561
1562 static int drm_intel_gem_bo_unmap(drm_intel_bo *bo)
1563 {
1564         drm_intel_bufmgr_gem *bufmgr_gem;
1565         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1566         int ret = 0;
1567
1568         if (bo == NULL)
1569                 return 0;
1570
1571         if (bo_gem->is_userptr)
1572                 return 0;
1573
1574         bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1575
1576         pthread_mutex_lock(&bufmgr_gem->lock);
1577
1578         if (bo_gem->map_count <= 0) {
1579                 DBG("attempted to unmap an unmapped bo\n");
1580                 pthread_mutex_unlock(&bufmgr_gem->lock);
1581                 /* Preserve the old behaviour of just treating this as a
1582                  * no-op rather than reporting the error.
1583                  */
1584                 return 0;
1585         }
1586
1587         if (bo_gem->mapped_cpu_write) {
1588                 struct drm_i915_gem_sw_finish sw_finish;
1589
1590                 /* Cause a flush to happen if the buffer's pinned for
1591                  * scanout, so the results show up in a timely manner.
1592                  * Unlike GTT set domains, this only does work if the
1593                  * buffer should be scanout-related.
1594                  */
1595                 memclear(sw_finish);
1596                 sw_finish.handle = bo_gem->gem_handle;
1597                 ret = drmIoctl(bufmgr_gem->fd,
1598                                DRM_IOCTL_I915_GEM_SW_FINISH,
1599                                &sw_finish);
1600                 ret = ret == -1 ? -errno : 0;
1601
1602                 bo_gem->mapped_cpu_write = false;
1603         }
1604
1605         /* We need to unmap after every innovation as we cannot track
1606          * an open vma for every bo as that will exhaasut the system
1607          * limits and cause later failures.
1608          */
1609         if (--bo_gem->map_count == 0) {
1610                 drm_intel_gem_bo_close_vma(bufmgr_gem, bo_gem);
1611                 drm_intel_gem_bo_mark_mmaps_incoherent(bo);
1612                 bo->virtual = NULL;
1613         }
1614         pthread_mutex_unlock(&bufmgr_gem->lock);
1615
1616         return ret;
1617 }
1618
1619 int
1620 drm_intel_gem_bo_unmap_gtt(drm_intel_bo *bo)
1621 {
1622         return drm_intel_gem_bo_unmap(bo);
1623 }
1624
1625 static int
1626 drm_intel_gem_bo_subdata(drm_intel_bo *bo, unsigned long offset,
1627                          unsigned long size, const void *data)
1628 {
1629         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1630         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1631         struct drm_i915_gem_pwrite pwrite;
1632         int ret;
1633
1634         if (bo_gem->is_userptr)
1635                 return -EINVAL;
1636
1637         memclear(pwrite);
1638         pwrite.handle = bo_gem->gem_handle;
1639         pwrite.offset = offset;
1640         pwrite.size = size;
1641         pwrite.data_ptr = (uint64_t) (uintptr_t) data;
1642         ret = drmIoctl(bufmgr_gem->fd,
1643                        DRM_IOCTL_I915_GEM_PWRITE,
1644                        &pwrite);
1645         if (ret != 0) {
1646                 ret = -errno;
1647                 DBG("%s:%d: Error writing data to buffer %d: (%d %d) %s .\n",
1648                     __FILE__, __LINE__, bo_gem->gem_handle, (int)offset,
1649                     (int)size, strerror(errno));
1650         }
1651
1652         return ret;
1653 }
1654
1655 static int
1656 drm_intel_gem_get_pipe_from_crtc_id(drm_intel_bufmgr *bufmgr, int crtc_id)
1657 {
1658         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
1659         struct drm_i915_get_pipe_from_crtc_id get_pipe_from_crtc_id;
1660         int ret;
1661
1662         memclear(get_pipe_from_crtc_id);
1663         get_pipe_from_crtc_id.crtc_id = crtc_id;
1664         ret = drmIoctl(bufmgr_gem->fd,
1665                        DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID,
1666                        &get_pipe_from_crtc_id);
1667         if (ret != 0) {
1668                 /* We return -1 here to signal that we don't
1669                  * know which pipe is associated with this crtc.
1670                  * This lets the caller know that this information
1671                  * isn't available; using the wrong pipe for
1672                  * vblank waiting can cause the chipset to lock up
1673                  */
1674                 return -1;
1675         }
1676
1677         return get_pipe_from_crtc_id.pipe;
1678 }
1679
1680 static int
1681 drm_intel_gem_bo_get_subdata(drm_intel_bo *bo, unsigned long offset,
1682                              unsigned long size, void *data)
1683 {
1684         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1685         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1686         struct drm_i915_gem_pread pread;
1687         int ret;
1688
1689         if (bo_gem->is_userptr)
1690                 return -EINVAL;
1691
1692         memclear(pread);
1693         pread.handle = bo_gem->gem_handle;
1694         pread.offset = offset;
1695         pread.size = size;
1696         pread.data_ptr = (uint64_t) (uintptr_t) data;
1697         ret = drmIoctl(bufmgr_gem->fd,
1698                        DRM_IOCTL_I915_GEM_PREAD,
1699                        &pread);
1700         if (ret != 0) {
1701                 ret = -errno;
1702                 DBG("%s:%d: Error reading data from buffer %d: (%d %d) %s .\n",
1703                     __FILE__, __LINE__, bo_gem->gem_handle, (int)offset,
1704                     (int)size, strerror(errno));
1705         }
1706
1707         return ret;
1708 }
1709
1710 /** Waits for all GPU rendering with the object to have completed. */
1711 static void
1712 drm_intel_gem_bo_wait_rendering(drm_intel_bo *bo)
1713 {
1714         drm_intel_gem_bo_start_gtt_access(bo, 1);
1715 }
1716
1717 /**
1718  * Waits on a BO for the given amount of time.
1719  *
1720  * @bo: buffer object to wait for
1721  * @timeout_ns: amount of time to wait in nanoseconds.
1722  *   If value is less than 0, an infinite wait will occur.
1723  *
1724  * Returns 0 if the wait was successful ie. the last batch referencing the
1725  * object has completed within the allotted time. Otherwise some negative return
1726  * value describes the error. Of particular interest is -ETIME when the wait has
1727  * failed to yield the desired result.
1728  *
1729  * Similar to drm_intel_gem_bo_wait_rendering except a timeout parameter allows
1730  * the operation to give up after a certain amount of time. Another subtle
1731  * difference is the internal locking semantics are different (this variant does
1732  * not hold the lock for the duration of the wait). This makes the wait subject
1733  * to a larger userspace race window.
1734  *
1735  * The implementation shall wait until the object is no longer actively
1736  * referenced within a batch buffer at the time of the call. The wait will
1737  * not guarantee that the buffer is re-issued via another thread, or an flinked
1738  * handle. Userspace must make sure this race does not occur if such precision
1739  * is important.
1740  *
1741  * Note that some kernels have broken the inifite wait for negative values
1742  * promise, upgrade to latest stable kernels if this is the case.
1743  */
1744 int
1745 drm_intel_gem_bo_wait(drm_intel_bo *bo, int64_t timeout_ns)
1746 {
1747         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1748         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1749         struct drm_i915_gem_wait wait;
1750         int ret;
1751
1752         if (!bufmgr_gem->has_wait_timeout) {
1753                 DBG("%s:%d: Timed wait is not supported. Falling back to "
1754                     "infinite wait\n", __FILE__, __LINE__);
1755                 if (timeout_ns) {
1756                         drm_intel_gem_bo_wait_rendering(bo);
1757                         return 0;
1758                 } else {
1759                         return drm_intel_gem_bo_busy(bo) ? -ETIME : 0;
1760                 }
1761         }
1762
1763         memclear(wait);
1764         wait.bo_handle = bo_gem->gem_handle;
1765         wait.timeout_ns = timeout_ns;
1766         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_WAIT, &wait);
1767         if (ret == -1)
1768                 return -errno;
1769
1770         return ret;
1771 }
1772
1773 /**
1774  * Sets the object to the GTT read and possibly write domain, used by the X
1775  * 2D driver in the absence of kernel support to do drm_intel_gem_bo_map_gtt().
1776  *
1777  * In combination with drm_intel_gem_bo_pin() and manual fence management, we
1778  * can do tiled pixmaps this way.
1779  */
1780 void
1781 drm_intel_gem_bo_start_gtt_access(drm_intel_bo *bo, int write_enable)
1782 {
1783         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1784         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1785         struct drm_i915_gem_set_domain set_domain;
1786         int ret;
1787
1788         memclear(set_domain);
1789         set_domain.handle = bo_gem->gem_handle;
1790         set_domain.read_domains = I915_GEM_DOMAIN_GTT;
1791         set_domain.write_domain = write_enable ? I915_GEM_DOMAIN_GTT : 0;
1792         ret = drmIoctl(bufmgr_gem->fd,
1793                        DRM_IOCTL_I915_GEM_SET_DOMAIN,
1794                        &set_domain);
1795         if (ret != 0) {
1796                 DBG("%s:%d: Error setting memory domains %d (%08x %08x): %s .\n",
1797                     __FILE__, __LINE__, bo_gem->gem_handle,
1798                     set_domain.read_domains, set_domain.write_domain,
1799                     strerror(errno));
1800         }
1801 }
1802
1803 static void
1804 drm_intel_bufmgr_gem_destroy(drm_intel_bufmgr *bufmgr)
1805 {
1806         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
1807         struct drm_gem_close close_bo;
1808         int i, ret;
1809
1810         free(bufmgr_gem->exec2_objects);
1811         free(bufmgr_gem->exec_objects);
1812         free(bufmgr_gem->exec_bos);
1813
1814         pthread_mutex_destroy(&bufmgr_gem->lock);
1815
1816         /* Free any cached buffer objects we were going to reuse */
1817         for (i = 0; i < bufmgr_gem->num_buckets; i++) {
1818                 struct drm_intel_gem_bo_bucket *bucket =
1819                     &bufmgr_gem->cache_bucket[i];
1820                 drm_intel_bo_gem *bo_gem;
1821
1822                 while (!DRMLISTEMPTY(&bucket->head)) {
1823                         bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
1824                                               bucket->head.next, head);
1825                         DRMLISTDEL(&bo_gem->head);
1826
1827                         drm_intel_gem_bo_free(&bo_gem->bo);
1828                 }
1829         }
1830
1831         /* Release userptr bo kept hanging around for optimisation. */
1832         if (bufmgr_gem->userptr_active.ptr) {
1833                 memclear(close_bo);
1834                 close_bo.handle = bufmgr_gem->userptr_active.handle;
1835                 ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_GEM_CLOSE, &close_bo);
1836                 free(bufmgr_gem->userptr_active.ptr);
1837                 if (ret)
1838                         fprintf(stderr,
1839                                 "Failed to release test userptr object! (%d) "
1840                                 "i915 kernel driver may not be sane!\n", errno);
1841         }
1842
1843         free(bufmgr);
1844 }
1845
1846 /**
1847  * Adds the target buffer to the validation list and adds the relocation
1848  * to the reloc_buffer's relocation list.
1849  *
1850  * The relocation entry at the given offset must already contain the
1851  * precomputed relocation value, because the kernel will optimize out
1852  * the relocation entry write when the buffer hasn't moved from the
1853  * last known offset in target_bo.
1854  */
1855 static int
1856 do_bo_emit_reloc(drm_intel_bo *bo, uint32_t offset,
1857                  drm_intel_bo *target_bo, uint32_t target_offset,
1858                  uint32_t read_domains, uint32_t write_domain,
1859                  bool need_fence)
1860 {
1861         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1862         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1863         drm_intel_bo_gem *target_bo_gem = (drm_intel_bo_gem *) target_bo;
1864         bool fenced_command;
1865
1866         if (bo_gem->has_error)
1867                 return -ENOMEM;
1868
1869         if (target_bo_gem->has_error) {
1870                 bo_gem->has_error = true;
1871                 return -ENOMEM;
1872         }
1873
1874         /* We never use HW fences for rendering on 965+ */
1875         if (bufmgr_gem->gen >= 4)
1876                 need_fence = false;
1877
1878         fenced_command = need_fence;
1879         if (target_bo_gem->tiling_mode == I915_TILING_NONE)
1880                 need_fence = false;
1881
1882         /* Create a new relocation list if needed */
1883         if (bo_gem->relocs == NULL && drm_intel_setup_reloc_list(bo))
1884                 return -ENOMEM;
1885
1886         /* Check overflow */
1887         assert(bo_gem->reloc_count < bufmgr_gem->max_relocs);
1888
1889         /* Check args */
1890         assert(offset <= bo->size - 4);
1891         assert((write_domain & (write_domain - 1)) == 0);
1892
1893         /* An object needing a fence is a tiled buffer, so it won't have
1894          * relocs to other buffers.
1895          */
1896         if (need_fence) {
1897                 assert(target_bo_gem->reloc_count == 0);
1898                 target_bo_gem->reloc_tree_fences = 1;
1899         }
1900
1901         /* Make sure that we're not adding a reloc to something whose size has
1902          * already been accounted for.
1903          */
1904         assert(!bo_gem->used_as_reloc_target);
1905         if (target_bo_gem != bo_gem) {
1906                 target_bo_gem->used_as_reloc_target = true;
1907                 bo_gem->reloc_tree_size += target_bo_gem->reloc_tree_size;
1908                 bo_gem->reloc_tree_fences += target_bo_gem->reloc_tree_fences;
1909         }
1910
1911         bo_gem->relocs[bo_gem->reloc_count].offset = offset;
1912         bo_gem->relocs[bo_gem->reloc_count].delta = target_offset;
1913         bo_gem->relocs[bo_gem->reloc_count].target_handle =
1914             target_bo_gem->gem_handle;
1915         bo_gem->relocs[bo_gem->reloc_count].read_domains = read_domains;
1916         bo_gem->relocs[bo_gem->reloc_count].write_domain = write_domain;
1917         bo_gem->relocs[bo_gem->reloc_count].presumed_offset = target_bo->offset64;
1918
1919         bo_gem->reloc_target_info[bo_gem->reloc_count].bo = target_bo;
1920         if (target_bo != bo)
1921                 drm_intel_gem_bo_reference(target_bo);
1922         if (fenced_command)
1923                 bo_gem->reloc_target_info[bo_gem->reloc_count].flags =
1924                         DRM_INTEL_RELOC_FENCE;
1925         else
1926                 bo_gem->reloc_target_info[bo_gem->reloc_count].flags = 0;
1927
1928         bo_gem->reloc_count++;
1929
1930         return 0;
1931 }
1932
1933 static int
1934 drm_intel_gem_bo_emit_reloc(drm_intel_bo *bo, uint32_t offset,
1935                             drm_intel_bo *target_bo, uint32_t target_offset,
1936                             uint32_t read_domains, uint32_t write_domain)
1937 {
1938         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
1939
1940         return do_bo_emit_reloc(bo, offset, target_bo, target_offset,
1941                                 read_domains, write_domain,
1942                                 !bufmgr_gem->fenced_relocs);
1943 }
1944
1945 static int
1946 drm_intel_gem_bo_emit_reloc_fence(drm_intel_bo *bo, uint32_t offset,
1947                                   drm_intel_bo *target_bo,
1948                                   uint32_t target_offset,
1949                                   uint32_t read_domains, uint32_t write_domain)
1950 {
1951         return do_bo_emit_reloc(bo, offset, target_bo, target_offset,
1952                                 read_domains, write_domain, true);
1953 }
1954
1955 int
1956 drm_intel_gem_bo_get_reloc_count(drm_intel_bo *bo)
1957 {
1958         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1959
1960         return bo_gem->reloc_count;
1961 }
1962
1963 /**
1964  * Removes existing relocation entries in the BO after "start".
1965  *
1966  * This allows a user to avoid a two-step process for state setup with
1967  * counting up all the buffer objects and doing a
1968  * drm_intel_bufmgr_check_aperture_space() before emitting any of the
1969  * relocations for the state setup.  Instead, save the state of the
1970  * batchbuffer including drm_intel_gem_get_reloc_count(), emit all the
1971  * state, and then check if it still fits in the aperture.
1972  *
1973  * Any further drm_intel_bufmgr_check_aperture_space() queries
1974  * involving this buffer in the tree are undefined after this call.
1975  */
1976 void
1977 drm_intel_gem_bo_clear_relocs(drm_intel_bo *bo, int start)
1978 {
1979         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1980         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1981         int i;
1982         struct timespec time;
1983
1984         clock_gettime(CLOCK_MONOTONIC, &time);
1985
1986         assert(bo_gem->reloc_count >= start);
1987
1988         /* Unreference the cleared target buffers */
1989         pthread_mutex_lock(&bufmgr_gem->lock);
1990
1991         for (i = start; i < bo_gem->reloc_count; i++) {
1992                 drm_intel_bo_gem *target_bo_gem = (drm_intel_bo_gem *) bo_gem->reloc_target_info[i].bo;
1993                 if (&target_bo_gem->bo != bo) {
1994                         bo_gem->reloc_tree_fences -= target_bo_gem->reloc_tree_fences;
1995                         drm_intel_gem_bo_unreference_locked_timed(&target_bo_gem->bo,
1996                                                                   time.tv_sec);
1997                 }
1998         }
1999         bo_gem->reloc_count = start;
2000
2001         pthread_mutex_unlock(&bufmgr_gem->lock);
2002
2003 }
2004
2005 /**
2006  * Walk the tree of relocations rooted at BO and accumulate the list of
2007  * validations to be performed and update the relocation buffers with
2008  * index values into the validation list.
2009  */
2010 static void
2011 drm_intel_gem_bo_process_reloc(drm_intel_bo *bo)
2012 {
2013         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2014         int i;
2015
2016         if (bo_gem->relocs == NULL)
2017                 return;
2018
2019         for (i = 0; i < bo_gem->reloc_count; i++) {
2020                 drm_intel_bo *target_bo = bo_gem->reloc_target_info[i].bo;
2021
2022                 if (target_bo == bo)
2023                         continue;
2024
2025                 drm_intel_gem_bo_mark_mmaps_incoherent(bo);
2026
2027                 /* Continue walking the tree depth-first. */
2028                 drm_intel_gem_bo_process_reloc(target_bo);
2029
2030                 /* Add the target to the validate list */
2031                 drm_intel_add_validate_buffer(target_bo);
2032         }
2033 }
2034
2035 static void
2036 drm_intel_gem_bo_process_reloc2(drm_intel_bo *bo)
2037 {
2038         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
2039         int i;
2040
2041         if (bo_gem->relocs == NULL)
2042                 return;
2043
2044         for (i = 0; i < bo_gem->reloc_count; i++) {
2045                 drm_intel_bo *target_bo = bo_gem->reloc_target_info[i].bo;
2046                 int need_fence;
2047
2048                 if (target_bo == bo)
2049                         continue;
2050
2051                 drm_intel_gem_bo_mark_mmaps_incoherent(bo);
2052
2053                 /* Continue walking the tree depth-first. */
2054                 drm_intel_gem_bo_process_reloc2(target_bo);
2055
2056                 need_fence = (bo_gem->reloc_target_info[i].flags &
2057                               DRM_INTEL_RELOC_FENCE);
2058
2059                 /* Add the target to the validate list */
2060                 drm_intel_add_validate_buffer2(target_bo, need_fence);
2061         }
2062 }
2063
2064
2065 static void
2066 drm_intel_update_buffer_offsets(drm_intel_bufmgr_gem *bufmgr_gem)
2067 {
2068         int i;
2069
2070         for (i = 0; i < bufmgr_gem->exec_count; i++) {
2071                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
2072                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2073
2074                 /* Update the buffer offset */
2075                 if (bufmgr_gem->exec_objects[i].offset != bo->offset64) {
2076                         DBG("BO %d (%s) migrated: 0x%08lx -> 0x%08llx\n",
2077                             bo_gem->gem_handle, bo_gem->name, bo->offset64,
2078                             (unsigned long long)bufmgr_gem->exec_objects[i].
2079                             offset);
2080                         bo->offset64 = bufmgr_gem->exec_objects[i].offset;
2081                         bo->offset = bufmgr_gem->exec_objects[i].offset;
2082                 }
2083         }
2084 }
2085
2086 static void
2087 drm_intel_update_buffer_offsets2 (drm_intel_bufmgr_gem *bufmgr_gem)
2088 {
2089         int i;
2090
2091         for (i = 0; i < bufmgr_gem->exec_count; i++) {
2092                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
2093                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
2094
2095                 /* Update the buffer offset */
2096                 if (bufmgr_gem->exec2_objects[i].offset != bo->offset64) {
2097                         DBG("BO %d (%s) migrated: 0x%08lx -> 0x%08llx\n",
2098                             bo_gem->gem_handle, bo_gem->name, bo->offset64,
2099                             (unsigned long long)bufmgr_gem->exec2_objects[i].offset);
2100                         bo->offset64 = bufmgr_gem->exec2_objects[i].offset;
2101                         bo->offset = bufmgr_gem->exec2_objects[i].offset;
2102                 }
2103         }
2104 }
2105
2106 void
2107 drm_intel_gem_bo_aub_dump_bmp(drm_intel_bo *bo,
2108                               int x1, int y1, int width, int height,
2109                               enum aub_dump_bmp_format format,
2110                               int pitch, int offset)
2111 {
2112 }
2113
2114 static int
2115 drm_intel_gem_bo_exec(drm_intel_bo *bo, int used,
2116                       drm_clip_rect_t * cliprects, int num_cliprects, int DR4)
2117 {
2118         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2119         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2120         struct drm_i915_gem_execbuffer execbuf;
2121         int ret, i;
2122
2123         if (bo_gem->has_error)
2124                 return -ENOMEM;
2125
2126         pthread_mutex_lock(&bufmgr_gem->lock);
2127         /* Update indices and set up the validate list. */
2128         drm_intel_gem_bo_process_reloc(bo);
2129
2130         /* Add the batch buffer to the validation list.  There are no
2131          * relocations pointing to it.
2132          */
2133         drm_intel_add_validate_buffer(bo);
2134
2135         memclear(execbuf);
2136         execbuf.buffers_ptr = (uintptr_t) bufmgr_gem->exec_objects;
2137         execbuf.buffer_count = bufmgr_gem->exec_count;
2138         execbuf.batch_start_offset = 0;
2139         execbuf.batch_len = used;
2140         execbuf.cliprects_ptr = (uintptr_t) cliprects;
2141         execbuf.num_cliprects = num_cliprects;
2142         execbuf.DR1 = 0;
2143         execbuf.DR4 = DR4;
2144
2145         ret = drmIoctl(bufmgr_gem->fd,
2146                        DRM_IOCTL_I915_GEM_EXECBUFFER,
2147                        &execbuf);
2148         if (ret != 0) {
2149                 ret = -errno;
2150                 if (errno == ENOSPC) {
2151                         DBG("Execbuffer fails to pin. "
2152                             "Estimate: %u. Actual: %u. Available: %u\n",
2153                             drm_intel_gem_estimate_batch_space(bufmgr_gem->exec_bos,
2154                                                                bufmgr_gem->
2155                                                                exec_count),
2156                             drm_intel_gem_compute_batch_space(bufmgr_gem->exec_bos,
2157                                                               bufmgr_gem->
2158                                                               exec_count),
2159                             (unsigned int)bufmgr_gem->gtt_size);
2160                 }
2161         }
2162         drm_intel_update_buffer_offsets(bufmgr_gem);
2163
2164         if (bufmgr_gem->bufmgr.debug)
2165                 drm_intel_gem_dump_validation_list(bufmgr_gem);
2166
2167         for (i = 0; i < bufmgr_gem->exec_count; i++) {
2168                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
2169                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2170
2171                 bo_gem->idle = false;
2172
2173                 /* Disconnect the buffer from the validate list */
2174                 bo_gem->validate_index = -1;
2175                 bufmgr_gem->exec_bos[i] = NULL;
2176         }
2177         bufmgr_gem->exec_count = 0;
2178         pthread_mutex_unlock(&bufmgr_gem->lock);
2179
2180         return ret;
2181 }
2182
2183 static int
2184 do_exec2(drm_intel_bo *bo, int used, drm_intel_context *ctx,
2185          drm_clip_rect_t *cliprects, int num_cliprects, int DR4,
2186          unsigned int flags)
2187 {
2188         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
2189         struct drm_i915_gem_execbuffer2 execbuf;
2190         int ret = 0;
2191         int i;
2192
2193         switch (flags & 0x7) {
2194         default:
2195                 return -EINVAL;
2196         case I915_EXEC_BLT:
2197                 if (!bufmgr_gem->has_blt)
2198                         return -EINVAL;
2199                 break;
2200         case I915_EXEC_BSD:
2201                 if (!bufmgr_gem->has_bsd)
2202                         return -EINVAL;
2203                 break;
2204         case I915_EXEC_VEBOX:
2205                 if (!bufmgr_gem->has_vebox)
2206                         return -EINVAL;
2207                 break;
2208         case I915_EXEC_RENDER:
2209         case I915_EXEC_DEFAULT:
2210                 break;
2211         }
2212
2213         pthread_mutex_lock(&bufmgr_gem->lock);
2214         /* Update indices and set up the validate list. */
2215         drm_intel_gem_bo_process_reloc2(bo);
2216
2217         /* Add the batch buffer to the validation list.  There are no relocations
2218          * pointing to it.
2219          */
2220         drm_intel_add_validate_buffer2(bo, 0);
2221
2222         memclear(execbuf);
2223         execbuf.buffers_ptr = (uintptr_t)bufmgr_gem->exec2_objects;
2224         execbuf.buffer_count = bufmgr_gem->exec_count;
2225         execbuf.batch_start_offset = 0;
2226         execbuf.batch_len = used;
2227         execbuf.cliprects_ptr = (uintptr_t)cliprects;
2228         execbuf.num_cliprects = num_cliprects;
2229         execbuf.DR1 = 0;
2230         execbuf.DR4 = DR4;
2231         execbuf.flags = flags;
2232         if (ctx == NULL)
2233                 i915_execbuffer2_set_context_id(execbuf, 0);
2234         else
2235                 i915_execbuffer2_set_context_id(execbuf, ctx->ctx_id);
2236         execbuf.rsvd2 = 0;
2237
2238         if (bufmgr_gem->no_exec)
2239                 goto skip_execution;
2240
2241         ret = drmIoctl(bufmgr_gem->fd,
2242                        DRM_IOCTL_I915_GEM_EXECBUFFER2,
2243                        &execbuf);
2244         if (ret != 0) {
2245                 ret = -errno;
2246                 if (ret == -ENOSPC) {
2247                         DBG("Execbuffer fails to pin. "
2248                             "Estimate: %u. Actual: %u. Available: %u\n",
2249                             drm_intel_gem_estimate_batch_space(bufmgr_gem->exec_bos,
2250                                                                bufmgr_gem->exec_count),
2251                             drm_intel_gem_compute_batch_space(bufmgr_gem->exec_bos,
2252                                                               bufmgr_gem->exec_count),
2253                             (unsigned int) bufmgr_gem->gtt_size);
2254                 }
2255         }
2256         drm_intel_update_buffer_offsets2(bufmgr_gem);
2257
2258 skip_execution:
2259         if (bufmgr_gem->bufmgr.debug)
2260                 drm_intel_gem_dump_validation_list(bufmgr_gem);
2261
2262         for (i = 0; i < bufmgr_gem->exec_count; i++) {
2263                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
2264                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
2265
2266                 bo_gem->idle = false;
2267
2268                 /* Disconnect the buffer from the validate list */
2269                 bo_gem->validate_index = -1;
2270                 bufmgr_gem->exec_bos[i] = NULL;
2271         }
2272         bufmgr_gem->exec_count = 0;
2273         pthread_mutex_unlock(&bufmgr_gem->lock);
2274
2275         return ret;
2276 }
2277
2278 static int
2279 drm_intel_gem_bo_exec2(drm_intel_bo *bo, int used,
2280                        drm_clip_rect_t *cliprects, int num_cliprects,
2281                        int DR4)
2282 {
2283         return do_exec2(bo, used, NULL, cliprects, num_cliprects, DR4,
2284                         I915_EXEC_RENDER);
2285 }
2286
2287 static int
2288 drm_intel_gem_bo_mrb_exec2(drm_intel_bo *bo, int used,
2289                         drm_clip_rect_t *cliprects, int num_cliprects, int DR4,
2290                         unsigned int flags)
2291 {
2292         return do_exec2(bo, used, NULL, cliprects, num_cliprects, DR4,
2293                         flags);
2294 }
2295
2296 int
2297 drm_intel_gem_bo_context_exec(drm_intel_bo *bo, drm_intel_context *ctx,
2298                               int used, unsigned int flags)
2299 {
2300         return do_exec2(bo, used, ctx, NULL, 0, 0, flags);
2301 }
2302
2303 static int
2304 drm_intel_gem_bo_pin(drm_intel_bo *bo, uint32_t alignment)
2305 {
2306         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2307         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2308         struct drm_i915_gem_pin pin;
2309         int ret;
2310
2311         memclear(pin);
2312         pin.handle = bo_gem->gem_handle;
2313         pin.alignment = alignment;
2314
2315         ret = drmIoctl(bufmgr_gem->fd,
2316                        DRM_IOCTL_I915_GEM_PIN,
2317                        &pin);
2318         if (ret != 0)
2319                 return -errno;
2320
2321         bo->offset64 = pin.offset;
2322         bo->offset = pin.offset;
2323         return 0;
2324 }
2325
2326 static int
2327 drm_intel_gem_bo_unpin(drm_intel_bo *bo)
2328 {
2329         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2330         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2331         struct drm_i915_gem_unpin unpin;
2332         int ret;
2333
2334         memclear(unpin);
2335         unpin.handle = bo_gem->gem_handle;
2336
2337         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_UNPIN, &unpin);
2338         if (ret != 0)
2339                 return -errno;
2340
2341         return 0;
2342 }
2343
2344 static int
2345 drm_intel_gem_bo_set_tiling_internal(drm_intel_bo *bo,
2346                                      uint32_t tiling_mode,
2347                                      uint32_t stride)
2348 {
2349         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2350         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2351         struct drm_i915_gem_set_tiling set_tiling;
2352         int ret;
2353
2354         if (bo_gem->global_name == 0 &&
2355             tiling_mode == bo_gem->tiling_mode &&
2356             stride == bo_gem->stride)
2357                 return 0;
2358
2359         memset(&set_tiling, 0, sizeof(set_tiling));
2360         do {
2361                 /* set_tiling is slightly broken and overwrites the
2362                  * input on the error path, so we have to open code
2363                  * rmIoctl.
2364                  */
2365                 set_tiling.handle = bo_gem->gem_handle;
2366                 set_tiling.tiling_mode = tiling_mode;
2367                 set_tiling.stride = stride;
2368
2369                 ret = ioctl(bufmgr_gem->fd,
2370                             DRM_IOCTL_I915_GEM_SET_TILING,
2371                             &set_tiling);
2372         } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
2373         if (ret == -1)
2374                 return -errno;
2375
2376         bo_gem->tiling_mode = set_tiling.tiling_mode;
2377         bo_gem->swizzle_mode = set_tiling.swizzle_mode;
2378         bo_gem->stride = set_tiling.stride;
2379         return 0;
2380 }
2381
2382 static int
2383 drm_intel_gem_bo_set_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
2384                             uint32_t stride)
2385 {
2386         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2387         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2388         int ret;
2389
2390         /* Tiling with userptr surfaces is not supported
2391          * on all hardware so refuse it for time being.
2392          */
2393         if (bo_gem->is_userptr)
2394                 return -EINVAL;
2395
2396         /* Linear buffers have no stride. By ensuring that we only ever use
2397          * stride 0 with linear buffers, we simplify our code.
2398          */
2399         if (*tiling_mode == I915_TILING_NONE)
2400                 stride = 0;
2401
2402         ret = drm_intel_gem_bo_set_tiling_internal(bo, *tiling_mode, stride);
2403         if (ret == 0)
2404                 drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem, 0);
2405
2406         *tiling_mode = bo_gem->tiling_mode;
2407         return ret;
2408 }
2409
2410 static int
2411 drm_intel_gem_bo_get_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
2412                             uint32_t * swizzle_mode)
2413 {
2414         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2415
2416         *tiling_mode = bo_gem->tiling_mode;
2417         *swizzle_mode = bo_gem->swizzle_mode;
2418         return 0;
2419 }
2420
2421 drm_intel_bo *
2422 drm_intel_bo_gem_create_from_prime(drm_intel_bufmgr *bufmgr, int prime_fd, int size)
2423 {
2424         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
2425         int ret;
2426         uint32_t handle;
2427         drm_intel_bo_gem *bo_gem;
2428         struct drm_i915_gem_get_tiling get_tiling;
2429         drmMMListHead *list;
2430
2431         pthread_mutex_lock(&bufmgr_gem->lock);
2432         ret = drmPrimeFDToHandle(bufmgr_gem->fd, prime_fd, &handle);
2433         if (ret) {
2434                 DBG("create_from_prime: failed to obtain handle from fd: %s\n", strerror(errno));
2435                 pthread_mutex_unlock(&bufmgr_gem->lock);
2436                 return NULL;
2437         }
2438
2439         /*
2440          * See if the kernel has already returned this buffer to us. Just as
2441          * for named buffers, we must not create two bo's pointing at the same
2442          * kernel object
2443          */
2444         for (list = bufmgr_gem->named.next;
2445              list != &bufmgr_gem->named;
2446              list = list->next) {
2447                 bo_gem = DRMLISTENTRY(drm_intel_bo_gem, list, name_list);
2448                 if (bo_gem->gem_handle == handle) {
2449                         drm_intel_gem_bo_reference(&bo_gem->bo);
2450                         pthread_mutex_unlock(&bufmgr_gem->lock);
2451                         return &bo_gem->bo;
2452                 }
2453         }
2454
2455         bo_gem = calloc(1, sizeof(*bo_gem));
2456         if (!bo_gem) {
2457                 pthread_mutex_unlock(&bufmgr_gem->lock);
2458                 return NULL;
2459         }
2460         /* Determine size of bo.  The fd-to-handle ioctl really should
2461          * return the size, but it doesn't.  If we have kernel 3.12 or
2462          * later, we can lseek on the prime fd to get the size.  Older
2463          * kernels will just fail, in which case we fall back to the
2464          * provided (estimated or guess size). */
2465         ret = lseek(prime_fd, 0, SEEK_END);
2466         if (ret != -1)
2467                 bo_gem->bo.size = ret;
2468         else
2469                 bo_gem->bo.size = size;
2470
2471         bo_gem->bo.handle = handle;
2472         bo_gem->bo.bufmgr = bufmgr;
2473
2474         bo_gem->gem_handle = handle;
2475
2476         atomic_set(&bo_gem->refcount, 1);
2477
2478         bo_gem->name = "prime";
2479         bo_gem->validate_index = -1;
2480         bo_gem->reloc_tree_fences = 0;
2481         bo_gem->used_as_reloc_target = false;
2482         bo_gem->has_error = false;
2483         bo_gem->reusable = false;
2484
2485         DRMINITLISTHEAD(&bo_gem->vma_list);
2486         DRMLISTADDTAIL(&bo_gem->name_list, &bufmgr_gem->named);
2487         pthread_mutex_unlock(&bufmgr_gem->lock);
2488
2489         memclear(get_tiling);
2490         get_tiling.handle = bo_gem->gem_handle;
2491         ret = drmIoctl(bufmgr_gem->fd,
2492                        DRM_IOCTL_I915_GEM_GET_TILING,
2493                        &get_tiling);
2494         if (ret != 0) {
2495                 DBG("create_from_prime: failed to get tiling: %s\n", strerror(errno));
2496                 drm_intel_gem_bo_unreference(&bo_gem->bo);
2497                 return NULL;
2498         }
2499         bo_gem->tiling_mode = get_tiling.tiling_mode;
2500         bo_gem->swizzle_mode = get_tiling.swizzle_mode;
2501         /* XXX stride is unknown */
2502         drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem, 0);
2503
2504         return &bo_gem->bo;
2505 }
2506
2507 int
2508 drm_intel_bo_gem_export_to_prime(drm_intel_bo *bo, int *prime_fd)
2509 {
2510         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2511         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2512
2513         pthread_mutex_lock(&bufmgr_gem->lock);
2514         if (DRMLISTEMPTY(&bo_gem->name_list))
2515                 DRMLISTADDTAIL(&bo_gem->name_list, &bufmgr_gem->named);
2516         pthread_mutex_unlock(&bufmgr_gem->lock);
2517
2518         if (drmPrimeHandleToFD(bufmgr_gem->fd, bo_gem->gem_handle,
2519                                DRM_CLOEXEC, prime_fd) != 0)
2520                 return -errno;
2521
2522         bo_gem->reusable = false;
2523
2524         return 0;
2525 }
2526
2527 static int
2528 drm_intel_gem_bo_flink(drm_intel_bo *bo, uint32_t * name)
2529 {
2530         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2531         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2532         int ret;
2533
2534         if (!bo_gem->global_name) {
2535                 struct drm_gem_flink flink;
2536
2537                 memclear(flink);
2538                 flink.handle = bo_gem->gem_handle;
2539
2540                 pthread_mutex_lock(&bufmgr_gem->lock);
2541
2542                 ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_GEM_FLINK, &flink);
2543                 if (ret != 0) {
2544                         pthread_mutex_unlock(&bufmgr_gem->lock);
2545                         return -errno;
2546                 }
2547
2548                 bo_gem->global_name = flink.name;
2549                 bo_gem->reusable = false;
2550
2551                 if (DRMLISTEMPTY(&bo_gem->name_list))
2552                         DRMLISTADDTAIL(&bo_gem->name_list, &bufmgr_gem->named);
2553                 pthread_mutex_unlock(&bufmgr_gem->lock);
2554         }
2555
2556         *name = bo_gem->global_name;
2557         return 0;
2558 }
2559
2560 /**
2561  * Enables unlimited caching of buffer objects for reuse.
2562  *
2563  * This is potentially very memory expensive, as the cache at each bucket
2564  * size is only bounded by how many buffers of that size we've managed to have
2565  * in flight at once.
2566  */
2567 void
2568 drm_intel_bufmgr_gem_enable_reuse(drm_intel_bufmgr *bufmgr)
2569 {
2570         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
2571
2572         bufmgr_gem->bo_reuse = true;
2573 }
2574
2575 /**
2576  * Enable use of fenced reloc type.
2577  *
2578  * New code should enable this to avoid unnecessary fence register
2579  * allocation.  If this option is not enabled, all relocs will have fence
2580  * register allocated.
2581  */
2582 void
2583 drm_intel_bufmgr_gem_enable_fenced_relocs(drm_intel_bufmgr *bufmgr)
2584 {
2585         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
2586
2587         if (bufmgr_gem->bufmgr.bo_exec == drm_intel_gem_bo_exec2)
2588                 bufmgr_gem->fenced_relocs = true;
2589 }
2590
2591 /**
2592  * Return the additional aperture space required by the tree of buffer objects
2593  * rooted at bo.
2594  */
2595 static int
2596 drm_intel_gem_bo_get_aperture_space(drm_intel_bo *bo)
2597 {
2598         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2599         int i;
2600         int total = 0;
2601
2602         if (bo == NULL || bo_gem->included_in_check_aperture)
2603                 return 0;
2604
2605         total += bo->size;
2606         bo_gem->included_in_check_aperture = true;
2607
2608         for (i = 0; i < bo_gem->reloc_count; i++)
2609                 total +=
2610                     drm_intel_gem_bo_get_aperture_space(bo_gem->
2611                                                         reloc_target_info[i].bo);
2612
2613         return total;
2614 }
2615
2616 /**
2617  * Count the number of buffers in this list that need a fence reg
2618  *
2619  * If the count is greater than the number of available regs, we'll have
2620  * to ask the caller to resubmit a batch with fewer tiled buffers.
2621  *
2622  * This function over-counts if the same buffer is used multiple times.
2623  */
2624 static unsigned int
2625 drm_intel_gem_total_fences(drm_intel_bo ** bo_array, int count)
2626 {
2627         int i;
2628         unsigned int total = 0;
2629
2630         for (i = 0; i < count; i++) {
2631                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo_array[i];
2632
2633                 if (bo_gem == NULL)
2634                         continue;
2635
2636                 total += bo_gem->reloc_tree_fences;
2637         }
2638         return total;
2639 }
2640
2641 /**
2642  * Clear the flag set by drm_intel_gem_bo_get_aperture_space() so we're ready
2643  * for the next drm_intel_bufmgr_check_aperture_space() call.
2644  */
2645 static void
2646 drm_intel_gem_bo_clear_aperture_space_flag(drm_intel_bo *bo)
2647 {
2648         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2649         int i;
2650
2651         if (bo == NULL || !bo_gem->included_in_check_aperture)
2652                 return;
2653
2654         bo_gem->included_in_check_aperture = false;
2655
2656         for (i = 0; i < bo_gem->reloc_count; i++)
2657                 drm_intel_gem_bo_clear_aperture_space_flag(bo_gem->
2658                                                            reloc_target_info[i].bo);
2659 }
2660
2661 /**
2662  * Return a conservative estimate for the amount of aperture required
2663  * for a collection of buffers. This may double-count some buffers.
2664  */
2665 static unsigned int
2666 drm_intel_gem_estimate_batch_space(drm_intel_bo **bo_array, int count)
2667 {
2668         int i;
2669         unsigned int total = 0;
2670
2671         for (i = 0; i < count; i++) {
2672                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo_array[i];
2673                 if (bo_gem != NULL)
2674                         total += bo_gem->reloc_tree_size;
2675         }
2676         return total;
2677 }
2678
2679 /**
2680  * Return the amount of aperture needed for a collection of buffers.
2681  * This avoids double counting any buffers, at the cost of looking
2682  * at every buffer in the set.
2683  */
2684 static unsigned int
2685 drm_intel_gem_compute_batch_space(drm_intel_bo **bo_array, int count)
2686 {
2687         int i;
2688         unsigned int total = 0;
2689
2690         for (i = 0; i < count; i++) {
2691                 total += drm_intel_gem_bo_get_aperture_space(bo_array[i]);
2692                 /* For the first buffer object in the array, we get an
2693                  * accurate count back for its reloc_tree size (since nothing
2694                  * had been flagged as being counted yet).  We can save that
2695                  * value out as a more conservative reloc_tree_size that
2696                  * avoids double-counting target buffers.  Since the first
2697                  * buffer happens to usually be the batch buffer in our
2698                  * callers, this can pull us back from doing the tree
2699                  * walk on every new batch emit.
2700                  */
2701                 if (i == 0) {
2702                         drm_intel_bo_gem *bo_gem =
2703                             (drm_intel_bo_gem *) bo_array[i];
2704                         bo_gem->reloc_tree_size = total;
2705                 }
2706         }
2707
2708         for (i = 0; i < count; i++)
2709                 drm_intel_gem_bo_clear_aperture_space_flag(bo_array[i]);
2710         return total;
2711 }
2712
2713 /**
2714  * Return -1 if the batchbuffer should be flushed before attempting to
2715  * emit rendering referencing the buffers pointed to by bo_array.
2716  *
2717  * This is required because if we try to emit a batchbuffer with relocations
2718  * to a tree of buffers that won't simultaneously fit in the aperture,
2719  * the rendering will return an error at a point where the software is not
2720  * prepared to recover from it.
2721  *
2722  * However, we also want to emit the batchbuffer significantly before we reach
2723  * the limit, as a series of batchbuffers each of which references buffers
2724  * covering almost all of the aperture means that at each emit we end up
2725  * waiting to evict a buffer from the last rendering, and we get synchronous
2726  * performance.  By emitting smaller batchbuffers, we eat some CPU overhead to
2727  * get better parallelism.
2728  */
2729 static int
2730 drm_intel_gem_check_aperture_space(drm_intel_bo **bo_array, int count)
2731 {
2732         drm_intel_bufmgr_gem *bufmgr_gem =
2733             (drm_intel_bufmgr_gem *) bo_array[0]->bufmgr;
2734         unsigned int total = 0;
2735         unsigned int threshold = bufmgr_gem->gtt_size * 3 / 4;
2736         int total_fences;
2737
2738         /* Check for fence reg constraints if necessary */
2739         if (bufmgr_gem->available_fences) {
2740                 total_fences = drm_intel_gem_total_fences(bo_array, count);
2741                 if (total_fences > bufmgr_gem->available_fences)
2742                         return -ENOSPC;
2743         }
2744
2745         total = drm_intel_gem_estimate_batch_space(bo_array, count);
2746
2747         if (total > threshold)
2748                 total = drm_intel_gem_compute_batch_space(bo_array, count);
2749
2750         if (total > threshold) {
2751                 DBG("check_space: overflowed available aperture, "
2752                     "%dkb vs %dkb\n",
2753                     total / 1024, (int)bufmgr_gem->gtt_size / 1024);
2754                 return -ENOSPC;
2755         } else {
2756                 DBG("drm_check_space: total %dkb vs bufgr %dkb\n", total / 1024,
2757                     (int)bufmgr_gem->gtt_size / 1024);
2758                 return 0;
2759         }
2760 }
2761
2762 /*
2763  * Disable buffer reuse for objects which are shared with the kernel
2764  * as scanout buffers
2765  */
2766 static int
2767 drm_intel_gem_bo_disable_reuse(drm_intel_bo *bo)
2768 {
2769         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2770
2771         bo_gem->reusable = false;
2772         return 0;
2773 }
2774
2775 static int
2776 drm_intel_gem_bo_is_reusable(drm_intel_bo *bo)
2777 {
2778         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2779
2780         return bo_gem->reusable;
2781 }
2782
2783 static int
2784 _drm_intel_gem_bo_references(drm_intel_bo *bo, drm_intel_bo *target_bo)
2785 {
2786         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2787         int i;
2788
2789         for (i = 0; i < bo_gem->reloc_count; i++) {
2790                 if (bo_gem->reloc_target_info[i].bo == target_bo)
2791                         return 1;
2792                 if (bo == bo_gem->reloc_target_info[i].bo)
2793                         continue;
2794                 if (_drm_intel_gem_bo_references(bo_gem->reloc_target_info[i].bo,
2795                                                 target_bo))
2796                         return 1;
2797         }
2798
2799         return 0;
2800 }
2801
2802 /** Return true if target_bo is referenced by bo's relocation tree. */
2803 static int
2804 drm_intel_gem_bo_references(drm_intel_bo *bo, drm_intel_bo *target_bo)
2805 {
2806         drm_intel_bo_gem *target_bo_gem = (drm_intel_bo_gem *) target_bo;
2807
2808         if (bo == NULL || target_bo == NULL)
2809                 return 0;
2810         if (target_bo_gem->used_as_reloc_target)
2811                 return _drm_intel_gem_bo_references(bo, target_bo);
2812         return 0;
2813 }
2814
2815 static void
2816 add_bucket(drm_intel_bufmgr_gem *bufmgr_gem, int size)
2817 {
2818         unsigned int i = bufmgr_gem->num_buckets;
2819
2820         assert(i < ARRAY_SIZE(bufmgr_gem->cache_bucket));
2821
2822         DRMINITLISTHEAD(&bufmgr_gem->cache_bucket[i].head);
2823         bufmgr_gem->cache_bucket[i].size = size;
2824         bufmgr_gem->num_buckets++;
2825 }
2826
2827 static void
2828 init_cache_buckets(drm_intel_bufmgr_gem *bufmgr_gem)
2829 {
2830         unsigned long size, cache_max_size = 64 * 1024 * 1024;
2831
2832         /* OK, so power of two buckets was too wasteful of memory.
2833          * Give 3 other sizes between each power of two, to hopefully
2834          * cover things accurately enough.  (The alternative is
2835          * probably to just go for exact matching of sizes, and assume
2836          * that for things like composited window resize the tiled
2837          * width/height alignment and rounding of sizes to pages will
2838          * get us useful cache hit rates anyway)
2839          */
2840         add_bucket(bufmgr_gem, 4096);
2841         add_bucket(bufmgr_gem, 4096 * 2);
2842         add_bucket(bufmgr_gem, 4096 * 3);
2843
2844         /* Initialize the linked lists for BO reuse cache. */
2845         for (size = 4 * 4096; size <= cache_max_size; size *= 2) {
2846                 add_bucket(bufmgr_gem, size);
2847
2848                 add_bucket(bufmgr_gem, size + size * 1 / 4);
2849                 add_bucket(bufmgr_gem, size + size * 2 / 4);
2850                 add_bucket(bufmgr_gem, size + size * 3 / 4);
2851         }
2852 }
2853
2854 void
2855 drm_intel_bufmgr_gem_set_vma_cache_size(drm_intel_bufmgr *bufmgr, int limit)
2856 {
2857         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
2858
2859         bufmgr_gem->vma_max = limit;
2860
2861         drm_intel_gem_bo_purge_vma_cache(bufmgr_gem);
2862 }
2863
2864 /**
2865  * Get the PCI ID for the device.  This can be overridden by setting the
2866  * INTEL_DEVID_OVERRIDE environment variable to the desired ID.
2867  */
2868 static int
2869 get_pci_device_id(drm_intel_bufmgr_gem *bufmgr_gem)
2870 {
2871         char *devid_override;
2872         int devid = 0;
2873         int ret;
2874         drm_i915_getparam_t gp;
2875
2876         if (geteuid() == getuid()) {
2877                 devid_override = getenv("INTEL_DEVID_OVERRIDE");
2878                 if (devid_override) {
2879                         bufmgr_gem->no_exec = true;
2880                         return strtod(devid_override, NULL);
2881                 }
2882         }
2883
2884         memclear(gp);
2885         gp.param = I915_PARAM_CHIPSET_ID;
2886         gp.value = &devid;
2887         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2888         if (ret) {
2889                 fprintf(stderr, "get chip id failed: %d [%d]\n", ret, errno);
2890                 fprintf(stderr, "param: %d, val: %d\n", gp.param, *gp.value);
2891         }
2892         return devid;
2893 }
2894
2895 int
2896 drm_intel_bufmgr_gem_get_devid(drm_intel_bufmgr *bufmgr)
2897 {
2898         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
2899
2900         return bufmgr_gem->pci_device;
2901 }
2902
2903 /**
2904  * Sets the AUB filename.
2905  *
2906  * This function has to be called before drm_intel_bufmgr_gem_set_aub_dump()
2907  * for it to have any effect.
2908  */
2909 void
2910 drm_intel_bufmgr_gem_set_aub_filename(drm_intel_bufmgr *bufmgr,
2911                                       const char *filename)
2912 {
2913 }
2914
2915 /**
2916  * Sets up AUB dumping.
2917  *
2918  * This is a trace file format that can be used with the simulator.
2919  * Packets are emitted in a format somewhat like GPU command packets.
2920  * You can set up a GTT and upload your objects into the referenced
2921  * space, then send off batchbuffers and get BMPs out the other end.
2922  */
2923 void
2924 drm_intel_bufmgr_gem_set_aub_dump(drm_intel_bufmgr *bufmgr, int enable)
2925 {
2926         fprintf(stderr, "libdrm aub dumping is deprecated.\n\n"
2927                 "Use intel_aubdump from intel-gpu-tools instead.  Install intel-gpu-tools,\n"
2928                 "then run (for example)\n\n"
2929                 "\t$ intel_aubdump --output=trace.aub glxgears -geometry 500x500\n\n"
2930                 "See the intel_aubdump man page for more details.\n");
2931 }
2932
2933 drm_intel_context *
2934 drm_intel_gem_context_create(drm_intel_bufmgr *bufmgr)
2935 {
2936         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
2937         struct drm_i915_gem_context_create create;
2938         drm_intel_context *context = NULL;
2939         int ret;
2940
2941         context = calloc(1, sizeof(*context));
2942         if (!context)
2943                 return NULL;
2944
2945         memclear(create);
2946         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_CONTEXT_CREATE, &create);
2947         if (ret != 0) {
2948                 DBG("DRM_IOCTL_I915_GEM_CONTEXT_CREATE failed: %s\n",
2949                     strerror(errno));
2950                 free(context);
2951                 return NULL;
2952         }
2953
2954         context->ctx_id = create.ctx_id;
2955         context->bufmgr = bufmgr;
2956
2957         return context;
2958 }
2959
2960 void
2961 drm_intel_gem_context_destroy(drm_intel_context *ctx)
2962 {
2963         drm_intel_bufmgr_gem *bufmgr_gem;
2964         struct drm_i915_gem_context_destroy destroy;
2965         int ret;
2966
2967         if (ctx == NULL)
2968                 return;
2969
2970         memclear(destroy);
2971
2972         bufmgr_gem = (drm_intel_bufmgr_gem *)ctx->bufmgr;
2973         destroy.ctx_id = ctx->ctx_id;
2974         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_CONTEXT_DESTROY,
2975                        &destroy);
2976         if (ret != 0)
2977                 fprintf(stderr, "DRM_IOCTL_I915_GEM_CONTEXT_DESTROY failed: %s\n",
2978                         strerror(errno));
2979
2980         free(ctx);
2981 }
2982
2983 int
2984 drm_intel_get_reset_stats(drm_intel_context *ctx,
2985                           uint32_t *reset_count,
2986                           uint32_t *active,
2987                           uint32_t *pending)
2988 {
2989         drm_intel_bufmgr_gem *bufmgr_gem;
2990         struct drm_i915_reset_stats stats;
2991         int ret;
2992
2993         if (ctx == NULL)
2994                 return -EINVAL;
2995
2996         memclear(stats);
2997
2998         bufmgr_gem = (drm_intel_bufmgr_gem *)ctx->bufmgr;
2999         stats.ctx_id = ctx->ctx_id;
3000         ret = drmIoctl(bufmgr_gem->fd,
3001                        DRM_IOCTL_I915_GET_RESET_STATS,
3002                        &stats);
3003         if (ret == 0) {
3004                 if (reset_count != NULL)
3005                         *reset_count = stats.reset_count;
3006
3007                 if (active != NULL)
3008                         *active = stats.batch_active;
3009
3010                 if (pending != NULL)
3011                         *pending = stats.batch_pending;
3012         }
3013
3014         return ret;
3015 }
3016
3017 int
3018 drm_intel_reg_read(drm_intel_bufmgr *bufmgr,
3019                    uint32_t offset,
3020                    uint64_t *result)
3021 {
3022         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
3023         struct drm_i915_reg_read reg_read;
3024         int ret;
3025
3026         memclear(reg_read);
3027         reg_read.offset = offset;
3028
3029         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_REG_READ, &reg_read);
3030
3031         *result = reg_read.val;
3032         return ret;
3033 }
3034
3035 int
3036 drm_intel_get_subslice_total(int fd, unsigned int *subslice_total)
3037 {
3038         drm_i915_getparam_t gp;
3039         int ret;
3040
3041         memclear(gp);
3042         gp.value = (int*)subslice_total;
3043         gp.param = I915_PARAM_SUBSLICE_TOTAL;
3044         ret = drmIoctl(fd, DRM_IOCTL_I915_GETPARAM, &gp);
3045         if (ret)
3046                 return -errno;
3047
3048         return 0;
3049 }
3050
3051 int
3052 drm_intel_get_eu_total(int fd, unsigned int *eu_total)
3053 {
3054         drm_i915_getparam_t gp;
3055         int ret;
3056
3057         memclear(gp);
3058         gp.value = (int*)eu_total;
3059         gp.param = I915_PARAM_EU_TOTAL;
3060         ret = drmIoctl(fd, DRM_IOCTL_I915_GETPARAM, &gp);
3061         if (ret)
3062                 return -errno;
3063
3064         return 0;
3065 }
3066
3067 /**
3068  * Annotate the given bo for use in aub dumping.
3069  *
3070  * \param annotations is an array of drm_intel_aub_annotation objects
3071  * describing the type of data in various sections of the bo.  Each
3072  * element of the array specifies the type and subtype of a section of
3073  * the bo, and the past-the-end offset of that section.  The elements
3074  * of \c annotations must be sorted so that ending_offset is
3075  * increasing.
3076  *
3077  * \param count is the number of elements in the \c annotations array.
3078  * If \c count is zero, then \c annotations will not be dereferenced.
3079  *
3080  * Annotations are copied into a private data structure, so caller may
3081  * re-use the memory pointed to by \c annotations after the call
3082  * returns.
3083  *
3084  * Annotations are stored for the lifetime of the bo; to reset to the
3085  * default state (no annotations), call this function with a \c count
3086  * of zero.
3087  */
3088 void
3089 drm_intel_bufmgr_gem_set_aub_annotations(drm_intel_bo *bo,
3090                                          drm_intel_aub_annotation *annotations,
3091                                          unsigned count)
3092 {
3093 }
3094
3095 static pthread_mutex_t bufmgr_list_mutex = PTHREAD_MUTEX_INITIALIZER;
3096 static drmMMListHead bufmgr_list = { &bufmgr_list, &bufmgr_list };
3097
3098 static drm_intel_bufmgr_gem *
3099 drm_intel_bufmgr_gem_find(int fd)
3100 {
3101         drm_intel_bufmgr_gem *bufmgr_gem;
3102
3103         DRMLISTFOREACHENTRY(bufmgr_gem, &bufmgr_list, managers) {
3104                 if (bufmgr_gem->fd == fd) {
3105                         atomic_inc(&bufmgr_gem->refcount);
3106                         return bufmgr_gem;
3107                 }
3108         }
3109
3110         return NULL;
3111 }
3112
3113 static void
3114 drm_intel_bufmgr_gem_unref(drm_intel_bufmgr *bufmgr)
3115 {
3116         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
3117
3118         if (atomic_add_unless(&bufmgr_gem->refcount, -1, 1)) {
3119                 pthread_mutex_lock(&bufmgr_list_mutex);
3120
3121                 if (atomic_dec_and_test(&bufmgr_gem->refcount)) {
3122                         DRMLISTDEL(&bufmgr_gem->managers);
3123                         drm_intel_bufmgr_gem_destroy(bufmgr);
3124                 }
3125
3126                 pthread_mutex_unlock(&bufmgr_list_mutex);
3127         }
3128 }
3129
3130 /**
3131  * Initializes the GEM buffer manager, which uses the kernel to allocate, map,
3132  * and manage map buffer objections.
3133  *
3134  * \param fd File descriptor of the opened DRM device.
3135  */
3136 drm_intel_bufmgr *
3137 drm_intel_bufmgr_gem_init(int fd, int batch_size)
3138 {
3139         drm_intel_bufmgr_gem *bufmgr_gem;
3140         struct drm_i915_gem_get_aperture aperture;
3141         drm_i915_getparam_t gp;
3142         int ret, tmp;
3143         bool exec2 = false;
3144
3145         pthread_mutex_lock(&bufmgr_list_mutex);
3146
3147         bufmgr_gem = drm_intel_bufmgr_gem_find(fd);
3148         if (bufmgr_gem)
3149                 goto exit;
3150
3151         bufmgr_gem = calloc(1, sizeof(*bufmgr_gem));
3152         if (bufmgr_gem == NULL)
3153                 goto exit;
3154
3155         bufmgr_gem->fd = fd;
3156         atomic_set(&bufmgr_gem->refcount, 1);
3157
3158         if (pthread_mutex_init(&bufmgr_gem->lock, NULL) != 0) {
3159                 free(bufmgr_gem);
3160                 bufmgr_gem = NULL;
3161                 goto exit;
3162         }
3163
3164         memclear(aperture);
3165         ret = drmIoctl(bufmgr_gem->fd,
3166                        DRM_IOCTL_I915_GEM_GET_APERTURE,
3167                        &aperture);
3168
3169         if (ret == 0)
3170                 bufmgr_gem->gtt_size = aperture.aper_available_size;
3171         else {
3172                 fprintf(stderr, "DRM_IOCTL_I915_GEM_APERTURE failed: %s\n",
3173                         strerror(errno));
3174                 bufmgr_gem->gtt_size = 128 * 1024 * 1024;
3175                 fprintf(stderr, "Assuming %dkB available aperture size.\n"
3176                         "May lead to reduced performance or incorrect "
3177                         "rendering.\n",
3178                         (int)bufmgr_gem->gtt_size / 1024);
3179         }
3180
3181         bufmgr_gem->pci_device = get_pci_device_id(bufmgr_gem);
3182
3183         if (IS_GEN2(bufmgr_gem->pci_device))
3184                 bufmgr_gem->gen = 2;
3185         else if (IS_GEN3(bufmgr_gem->pci_device))
3186                 bufmgr_gem->gen = 3;
3187         else if (IS_GEN4(bufmgr_gem->pci_device))
3188                 bufmgr_gem->gen = 4;
3189         else if (IS_GEN5(bufmgr_gem->pci_device))
3190                 bufmgr_gem->gen = 5;
3191         else if (IS_GEN6(bufmgr_gem->pci_device))
3192                 bufmgr_gem->gen = 6;
3193         else if (IS_GEN7(bufmgr_gem->pci_device))
3194                 bufmgr_gem->gen = 7;
3195         else if (IS_GEN8(bufmgr_gem->pci_device))
3196                 bufmgr_gem->gen = 8;
3197         else if (IS_GEN9(bufmgr_gem->pci_device))
3198                 bufmgr_gem->gen = 9;
3199         else {
3200                 free(bufmgr_gem);
3201                 bufmgr_gem = NULL;
3202                 goto exit;
3203         }
3204
3205         if (IS_GEN3(bufmgr_gem->pci_device) &&
3206             bufmgr_gem->gtt_size > 256*1024*1024) {
3207                 /* The unmappable part of gtt on gen 3 (i.e. above 256MB) can't
3208                  * be used for tiled blits. To simplify the accounting, just
3209                  * substract the unmappable part (fixed to 256MB on all known
3210                  * gen3 devices) if the kernel advertises it. */
3211                 bufmgr_gem->gtt_size -= 256*1024*1024;
3212         }
3213
3214         memclear(gp);
3215         gp.value = &tmp;
3216
3217         gp.param = I915_PARAM_HAS_EXECBUF2;
3218         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3219         if (!ret)
3220                 exec2 = true;
3221
3222         gp.param = I915_PARAM_HAS_BSD;
3223         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3224         bufmgr_gem->has_bsd = ret == 0;
3225
3226         gp.param = I915_PARAM_HAS_BLT;
3227         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3228         bufmgr_gem->has_blt = ret == 0;
3229
3230         gp.param = I915_PARAM_HAS_RELAXED_FENCING;
3231         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3232         bufmgr_gem->has_relaxed_fencing = ret == 0;
3233
3234         bufmgr_gem->bufmgr.bo_alloc_userptr = check_bo_alloc_userptr;
3235
3236         gp.param = I915_PARAM_HAS_WAIT_TIMEOUT;
3237         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3238         bufmgr_gem->has_wait_timeout = ret == 0;
3239
3240         gp.param = I915_PARAM_HAS_LLC;
3241         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3242         if (ret != 0) {
3243                 /* Kernel does not supports HAS_LLC query, fallback to GPU
3244                  * generation detection and assume that we have LLC on GEN6/7
3245                  */
3246                 bufmgr_gem->has_llc = (IS_GEN6(bufmgr_gem->pci_device) |
3247                                 IS_GEN7(bufmgr_gem->pci_device));
3248         } else
3249                 bufmgr_gem->has_llc = *gp.value;
3250
3251         gp.param = I915_PARAM_HAS_VEBOX;
3252         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3253         bufmgr_gem->has_vebox = (ret == 0) & (*gp.value > 0);
3254
3255         if (bufmgr_gem->gen < 4) {
3256                 gp.param = I915_PARAM_NUM_FENCES_AVAIL;
3257                 gp.value = &bufmgr_gem->available_fences;
3258                 ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3259                 if (ret) {
3260                         fprintf(stderr, "get fences failed: %d [%d]\n", ret,
3261                                 errno);
3262                         fprintf(stderr, "param: %d, val: %d\n", gp.param,
3263                                 *gp.value);
3264                         bufmgr_gem->available_fences = 0;
3265                 } else {
3266                         /* XXX The kernel reports the total number of fences,
3267                          * including any that may be pinned.
3268                          *
3269                          * We presume that there will be at least one pinned
3270                          * fence for the scanout buffer, but there may be more
3271                          * than one scanout and the user may be manually
3272                          * pinning buffers. Let's move to execbuffer2 and
3273                          * thereby forget the insanity of using fences...
3274                          */
3275                         bufmgr_gem->available_fences -= 2;
3276                         if (bufmgr_gem->available_fences < 0)
3277                                 bufmgr_gem->available_fences = 0;
3278                 }
3279         }
3280
3281         /* Let's go with one relocation per every 2 dwords (but round down a bit
3282          * since a power of two will mean an extra page allocation for the reloc
3283          * buffer).
3284          *
3285          * Every 4 was too few for the blender benchmark.
3286          */
3287         bufmgr_gem->max_relocs = batch_size / sizeof(uint32_t) / 2 - 2;
3288
3289         bufmgr_gem->bufmgr.bo_alloc = drm_intel_gem_bo_alloc;
3290         bufmgr_gem->bufmgr.bo_alloc_for_render =
3291             drm_intel_gem_bo_alloc_for_render;
3292         bufmgr_gem->bufmgr.bo_alloc_tiled = drm_intel_gem_bo_alloc_tiled;
3293         bufmgr_gem->bufmgr.bo_reference = drm_intel_gem_bo_reference;
3294         bufmgr_gem->bufmgr.bo_unreference = drm_intel_gem_bo_unreference;
3295         bufmgr_gem->bufmgr.bo_map = drm_intel_gem_bo_map;
3296         bufmgr_gem->bufmgr.bo_unmap = drm_intel_gem_bo_unmap;
3297         bufmgr_gem->bufmgr.bo_subdata = drm_intel_gem_bo_subdata;
3298         bufmgr_gem->bufmgr.bo_get_subdata = drm_intel_gem_bo_get_subdata;
3299         bufmgr_gem->bufmgr.bo_wait_rendering = drm_intel_gem_bo_wait_rendering;
3300         bufmgr_gem->bufmgr.bo_emit_reloc = drm_intel_gem_bo_emit_reloc;
3301         bufmgr_gem->bufmgr.bo_emit_reloc_fence = drm_intel_gem_bo_emit_reloc_fence;
3302         bufmgr_gem->bufmgr.bo_pin = drm_intel_gem_bo_pin;
3303         bufmgr_gem->bufmgr.bo_unpin = drm_intel_gem_bo_unpin;
3304         bufmgr_gem->bufmgr.bo_get_tiling = drm_intel_gem_bo_get_tiling;
3305         bufmgr_gem->bufmgr.bo_set_tiling = drm_intel_gem_bo_set_tiling;
3306         bufmgr_gem->bufmgr.bo_flink = drm_intel_gem_bo_flink;
3307         /* Use the new one if available */
3308         if (exec2) {
3309                 bufmgr_gem->bufmgr.bo_exec = drm_intel_gem_bo_exec2;
3310                 bufmgr_gem->bufmgr.bo_mrb_exec = drm_intel_gem_bo_mrb_exec2;
3311         } else
3312                 bufmgr_gem->bufmgr.bo_exec = drm_intel_gem_bo_exec;
3313         bufmgr_gem->bufmgr.bo_busy = drm_intel_gem_bo_busy;
3314         bufmgr_gem->bufmgr.bo_madvise = drm_intel_gem_bo_madvise;
3315         bufmgr_gem->bufmgr.destroy = drm_intel_bufmgr_gem_unref;
3316         bufmgr_gem->bufmgr.debug = 0;
3317         bufmgr_gem->bufmgr.check_aperture_space =
3318             drm_intel_gem_check_aperture_space;
3319         bufmgr_gem->bufmgr.bo_disable_reuse = drm_intel_gem_bo_disable_reuse;
3320         bufmgr_gem->bufmgr.bo_is_reusable = drm_intel_gem_bo_is_reusable;
3321         bufmgr_gem->bufmgr.get_pipe_from_crtc_id =
3322             drm_intel_gem_get_pipe_from_crtc_id;
3323         bufmgr_gem->bufmgr.bo_references = drm_intel_gem_bo_references;
3324
3325         DRMINITLISTHEAD(&bufmgr_gem->named);
3326         init_cache_buckets(bufmgr_gem);
3327
3328         DRMINITLISTHEAD(&bufmgr_gem->vma_cache);
3329         bufmgr_gem->vma_max = -1; /* unlimited by default */
3330
3331         DRMLISTADD(&bufmgr_gem->managers, &bufmgr_list);
3332
3333 exit:
3334         pthread_mutex_unlock(&bufmgr_list_mutex);
3335
3336         return bufmgr_gem != NULL ? &bufmgr_gem->bufmgr : NULL;
3337 }