intel/intel_bufmgr_gem.c

   1 /**************************************************************************
   2  *
   3  * Copyright © 2007 Red Hat Inc.
   4  * Copyright © 2007 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/mman.h>
  52 #include <sys/stat.h>
  53 #include <sys/types.h>
  54 #include <stdbool.h>
  55
  56 #include "errno.h"
  57 #include "libdrm_lists.h"
  58 #include "intel_bufmgr.h"
  59 #include "intel_bufmgr_priv.h"
  60 #include "intel_chipset.h"
  61 #include "string.h"
  62
  63 #include "i915_drm.h"
  64
  65 #define DBG(...) do {                                   \
  66         if (bufmgr_gem->bufmgr.debug)                   \
  67                 fprintf(stderr, __VA_ARGS__);           \
  68 } while (0)
  69
  70 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
  71
  72 typedef struct _drm_intel_bo_gem drm_intel_bo_gem;
  73
  74 struct drm_intel_gem_bo_bucket {
  75         drmMMListHead head;
  76         unsigned long size;
  77 };
  78
  79 typedef struct _drm_intel_bufmgr_gem {
  80         drm_intel_bufmgr bufmgr;
  81
  82         int fd;
  83
  84         int max_relocs;
  85
  86         pthread_mutex_t lock;
  87
  88         struct drm_i915_gem_exec_object *exec_objects;
  89         struct drm_i915_gem_exec_object2 *exec2_objects;
  90         drm_intel_bo **exec_bos;
  91         int exec_size;
  92         int exec_count;
  93
  94         /** Array of lists of cached gem objects of power-of-two sizes */
  95         struct drm_intel_gem_bo_bucket cache_bucket[14 * 4];
  96         int num_buckets;
  97         time_t time;
  98
  99         drmMMListHead named;
 100         drmMMListHead vma_cache;
 101         int vma_count, vma_open, vma_max;
 102
 103         uint64_t gtt_size;
 104         int available_fences;
 105         int pci_device;
 106         int gen;
 107         unsigned int has_bsd : 1;
 108         unsigned int has_blt : 1;
 109         unsigned int has_relaxed_fencing : 1;
 110         unsigned int bo_reuse : 1;
 111         bool fenced_relocs;
 112 } drm_intel_bufmgr_gem;
 113
 114 #define DRM_INTEL_RELOC_FENCE (1<<0)
 115
 116 typedef struct _drm_intel_reloc_target_info {
 117         drm_intel_bo *bo;
 118         int flags;
 119 } drm_intel_reloc_target;
 120
 121 struct _drm_intel_bo_gem {
 122         drm_intel_bo bo;
 123
 124         atomic_t refcount;
 125         uint32_t gem_handle;
 126         const char *name;
 127
 128         /**
 129          * Kenel-assigned global name for this object
 130          */
 131         unsigned int global_name;
 132         drmMMListHead name_list;
 133
 134         /**
 135          * Index of the buffer within the validation list while preparing a
 136          * batchbuffer execution.
 137          */
 138         int validate_index;
 139
 140         /**
 141          * Current tiling mode
 142          */
 143         uint32_t tiling_mode;
 144         uint32_t swizzle_mode;
 145         unsigned long stride;
 146
 147         time_t free_time;
 148
 149         /** Array passed to the DRM containing relocation information. */
 150         struct drm_i915_gem_relocation_entry *relocs;
 151         /**
 152          * Array of info structs corresponding to relocs[i].target_handle etc
 153          */
 154         drm_intel_reloc_target *reloc_target_info;
 155         /** Number of entries in relocs */
 156         int reloc_count;
 157         /** Mapped address for the buffer, saved across map/unmap cycles */
 158         void *mem_virtual;
 159         /** GTT virtual address for the buffer, saved across map/unmap cycles */
 160         void *gtt_virtual;
 161         int map_count;
 162         drmMMListHead vma_list;
 163
 164         /** BO cache list */
 165         drmMMListHead head;
 166
 167         /**
 168          * Boolean of whether this BO and its children have been included in
 169          * the current drm_intel_bufmgr_check_aperture_space() total.
 170          */
 171         bool included_in_check_aperture;
 172
 173         /**
 174          * Boolean of whether this buffer has been used as a relocation
 175          * target and had its size accounted for, and thus can't have any
 176          * further relocations added to it.
 177          */
 178         bool used_as_reloc_target;
 179
 180         /**
 181          * Boolean of whether we have encountered an error whilst building the relocation tree.
 182          */
 183         bool has_error;
 184
 185         /**
 186          * Boolean of whether this buffer can be re-used
 187          */
 188         bool reusable;
 189
 190         /**
 191          * Size in bytes of this buffer and its relocation descendents.
 192          *
 193          * Used to avoid costly tree walking in
 194          * drm_intel_bufmgr_check_aperture in the common case.
 195          */
 196         int reloc_tree_size;
 197
 198         /**
 199          * Number of potential fence registers required by this buffer and its
 200          * relocations.
 201          */
 202         int reloc_tree_fences;
 203
 204         /** Flags that we may need to do the SW_FINSIH ioctl on unmap. */
 205         bool mapped_cpu_write;
 206 };
 207
 208 static unsigned int
 209 drm_intel_gem_estimate_batch_space(drm_intel_bo ** bo_array, int count);
 210
 211 static unsigned int
 212 drm_intel_gem_compute_batch_space(drm_intel_bo ** bo_array, int count);
 213
 214 static int
 215 drm_intel_gem_bo_get_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
 216                             uint32_t * swizzle_mode);
 217
 218 static int
 219 drm_intel_gem_bo_set_tiling_internal(drm_intel_bo *bo,
 220                                      uint32_t tiling_mode,
 221                                      uint32_t stride);
 222
 223 static void drm_intel_gem_bo_unreference_locked_timed(drm_intel_bo *bo,
 224                                                       time_t time);
 225
 226 static void drm_intel_gem_bo_unreference(drm_intel_bo *bo);
 227
 228 static void drm_intel_gem_bo_free(drm_intel_bo *bo);
 229
 230 static unsigned long
 231 drm_intel_gem_bo_tile_size(drm_intel_bufmgr_gem *bufmgr_gem, unsigned long size,
 232                            uint32_t *tiling_mode)
 233 {
 234         unsigned long min_size, max_size;
 235         unsigned long i;
 236
 237         if (*tiling_mode == I915_TILING_NONE)
 238                 return size;
 239
 240         /* 965+ just need multiples of page size for tiling */
 241         if (bufmgr_gem->gen >= 4)
 242                 return ROUND_UP_TO(size, 4096);
 243
 244         /* Older chips need powers of two, of at least 512k or 1M */
 245         if (bufmgr_gem->gen == 3) {
 246                 min_size = 1024*1024;
 247                 max_size = 128*1024*1024;
 248         } else {
 249                 min_size = 512*1024;
 250                 max_size = 64*1024*1024;
 251         }
 252
 253         if (size > max_size) {
 254                 *tiling_mode = I915_TILING_NONE;
 255                 return size;
 256         }
 257
 258         /* Do we need to allocate every page for the fence? */
 259         if (bufmgr_gem->has_relaxed_fencing)
 260                 return ROUND_UP_TO(size, 4096);
 261
 262         for (i = min_size; i < size; i <<= 1)
 263                 ;
 264
 265         return i;
 266 }
 267
 268 /*
 269  * Round a given pitch up to the minimum required for X tiling on a
 270  * given chip.  We use 512 as the minimum to allow for a later tiling
 271  * change.
 272  */
 273 static unsigned long
 274 drm_intel_gem_bo_tile_pitch(drm_intel_bufmgr_gem *bufmgr_gem,
 275                             unsigned long pitch, uint32_t *tiling_mode)
 276 {
 277         unsigned long tile_width;
 278         unsigned long i;
 279
 280         /* If untiled, then just align it so that we can do rendering
 281          * to it with the 3D engine.
 282          */
 283         if (*tiling_mode == I915_TILING_NONE)
 284                 return ALIGN(pitch, 64);
 285
 286         if (*tiling_mode == I915_TILING_X
 287                         || (IS_915(bufmgr_gem) && *tiling_mode == I915_TILING_Y))
 288                 tile_width = 512;
 289         else
 290                 tile_width = 128;
 291
 292         /* 965 is flexible */
 293         if (bufmgr_gem->gen >= 4)
 294                 return ROUND_UP_TO(pitch, tile_width);
 295
 296         /* The older hardware has a maximum pitch of 8192 with tiled
 297          * surfaces, so fallback to untiled if it's too large.
 298          */
 299         if (pitch > 8192) {
 300                 *tiling_mode = I915_TILING_NONE;
 301                 return ALIGN(pitch, 64);
 302         }
 303
 304         /* Pre-965 needs power of two tile width */
 305         for (i = tile_width; i < pitch; i <<= 1)
 306                 ;
 307
 308         return i;
 309 }
 310
 311 static struct drm_intel_gem_bo_bucket *
 312 drm_intel_gem_bo_bucket_for_size(drm_intel_bufmgr_gem *bufmgr_gem,
 313                                  unsigned long size)
 314 {
 315         int i;
 316
 317         for (i = 0; i < bufmgr_gem->num_buckets; i++) {
 318                 struct drm_intel_gem_bo_bucket *bucket =
 319                     &bufmgr_gem->cache_bucket[i];
 320                 if (bucket->size >= size) {
 321                         return bucket;
 322                 }
 323         }
 324
 325         return NULL;
 326 }
 327
 328 static void
 329 drm_intel_gem_dump_validation_list(drm_intel_bufmgr_gem *bufmgr_gem)
 330 {
 331         int i, j;
 332
 333         for (i = 0; i < bufmgr_gem->exec_count; i++) {
 334                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
 335                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 336
 337                 if (bo_gem->relocs == NULL) {
 338                         DBG("%2d: %d (%s)\n", i, bo_gem->gem_handle,
 339                             bo_gem->name);
 340                         continue;
 341                 }
 342
 343                 for (j = 0; j < bo_gem->reloc_count; j++) {
 344                         drm_intel_bo *target_bo = bo_gem->reloc_target_info[j].bo;
 345                         drm_intel_bo_gem *target_gem =
 346                             (drm_intel_bo_gem *) target_bo;
 347
 348                         DBG("%2d: %d (%s)@0x%08llx -> "
 349                             "%d (%s)@0x%08lx + 0x%08x\n",
 350                             i,
 351                             bo_gem->gem_handle, bo_gem->name,
 352                             (unsigned long long)bo_gem->relocs[j].offset,
 353                             target_gem->gem_handle,
 354                             target_gem->name,
 355                             target_bo->offset,
 356                             bo_gem->relocs[j].delta);
 357                 }
 358         }
 359 }
 360
 361 static inline void
 362 drm_intel_gem_bo_reference(drm_intel_bo *bo)
 363 {
 364         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 365
 366         atomic_inc(&bo_gem->refcount);
 367 }
 368
 369 /**
 370  * Adds the given buffer to the list of buffers to be validated (moved into the
 371  * appropriate memory type) with the next batch submission.
 372  *
 373  * If a buffer is validated multiple times in a batch submission, it ends up
 374  * with the intersection of the memory type flags and the union of the
 375  * access flags.
 376  */
 377 static void
 378 drm_intel_add_validate_buffer(drm_intel_bo *bo)
 379 {
 380         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 381         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 382         int index;
 383
 384         if (bo_gem->validate_index != -1)
 385                 return;
 386
 387         /* Extend the array of validation entries as necessary. */
 388         if (bufmgr_gem->exec_count == bufmgr_gem->exec_size) {
 389                 int new_size = bufmgr_gem->exec_size * 2;
 390
 391                 if (new_size == 0)
 392                         new_size = 5;
 393
 394                 bufmgr_gem->exec_objects =
 395                     realloc(bufmgr_gem->exec_objects,
 396                             sizeof(*bufmgr_gem->exec_objects) * new_size);
 397                 bufmgr_gem->exec_bos =
 398                     realloc(bufmgr_gem->exec_bos,
 399                             sizeof(*bufmgr_gem->exec_bos) * new_size);
 400                 bufmgr_gem->exec_size = new_size;
 401         }
 402
 403         index = bufmgr_gem->exec_count;
 404         bo_gem->validate_index = index;
 405         /* Fill in array entry */
 406         bufmgr_gem->exec_objects[index].handle = bo_gem->gem_handle;
 407         bufmgr_gem->exec_objects[index].relocation_count = bo_gem->reloc_count;
 408         bufmgr_gem->exec_objects[index].relocs_ptr = (uintptr_t) bo_gem->relocs;
 409         bufmgr_gem->exec_objects[index].alignment = 0;
 410         bufmgr_gem->exec_objects[index].offset = 0;
 411         bufmgr_gem->exec_bos[index] = bo;
 412         bufmgr_gem->exec_count++;
 413 }
 414
 415 static void
 416 drm_intel_add_validate_buffer2(drm_intel_bo *bo, int need_fence)
 417 {
 418         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 419         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 420         int index;
 421
 422         if (bo_gem->validate_index != -1) {
 423                 if (need_fence)
 424                         bufmgr_gem->exec2_objects[bo_gem->validate_index].flags |=
 425                                 EXEC_OBJECT_NEEDS_FENCE;
 426                 return;
 427         }
 428
 429         /* Extend the array of validation entries as necessary. */
 430         if (bufmgr_gem->exec_count == bufmgr_gem->exec_size) {
 431                 int new_size = bufmgr_gem->exec_size * 2;
 432
 433                 if (new_size == 0)
 434                         new_size = 5;
 435
 436                 bufmgr_gem->exec2_objects =
 437                         realloc(bufmgr_gem->exec2_objects,
 438                                 sizeof(*bufmgr_gem->exec2_objects) * new_size);
 439                 bufmgr_gem->exec_bos =
 440                         realloc(bufmgr_gem->exec_bos,
 441                                 sizeof(*bufmgr_gem->exec_bos) * new_size);
 442                 bufmgr_gem->exec_size = new_size;
 443         }
 444
 445         index = bufmgr_gem->exec_count;
 446         bo_gem->validate_index = index;
 447         /* Fill in array entry */
 448         bufmgr_gem->exec2_objects[index].handle = bo_gem->gem_handle;
 449         bufmgr_gem->exec2_objects[index].relocation_count = bo_gem->reloc_count;
 450         bufmgr_gem->exec2_objects[index].relocs_ptr = (uintptr_t)bo_gem->relocs;
 451         bufmgr_gem->exec2_objects[index].alignment = 0;
 452         bufmgr_gem->exec2_objects[index].offset = 0;
 453         bufmgr_gem->exec_bos[index] = bo;
 454         bufmgr_gem->exec2_objects[index].flags = 0;
 455         bufmgr_gem->exec2_objects[index].rsvd1 = 0;
 456         bufmgr_gem->exec2_objects[index].rsvd2 = 0;
 457         if (need_fence) {
 458                 bufmgr_gem->exec2_objects[index].flags |=
 459                         EXEC_OBJECT_NEEDS_FENCE;
 460         }
 461         bufmgr_gem->exec_count++;
 462 }
 463
 464 #define RELOC_BUF_SIZE(x) ((I915_RELOC_HEADER + x * I915_RELOC0_STRIDE) * \
 465         sizeof(uint32_t))
 466
 467 static void
 468 drm_intel_bo_gem_set_in_aperture_size(drm_intel_bufmgr_gem *bufmgr_gem,
 469                                       drm_intel_bo_gem *bo_gem)
 470 {
 471         int size;
 472
 473         assert(!bo_gem->used_as_reloc_target);
 474
 475         /* The older chipsets are far-less flexible in terms of tiling,
 476          * and require tiled buffer to be size aligned in the aperture.
 477          * This means that in the worst possible case we will need a hole
 478          * twice as large as the object in order for it to fit into the
 479          * aperture. Optimal packing is for wimps.
 480          */
 481         size = bo_gem->bo.size;
 482         if (bufmgr_gem->gen < 4 && bo_gem->tiling_mode != I915_TILING_NONE) {
 483                 int min_size;
 484
 485                 if (bufmgr_gem->has_relaxed_fencing) {
 486                         if (bufmgr_gem->gen == 3)
 487                                 min_size = 1024*1024;
 488                         else
 489                                 min_size = 512*1024;
 490
 491                         while (min_size < size)
 492                                 min_size *= 2;
 493                 } else
 494                         min_size = size;
 495
 496                 /* Account for worst-case alignment. */
 497                 size = 2 * min_size;
 498         }
 499
 500         bo_gem->reloc_tree_size = size;
 501 }
 502
 503 static int
 504 drm_intel_setup_reloc_list(drm_intel_bo *bo)
 505 {
 506         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 507         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 508         unsigned int max_relocs = bufmgr_gem->max_relocs;
 509
 510         if (bo->size / 4 < max_relocs)
 511                 max_relocs = bo->size / 4;
 512
 513         bo_gem->relocs = malloc(max_relocs *
 514                                 sizeof(struct drm_i915_gem_relocation_entry));
 515         bo_gem->reloc_target_info = malloc(max_relocs *
 516                                            sizeof(drm_intel_reloc_target));
 517         if (bo_gem->relocs == NULL || bo_gem->reloc_target_info == NULL) {
 518                 bo_gem->has_error = true;
 519
 520                 free (bo_gem->relocs);
 521                 bo_gem->relocs = NULL;
 522
 523                 free (bo_gem->reloc_target_info);
 524                 bo_gem->reloc_target_info = NULL;
 525
 526                 return 1;
 527         }
 528
 529         return 0;
 530 }
 531
 532 static int
 533 drm_intel_gem_bo_busy(drm_intel_bo *bo)
 534 {
 535         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 536         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 537         struct drm_i915_gem_busy busy;
 538         int ret;
 539
 540         memset(&busy, 0, sizeof(busy));
 541         busy.handle = bo_gem->gem_handle;
 542
 543         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_BUSY, &busy);
 544
 545         return (ret == 0 && busy.busy);
 546 }
 547
 548 static int
 549 drm_intel_gem_bo_madvise_internal(drm_intel_bufmgr_gem *bufmgr_gem,
 550                                   drm_intel_bo_gem *bo_gem, int state)
 551 {
 552         struct drm_i915_gem_madvise madv;
 553
 554         madv.handle = bo_gem->gem_handle;
 555         madv.madv = state;
 556         madv.retained = 1;
 557         drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_MADVISE, &madv);
 558
 559         return madv.retained;
 560 }
 561
 562 static int
 563 drm_intel_gem_bo_madvise(drm_intel_bo *bo, int madv)
 564 {
 565         return drm_intel_gem_bo_madvise_internal
 566                 ((drm_intel_bufmgr_gem *) bo->bufmgr,
 567                  (drm_intel_bo_gem *) bo,
 568                  madv);
 569 }
 570
 571 /* drop the oldest entries that have been purged by the kernel */
 572 static void
 573 drm_intel_gem_bo_cache_purge_bucket(drm_intel_bufmgr_gem *bufmgr_gem,
 574                                     struct drm_intel_gem_bo_bucket *bucket)
 575 {
 576         while (!DRMLISTEMPTY(&bucket->head)) {
 577                 drm_intel_bo_gem *bo_gem;
 578
 579                 bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
 580                                       bucket->head.next, head);
 581                 if (drm_intel_gem_bo_madvise_internal
 582                     (bufmgr_gem, bo_gem, I915_MADV_DONTNEED))
 583                         break;
 584
 585                 DRMLISTDEL(&bo_gem->head);
 586                 drm_intel_gem_bo_free(&bo_gem->bo);
 587         }
 588 }
 589
 590 static drm_intel_bo *
 591 drm_intel_gem_bo_alloc_internal(drm_intel_bufmgr *bufmgr,
 592                                 const char *name,
 593                                 unsigned long size,
 594                                 unsigned long flags,
 595                                 uint32_t tiling_mode,
 596                                 unsigned long stride)
 597 {
 598         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
 599         drm_intel_bo_gem *bo_gem;
 600         unsigned int page_size = getpagesize();
 601         int ret;
 602         struct drm_intel_gem_bo_bucket *bucket;
 603         bool alloc_from_cache;
 604         unsigned long bo_size;
 605         bool for_render = false;
 606
 607         if (flags & BO_ALLOC_FOR_RENDER)
 608                 for_render = true;
 609
 610         /* Round the allocated size up to a power of two number of pages. */
 611         bucket = drm_intel_gem_bo_bucket_for_size(bufmgr_gem, size);
 612
 613         /* If we don't have caching at this size, don't actually round the
 614          * allocation up.
 615          */
 616         if (bucket == NULL) {
 617                 bo_size = size;
 618                 if (bo_size < page_size)
 619                         bo_size = page_size;
 620         } else {
 621                 bo_size = bucket->size;
 622         }
 623
 624         pthread_mutex_lock(&bufmgr_gem->lock);
 625         /* Get a buffer out of the cache if available */
 626 retry:
 627         alloc_from_cache = false;
 628         if (bucket != NULL && !DRMLISTEMPTY(&bucket->head)) {
 629                 if (for_render) {
 630                         /* Allocate new render-target BOs from the tail (MRU)
 631                          * of the list, as it will likely be hot in the GPU
 632                          * cache and in the aperture for us.
 633                          */
 634                         bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
 635                                               bucket->head.prev, head);
 636                         DRMLISTDEL(&bo_gem->head);
 637                         alloc_from_cache = true;
 638                 } else {
 639                         /* For non-render-target BOs (where we're probably
 640                          * going to map it first thing in order to fill it
 641                          * with data), check if the last BO in the cache is
 642                          * unbusy, and only reuse in that case. Otherwise,
 643                          * allocating a new buffer is probably faster than
 644                          * waiting for the GPU to finish.
 645                          */
 646                         bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
 647                                               bucket->head.next, head);
 648                         if (!drm_intel_gem_bo_busy(&bo_gem->bo)) {
 649                                 alloc_from_cache = true;
 650                                 DRMLISTDEL(&bo_gem->head);
 651                         }
 652                 }
 653
 654                 if (alloc_from_cache) {
 655                         if (!drm_intel_gem_bo_madvise_internal
 656                             (bufmgr_gem, bo_gem, I915_MADV_WILLNEED)) {
 657                                 drm_intel_gem_bo_free(&bo_gem->bo);
 658                                 drm_intel_gem_bo_cache_purge_bucket(bufmgr_gem,
 659                                                                     bucket);
 660                                 goto retry;
 661                         }
 662
 663                         if (drm_intel_gem_bo_set_tiling_internal(&bo_gem->bo,
 664                                                                  tiling_mode,
 665                                                                  stride)) {
 666                                 drm_intel_gem_bo_free(&bo_gem->bo);
 667                                 goto retry;
 668                         }
 669                 }
 670         }
 671         pthread_mutex_unlock(&bufmgr_gem->lock);
 672
 673         if (!alloc_from_cache) {
 674                 struct drm_i915_gem_create create;
 675
 676                 bo_gem = calloc(1, sizeof(*bo_gem));
 677                 if (!bo_gem)
 678                         return NULL;
 679
 680                 bo_gem->bo.size = bo_size;
 681                 memset(&create, 0, sizeof(create));
 682                 create.size = bo_size;
 683
 684                 ret = drmIoctl(bufmgr_gem->fd,
 685                                DRM_IOCTL_I915_GEM_CREATE,
 686                                &create);
 687                 bo_gem->gem_handle = create.handle;
 688                 bo_gem->bo.handle = bo_gem->gem_handle;
 689                 if (ret != 0) {
 690                         free(bo_gem);
 691                         return NULL;
 692                 }
 693                 bo_gem->bo.bufmgr = bufmgr;
 694
 695                 bo_gem->tiling_mode = I915_TILING_NONE;
 696                 bo_gem->swizzle_mode = I915_BIT_6_SWIZZLE_NONE;
 697                 bo_gem->stride = 0;
 698
 699                 if (drm_intel_gem_bo_set_tiling_internal(&bo_gem->bo,
 700                                                          tiling_mode,
 701                                                          stride)) {
 702                     drm_intel_gem_bo_free(&bo_gem->bo);
 703                     return NULL;
 704                 }
 705
 706                 DRMINITLISTHEAD(&bo_gem->name_list);
 707                 DRMINITLISTHEAD(&bo_gem->vma_list);
 708         }
 709
 710         bo_gem->name = name;
 711         atomic_set(&bo_gem->refcount, 1);
 712         bo_gem->validate_index = -1;
 713         bo_gem->reloc_tree_fences = 0;
 714         bo_gem->used_as_reloc_target = false;
 715         bo_gem->has_error = false;
 716         bo_gem->reusable = true;
 717
 718         drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem);
 719
 720         DBG("bo_create: buf %d (%s) %ldb\n",
 721             bo_gem->gem_handle, bo_gem->name, size);
 722
 723         return &bo_gem->bo;
 724 }
 725
 726 static drm_intel_bo *
 727 drm_intel_gem_bo_alloc_for_render(drm_intel_bufmgr *bufmgr,
 728                                   const char *name,
 729                                   unsigned long size,
 730                                   unsigned int alignment)
 731 {
 732         return drm_intel_gem_bo_alloc_internal(bufmgr, name, size,
 733                                                BO_ALLOC_FOR_RENDER,
 734                                                I915_TILING_NONE, 0);
 735 }
 736
 737 static drm_intel_bo *
 738 drm_intel_gem_bo_alloc(drm_intel_bufmgr *bufmgr,
 739                        const char *name,
 740                        unsigned long size,
 741                        unsigned int alignment)
 742 {
 743         return drm_intel_gem_bo_alloc_internal(bufmgr, name, size, 0,
 744                                                I915_TILING_NONE, 0);
 745 }
 746
 747 static drm_intel_bo *
 748 drm_intel_gem_bo_alloc_tiled(drm_intel_bufmgr *bufmgr, const char *name,
 749                              int x, int y, int cpp, uint32_t *tiling_mode,
 750                              unsigned long *pitch, unsigned long flags)
 751 {
 752         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
 753         unsigned long size, stride;
 754         uint32_t tiling;
 755
 756         do {
 757                 unsigned long aligned_y, height_alignment;
 758
 759                 tiling = *tiling_mode;
 760
 761                 /* If we're tiled, our allocations are in 8 or 32-row blocks,
 762                  * so failure to align our height means that we won't allocate
 763                  * enough pages.
 764                  *
 765                  * If we're untiled, we still have to align to 2 rows high
 766                  * because the data port accesses 2x2 blocks even if the
 767                  * bottom row isn't to be rendered, so failure to align means
 768                  * we could walk off the end of the GTT and fault.  This is
 769                  * documented on 965, and may be the case on older chipsets
 770                  * too so we try to be careful.
 771                  */
 772                 aligned_y = y;
 773                 height_alignment = 2;
 774
 775                 if (IS_GEN2(bufmgr_gem) && tiling != I915_TILING_NONE)
 776                         height_alignment = 16;
 777                 else if (tiling == I915_TILING_X
 778                         || (IS_915(bufmgr_gem) && tiling == I915_TILING_Y))
 779                         height_alignment = 8;
 780                 else if (tiling == I915_TILING_Y)
 781                         height_alignment = 32;
 782                 aligned_y = ALIGN(y, height_alignment);
 783
 784                 stride = x * cpp;
 785                 stride = drm_intel_gem_bo_tile_pitch(bufmgr_gem, stride, tiling_mode);
 786                 size = stride * aligned_y;
 787                 size = drm_intel_gem_bo_tile_size(bufmgr_gem, size, tiling_mode);
 788         } while (*tiling_mode != tiling);
 789         *pitch = stride;
 790
 791         if (tiling == I915_TILING_NONE)
 792                 stride = 0;
 793
 794         return drm_intel_gem_bo_alloc_internal(bufmgr, name, size, flags,
 795                                                tiling, stride);
 796 }
 797
 798 /**
 799  * Returns a drm_intel_bo wrapping the given buffer object handle.
 800  *
 801  * This can be used when one application needs to pass a buffer object
 802  * to another.
 803  */
 804 drm_intel_bo *
 805 drm_intel_bo_gem_create_from_name(drm_intel_bufmgr *bufmgr,
 806                                   const char *name,
 807                                   unsigned int handle)
 808 {
 809         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
 810         drm_intel_bo_gem *bo_gem;
 811         int ret;
 812         struct drm_gem_open open_arg;
 813         struct drm_i915_gem_get_tiling get_tiling;
 814         drmMMListHead *list;
 815
 816         /* At the moment most applications only have a few named bo.
 817          * For instance, in a DRI client only the render buffers passed
 818          * between X and the client are named. And since X returns the
 819          * alternating names for the front/back buffer a linear search
 820          * provides a sufficiently fast match.
 821          */
 822         for (list = bufmgr_gem->named.next;
 823              list != &bufmgr_gem->named;
 824              list = list->next) {
 825                 bo_gem = DRMLISTENTRY(drm_intel_bo_gem, list, name_list);
 826                 if (bo_gem->global_name == handle) {
 827                         drm_intel_gem_bo_reference(&bo_gem->bo);
 828                         return &bo_gem->bo;
 829                 }
 830         }
 831
 832         bo_gem = calloc(1, sizeof(*bo_gem));
 833         if (!bo_gem)
 834                 return NULL;
 835
 836         memset(&open_arg, 0, sizeof(open_arg));
 837         open_arg.name = handle;
 838         ret = drmIoctl(bufmgr_gem->fd,
 839                        DRM_IOCTL_GEM_OPEN,
 840                        &open_arg);
 841         if (ret != 0) {
 842                 DBG("Couldn't reference %s handle 0x%08x: %s\n",
 843                     name, handle, strerror(errno));
 844                 free(bo_gem);
 845                 return NULL;
 846         }
 847         bo_gem->bo.size = open_arg.size;
 848         bo_gem->bo.offset = 0;
 849         bo_gem->bo.virtual = NULL;
 850         bo_gem->bo.bufmgr = bufmgr;
 851         bo_gem->name = name;
 852         atomic_set(&bo_gem->refcount, 1);
 853         bo_gem->validate_index = -1;
 854         bo_gem->gem_handle = open_arg.handle;
 855         bo_gem->bo.handle = open_arg.handle;
 856         bo_gem->global_name = handle;
 857         bo_gem->reusable = false;
 858
 859         memset(&get_tiling, 0, sizeof(get_tiling));
 860         get_tiling.handle = bo_gem->gem_handle;
 861         ret = drmIoctl(bufmgr_gem->fd,
 862                        DRM_IOCTL_I915_GEM_GET_TILING,
 863                        &get_tiling);
 864         if (ret != 0) {
 865                 drm_intel_gem_bo_unreference(&bo_gem->bo);
 866                 return NULL;
 867         }
 868         bo_gem->tiling_mode = get_tiling.tiling_mode;
 869         bo_gem->swizzle_mode = get_tiling.swizzle_mode;
 870         /* XXX stride is unknown */
 871         drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem);
 872
 873         DRMINITLISTHEAD(&bo_gem->vma_list);
 874         DRMLISTADDTAIL(&bo_gem->name_list, &bufmgr_gem->named);
 875         DBG("bo_create_from_handle: %d (%s)\n", handle, bo_gem->name);
 876
 877         return &bo_gem->bo;
 878 }
 879
 880 static void
 881 drm_intel_gem_bo_free(drm_intel_bo *bo)
 882 {
 883         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
 884         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
 885         struct drm_gem_close close;
 886         int ret;
 887
 888         DRMLISTDEL(&bo_gem->vma_list);
 889         if (bo_gem->mem_virtual) {
 890                 munmap(bo_gem->mem_virtual, bo_gem->bo.size);
 891                 bufmgr_gem->vma_count--;
 892         }
 893         if (bo_gem->gtt_virtual) {
 894                 munmap(bo_gem->gtt_virtual, bo_gem->bo.size);
 895                 bufmgr_gem->vma_count--;
 896         }
 897
 898         /* Close this object */
 899         memset(&close, 0, sizeof(close));
 900         close.handle = bo_gem->gem_handle;
 901         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_GEM_CLOSE, &close);
 902         if (ret != 0) {
 903                 DBG("DRM_IOCTL_GEM_CLOSE %d failed (%s): %s\n",
 904                     bo_gem->gem_handle, bo_gem->name, strerror(errno));
 905         }
 906         free(bo);
 907 }
 908
 909 /** Frees all cached buffers significantly older than @time. */
 910 static void
 911 drm_intel_gem_cleanup_bo_cache(drm_intel_bufmgr_gem *bufmgr_gem, time_t time)
 912 {
 913         int i;
 914
 915         if (bufmgr_gem->time == time)
 916                 return;
 917
 918         for (i = 0; i < bufmgr_gem->num_buckets; i++) {
 919                 struct drm_intel_gem_bo_bucket *bucket =
 920                     &bufmgr_gem->cache_bucket[i];
 921
 922                 while (!DRMLISTEMPTY(&bucket->head)) {
 923                         drm_intel_bo_gem *bo_gem;
 924
 925                         bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
 926                                               bucket->head.next, head);
 927                         if (time - bo_gem->free_time <= 1)
 928                                 break;
 929
 930                         DRMLISTDEL(&bo_gem->head);
 931
 932                         drm_intel_gem_bo_free(&bo_gem->bo);
 933                 }
 934         }
 935
 936         bufmgr_gem->time = time;
 937 }
 938
 939 static void drm_intel_gem_bo_purge_vma_cache(drm_intel_bufmgr_gem *bufmgr_gem)
 940 {
 941         int limit;
 942
 943         DBG("%s: cached=%d, open=%d, limit=%d\n", __FUNCTION__,
 944             bufmgr_gem->vma_count, bufmgr_gem->vma_open, bufmgr_gem->vma_max);
 945
 946         if (bufmgr_gem->vma_max < 0)
 947                 return;
 948
 949         /* We may need to evict a few entries in order to create new mmaps */
 950         limit = bufmgr_gem->vma_max - 2*bufmgr_gem->vma_open;
 951         if (limit < 0)
 952                 limit = 0;
 953
 954         while (bufmgr_gem->vma_count > limit) {
 955                 drm_intel_bo_gem *bo_gem;
 956
 957                 bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
 958                                       bufmgr_gem->vma_cache.next,
 959                                       vma_list);
 960                 assert(bo_gem->map_count == 0);
 961                 DRMLISTDEL(&bo_gem->vma_list);
 962
 963                 if (bo_gem->mem_virtual) {
 964                         munmap(bo_gem->mem_virtual, bo_gem->bo.size);
 965                         bo_gem->mem_virtual = NULL;
 966                         bufmgr_gem->vma_count--;
 967                 }
 968                 if (bo_gem->gtt_virtual) {
 969                         munmap(bo_gem->gtt_virtual, bo_gem->bo.size);
 970                         bo_gem->gtt_virtual = NULL;
 971                         bufmgr_gem->vma_count--;
 972                 }
 973         }
 974 }
 975
 976 static void drm_intel_gem_bo_close_vma(drm_intel_bufmgr_gem *bufmgr_gem,
 977                                        drm_intel_bo_gem *bo_gem)
 978 {
 979         bufmgr_gem->vma_open--;
 980         DRMLISTADDTAIL(&bo_gem->vma_list, &bufmgr_gem->vma_cache);
 981         if (bo_gem->mem_virtual)
 982                 bufmgr_gem->vma_count++;
 983         if (bo_gem->gtt_virtual)
 984                 bufmgr_gem->vma_count++;
 985         drm_intel_gem_bo_purge_vma_cache(bufmgr_gem);
 986 }
 987
 988 static void drm_intel_gem_bo_open_vma(drm_intel_bufmgr_gem *bufmgr_gem,
 989                                       drm_intel_bo_gem *bo_gem)
 990 {
 991         bufmgr_gem->vma_open++;
 992         DRMLISTDEL(&bo_gem->vma_list);
 993         if (bo_gem->mem_virtual)
 994                 bufmgr_gem->vma_count--;
 995         if (bo_gem->gtt_virtual)
 996                 bufmgr_gem->vma_count--;
 997         drm_intel_gem_bo_purge_vma_cache(bufmgr_gem);
 998 }
 999
1000 static void
1001 drm_intel_gem_bo_unreference_final(drm_intel_bo *bo, time_t time)
1002 {
1003         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1004         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1005         struct drm_intel_gem_bo_bucket *bucket;
1006         int i;
1007
1008         /* Unreference all the target buffers */
1009         for (i = 0; i < bo_gem->reloc_count; i++) {
1010                 if (bo_gem->reloc_target_info[i].bo != bo) {
1011                         drm_intel_gem_bo_unreference_locked_timed(bo_gem->
1012                                                                   reloc_target_info[i].bo,
1013                                                                   time);
1014                 }
1015         }
1016         bo_gem->reloc_count = 0;
1017         bo_gem->used_as_reloc_target = false;
1018
1019         DBG("bo_unreference final: %d (%s)\n",
1020             bo_gem->gem_handle, bo_gem->name);
1021
1022         /* release memory associated with this object */
1023         if (bo_gem->reloc_target_info) {
1024                 free(bo_gem->reloc_target_info);
1025                 bo_gem->reloc_target_info = NULL;
1026         }
1027         if (bo_gem->relocs) {
1028                 free(bo_gem->relocs);
1029                 bo_gem->relocs = NULL;
1030         }
1031
1032         /* Clear any left-over mappings */
1033         if (bo_gem->map_count) {
1034                 DBG("bo freed with non-zero map-count %d\n", bo_gem->map_count);
1035                 bo_gem->map_count = 0;
1036                 drm_intel_gem_bo_close_vma(bufmgr_gem, bo_gem);
1037         }
1038
1039         DRMLISTDEL(&bo_gem->name_list);
1040
1041         bucket = drm_intel_gem_bo_bucket_for_size(bufmgr_gem, bo->size);
1042         /* Put the buffer into our internal cache for reuse if we can. */
1043         if (bufmgr_gem->bo_reuse && bo_gem->reusable && bucket != NULL &&
1044             drm_intel_gem_bo_madvise_internal(bufmgr_gem, bo_gem,
1045                                               I915_MADV_DONTNEED)) {
1046                 bo_gem->free_time = time;
1047
1048                 bo_gem->name = NULL;
1049                 bo_gem->validate_index = -1;
1050
1051                 DRMLISTADDTAIL(&bo_gem->head, &bucket->head);
1052         } else {
1053                 drm_intel_gem_bo_free(bo);
1054         }
1055 }
1056
1057 static void drm_intel_gem_bo_unreference_locked_timed(drm_intel_bo *bo,
1058                                                       time_t time)
1059 {
1060         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1061
1062         assert(atomic_read(&bo_gem->refcount) > 0);
1063         if (atomic_dec_and_test(&bo_gem->refcount))
1064                 drm_intel_gem_bo_unreference_final(bo, time);
1065 }
1066
1067 static void drm_intel_gem_bo_unreference(drm_intel_bo *bo)
1068 {
1069         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1070
1071         assert(atomic_read(&bo_gem->refcount) > 0);
1072         if (atomic_dec_and_test(&bo_gem->refcount)) {
1073                 drm_intel_bufmgr_gem *bufmgr_gem =
1074                     (drm_intel_bufmgr_gem *) bo->bufmgr;
1075                 struct timespec time;
1076
1077                 clock_gettime(CLOCK_MONOTONIC, &time);
1078
1079                 pthread_mutex_lock(&bufmgr_gem->lock);
1080                 drm_intel_gem_bo_unreference_final(bo, time.tv_sec);
1081                 drm_intel_gem_cleanup_bo_cache(bufmgr_gem, time.tv_sec);
1082                 pthread_mutex_unlock(&bufmgr_gem->lock);
1083         }
1084 }
1085
1086 static int drm_intel_gem_bo_map(drm_intel_bo *bo, int write_enable)
1087 {
1088         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1089         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1090         struct drm_i915_gem_set_domain set_domain;
1091         int ret;
1092
1093         pthread_mutex_lock(&bufmgr_gem->lock);
1094
1095         if (bo_gem->map_count++ == 0)
1096                 drm_intel_gem_bo_open_vma(bufmgr_gem, bo_gem);
1097
1098         if (!bo_gem->mem_virtual) {
1099                 struct drm_i915_gem_mmap mmap_arg;
1100
1101                 DBG("bo_map: %d (%s)\n", bo_gem->gem_handle, bo_gem->name);
1102                 assert(bo_gem->map_count == 1);
1103
1104                 memset(&mmap_arg, 0, sizeof(mmap_arg));
1105                 mmap_arg.handle = bo_gem->gem_handle;
1106                 mmap_arg.offset = 0;
1107                 mmap_arg.size = bo->size;
1108                 ret = drmIoctl(bufmgr_gem->fd,
1109                                DRM_IOCTL_I915_GEM_MMAP,
1110                                &mmap_arg);
1111                 if (ret != 0) {
1112                         ret = -errno;
1113                         DBG("%s:%d: Error mapping buffer %d (%s): %s .\n",
1114                             __FILE__, __LINE__, bo_gem->gem_handle,
1115                             bo_gem->name, strerror(errno));
1116                         if (--bo_gem->map_count == 0)
1117                                 drm_intel_gem_bo_close_vma(bufmgr_gem, bo_gem);
1118                         pthread_mutex_unlock(&bufmgr_gem->lock);
1119                         return ret;
1120                 }
1121                 bo_gem->mem_virtual = (void *)(uintptr_t) mmap_arg.addr_ptr;
1122         }
1123         DBG("bo_map: %d (%s) -> %p\n", bo_gem->gem_handle, bo_gem->name,
1124             bo_gem->mem_virtual);
1125         bo->virtual = bo_gem->mem_virtual;
1126
1127         set_domain.handle = bo_gem->gem_handle;
1128         set_domain.read_domains = I915_GEM_DOMAIN_CPU;
1129         if (write_enable)
1130                 set_domain.write_domain = I915_GEM_DOMAIN_CPU;
1131         else
1132                 set_domain.write_domain = 0;
1133         ret = drmIoctl(bufmgr_gem->fd,
1134                        DRM_IOCTL_I915_GEM_SET_DOMAIN,
1135                        &set_domain);
1136         if (ret != 0) {
1137                 DBG("%s:%d: Error setting to CPU domain %d: %s\n",
1138                     __FILE__, __LINE__, bo_gem->gem_handle,
1139                     strerror(errno));
1140         }
1141
1142         if (write_enable)
1143                 bo_gem->mapped_cpu_write = true;
1144
1145         pthread_mutex_unlock(&bufmgr_gem->lock);
1146
1147         return 0;
1148 }
1149
1150 int drm_intel_gem_bo_map_gtt(drm_intel_bo *bo)
1151 {
1152         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1153         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1154         struct drm_i915_gem_set_domain set_domain;
1155         int ret;
1156
1157         pthread_mutex_lock(&bufmgr_gem->lock);
1158
1159         if (bo_gem->map_count++ == 0)
1160                 drm_intel_gem_bo_open_vma(bufmgr_gem, bo_gem);
1161
1162         /* Get a mapping of the buffer if we haven't before. */
1163         if (bo_gem->gtt_virtual == NULL) {
1164                 struct drm_i915_gem_mmap_gtt mmap_arg;
1165
1166                 DBG("bo_map_gtt: mmap %d (%s)\n", bo_gem->gem_handle,
1167                     bo_gem->name);
1168                 assert(bo_gem->map_count == 1);
1169
1170                 memset(&mmap_arg, 0, sizeof(mmap_arg));
1171                 mmap_arg.handle = bo_gem->gem_handle;
1172
1173                 /* Get the fake offset back... */
1174                 ret = drmIoctl(bufmgr_gem->fd,
1175                                DRM_IOCTL_I915_GEM_MMAP_GTT,
1176                                &mmap_arg);
1177                 if (ret != 0) {
1178                         ret = -errno;
1179                         DBG("%s:%d: Error preparing buffer map %d (%s): %s .\n",
1180                             __FILE__, __LINE__,
1181                             bo_gem->gem_handle, bo_gem->name,
1182                             strerror(errno));
1183                         pthread_mutex_unlock(&bufmgr_gem->lock);
1184                         return ret;
1185                 }
1186
1187                 /* and mmap it */
1188                 bo_gem->gtt_virtual = mmap(0, bo->size, PROT_READ | PROT_WRITE,
1189                                            MAP_SHARED, bufmgr_gem->fd,
1190                                            mmap_arg.offset);
1191                 if (bo_gem->gtt_virtual == MAP_FAILED) {
1192                         bo_gem->gtt_virtual = NULL;
1193                         ret = -errno;
1194                         DBG("%s:%d: Error mapping buffer %d (%s): %s .\n",
1195                             __FILE__, __LINE__,
1196                             bo_gem->gem_handle, bo_gem->name,
1197                             strerror(errno));
1198                         if (--bo_gem->map_count == 0)
1199                                 drm_intel_gem_bo_close_vma(bufmgr_gem, bo_gem);
1200                         pthread_mutex_unlock(&bufmgr_gem->lock);
1201                         return ret;
1202                 }
1203         }
1204
1205         bo->virtual = bo_gem->gtt_virtual;
1206
1207         DBG("bo_map_gtt: %d (%s) -> %p\n", bo_gem->gem_handle, bo_gem->name,
1208             bo_gem->gtt_virtual);
1209
1210         /* Now move it to the GTT domain so that the CPU caches are flushed */
1211         set_domain.handle = bo_gem->gem_handle;
1212         set_domain.read_domains = I915_GEM_DOMAIN_GTT;
1213         set_domain.write_domain = I915_GEM_DOMAIN_GTT;
1214         ret = drmIoctl(bufmgr_gem->fd,
1215                        DRM_IOCTL_I915_GEM_SET_DOMAIN,
1216                        &set_domain);
1217         if (ret != 0) {
1218                 DBG("%s:%d: Error setting domain %d: %s\n",
1219                     __FILE__, __LINE__, bo_gem->gem_handle,
1220                     strerror(errno));
1221         }
1222
1223         pthread_mutex_unlock(&bufmgr_gem->lock);
1224
1225         return 0;
1226 }
1227
1228 static int drm_intel_gem_bo_unmap(drm_intel_bo *bo)
1229 {
1230         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1231         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1232         struct drm_i915_gem_sw_finish sw_finish;
1233         int ret = 0;
1234
1235         if (bo == NULL)
1236                 return 0;
1237
1238         pthread_mutex_lock(&bufmgr_gem->lock);
1239
1240         assert(bo_gem->map_count > 0);
1241
1242         if (bo_gem->mapped_cpu_write) {
1243                 /* Cause a flush to happen if the buffer's pinned for
1244                  * scanout, so the results show up in a timely manner.
1245                  * Unlike GTT set domains, this only does work if the
1246                  * buffer should be scanout-related.
1247                  */
1248                 sw_finish.handle = bo_gem->gem_handle;
1249                 ret = drmIoctl(bufmgr_gem->fd,
1250                                DRM_IOCTL_I915_GEM_SW_FINISH,
1251                                &sw_finish);
1252                 ret = ret == -1 ? -errno : 0;
1253
1254                 bo_gem->mapped_cpu_write = false;
1255         }
1256
1257         /* We need to unmap after every innovation as we cannot track
1258          * an open vma for every bo as that will exhaasut the system
1259          * limits and cause later failures.
1260          */
1261         if (--bo_gem->map_count == 0) {
1262                 drm_intel_gem_bo_close_vma(bufmgr_gem, bo_gem);
1263                 bo->virtual = NULL;
1264         }
1265         pthread_mutex_unlock(&bufmgr_gem->lock);
1266
1267         return ret;
1268 }
1269
1270 int drm_intel_gem_bo_unmap_gtt(drm_intel_bo *bo)
1271 {
1272         return drm_intel_gem_bo_unmap(bo);
1273 }
1274
1275 static int
1276 drm_intel_gem_bo_subdata(drm_intel_bo *bo, unsigned long offset,
1277                          unsigned long size, const void *data)
1278 {
1279         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1280         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1281         struct drm_i915_gem_pwrite pwrite;
1282         int ret;
1283
1284         memset(&pwrite, 0, sizeof(pwrite));
1285         pwrite.handle = bo_gem->gem_handle;
1286         pwrite.offset = offset;
1287         pwrite.size = size;
1288         pwrite.data_ptr = (uint64_t) (uintptr_t) data;
1289         ret = drmIoctl(bufmgr_gem->fd,
1290                        DRM_IOCTL_I915_GEM_PWRITE,
1291                        &pwrite);
1292         if (ret != 0) {
1293                 ret = -errno;
1294                 DBG("%s:%d: Error writing data to buffer %d: (%d %d) %s .\n",
1295                     __FILE__, __LINE__, bo_gem->gem_handle, (int)offset,
1296                     (int)size, strerror(errno));
1297         }
1298
1299         return ret;
1300 }
1301
1302 static int
1303 drm_intel_gem_get_pipe_from_crtc_id(drm_intel_bufmgr *bufmgr, int crtc_id)
1304 {
1305         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
1306         struct drm_i915_get_pipe_from_crtc_id get_pipe_from_crtc_id;
1307         int ret;
1308
1309         get_pipe_from_crtc_id.crtc_id = crtc_id;
1310         ret = drmIoctl(bufmgr_gem->fd,
1311                        DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID,
1312                        &get_pipe_from_crtc_id);
1313         if (ret != 0) {
1314                 /* We return -1 here to signal that we don't
1315                  * know which pipe is associated with this crtc.
1316                  * This lets the caller know that this information
1317                  * isn't available; using the wrong pipe for
1318                  * vblank waiting can cause the chipset to lock up
1319                  */
1320                 return -1;
1321         }
1322
1323         return get_pipe_from_crtc_id.pipe;
1324 }
1325
1326 static int
1327 drm_intel_gem_bo_get_subdata(drm_intel_bo *bo, unsigned long offset,
1328                              unsigned long size, void *data)
1329 {
1330         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1331         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1332         struct drm_i915_gem_pread pread;
1333         int ret;
1334
1335         memset(&pread, 0, sizeof(pread));
1336         pread.handle = bo_gem->gem_handle;
1337         pread.offset = offset;
1338         pread.size = size;
1339         pread.data_ptr = (uint64_t) (uintptr_t) data;
1340         ret = drmIoctl(bufmgr_gem->fd,
1341                        DRM_IOCTL_I915_GEM_PREAD,
1342                        &pread);
1343         if (ret != 0) {
1344                 ret = -errno;
1345                 DBG("%s:%d: Error reading data from buffer %d: (%d %d) %s .\n",
1346                     __FILE__, __LINE__, bo_gem->gem_handle, (int)offset,
1347                     (int)size, strerror(errno));
1348         }
1349
1350         return ret;
1351 }
1352
1353 /** Waits for all GPU rendering with the object to have completed. */
1354 static void
1355 drm_intel_gem_bo_wait_rendering(drm_intel_bo *bo)
1356 {
1357         drm_intel_gem_bo_start_gtt_access(bo, 1);
1358 }
1359
1360 /**
1361  * Sets the object to the GTT read and possibly write domain, used by the X
1362  * 2D driver in the absence of kernel support to do drm_intel_gem_bo_map_gtt().
1363  *
1364  * In combination with drm_intel_gem_bo_pin() and manual fence management, we
1365  * can do tiled pixmaps this way.
1366  */
1367 void
1368 drm_intel_gem_bo_start_gtt_access(drm_intel_bo *bo, int write_enable)
1369 {
1370         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1371         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1372         struct drm_i915_gem_set_domain set_domain;
1373         int ret;
1374
1375         set_domain.handle = bo_gem->gem_handle;
1376         set_domain.read_domains = I915_GEM_DOMAIN_GTT;
1377         set_domain.write_domain = write_enable ? I915_GEM_DOMAIN_GTT : 0;
1378         ret = drmIoctl(bufmgr_gem->fd,
1379                        DRM_IOCTL_I915_GEM_SET_DOMAIN,
1380                        &set_domain);
1381         if (ret != 0) {
1382                 DBG("%s:%d: Error setting memory domains %d (%08x %08x): %s .\n",
1383                     __FILE__, __LINE__, bo_gem->gem_handle,
1384                     set_domain.read_domains, set_domain.write_domain,
1385                     strerror(errno));
1386         }
1387 }
1388
1389 static void
1390 drm_intel_bufmgr_gem_destroy(drm_intel_bufmgr *bufmgr)
1391 {
1392         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
1393         int i;
1394
1395         free(bufmgr_gem->exec2_objects);
1396         free(bufmgr_gem->exec_objects);
1397         free(bufmgr_gem->exec_bos);
1398
1399         pthread_mutex_destroy(&bufmgr_gem->lock);
1400
1401         /* Free any cached buffer objects we were going to reuse */
1402         for (i = 0; i < bufmgr_gem->num_buckets; i++) {
1403                 struct drm_intel_gem_bo_bucket *bucket =
1404                     &bufmgr_gem->cache_bucket[i];
1405                 drm_intel_bo_gem *bo_gem;
1406
1407                 while (!DRMLISTEMPTY(&bucket->head)) {
1408                         bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
1409                                               bucket->head.next, head);
1410                         DRMLISTDEL(&bo_gem->head);
1411
1412                         drm_intel_gem_bo_free(&bo_gem->bo);
1413                 }
1414         }
1415
1416         free(bufmgr);
1417 }
1418
1419 /**
1420  * Adds the target buffer to the validation list and adds the relocation
1421  * to the reloc_buffer's relocation list.
1422  *
1423  * The relocation entry at the given offset must already contain the
1424  * precomputed relocation value, because the kernel will optimize out
1425  * the relocation entry write when the buffer hasn't moved from the
1426  * last known offset in target_bo.
1427  */
1428 static int
1429 do_bo_emit_reloc(drm_intel_bo *bo, uint32_t offset,
1430                  drm_intel_bo *target_bo, uint32_t target_offset,
1431                  uint32_t read_domains, uint32_t write_domain,
1432                  bool need_fence)
1433 {
1434         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1435         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1436         drm_intel_bo_gem *target_bo_gem = (drm_intel_bo_gem *) target_bo;
1437         bool fenced_command;
1438
1439         if (bo_gem->has_error)
1440                 return -ENOMEM;
1441
1442         if (target_bo_gem->has_error) {
1443                 bo_gem->has_error = true;
1444                 return -ENOMEM;
1445         }
1446
1447         /* We never use HW fences for rendering on 965+ */
1448         if (bufmgr_gem->gen >= 4)
1449                 need_fence = false;
1450
1451         fenced_command = need_fence;
1452         if (target_bo_gem->tiling_mode == I915_TILING_NONE)
1453                 need_fence = false;
1454
1455         /* Create a new relocation list if needed */
1456         if (bo_gem->relocs == NULL && drm_intel_setup_reloc_list(bo))
1457                 return -ENOMEM;
1458
1459         /* Check overflow */
1460         assert(bo_gem->reloc_count < bufmgr_gem->max_relocs);
1461
1462         /* Check args */
1463         assert(offset <= bo->size - 4);
1464         assert((write_domain & (write_domain - 1)) == 0);
1465
1466         /* Make sure that we're not adding a reloc to something whose size has
1467          * already been accounted for.
1468          */
1469         assert(!bo_gem->used_as_reloc_target);
1470         if (target_bo_gem != bo_gem) {
1471                 target_bo_gem->used_as_reloc_target = true;
1472                 bo_gem->reloc_tree_size += target_bo_gem->reloc_tree_size;
1473         }
1474         /* An object needing a fence is a tiled buffer, so it won't have
1475          * relocs to other buffers.
1476          */
1477         if (need_fence)
1478                 target_bo_gem->reloc_tree_fences = 1;
1479         bo_gem->reloc_tree_fences += target_bo_gem->reloc_tree_fences;
1480
1481         bo_gem->relocs[bo_gem->reloc_count].offset = offset;
1482         bo_gem->relocs[bo_gem->reloc_count].delta = target_offset;
1483         bo_gem->relocs[bo_gem->reloc_count].target_handle =
1484             target_bo_gem->gem_handle;
1485         bo_gem->relocs[bo_gem->reloc_count].read_domains = read_domains;
1486         bo_gem->relocs[bo_gem->reloc_count].write_domain = write_domain;
1487         bo_gem->relocs[bo_gem->reloc_count].presumed_offset = target_bo->offset;
1488
1489         bo_gem->reloc_target_info[bo_gem->reloc_count].bo = target_bo;
1490         if (target_bo != bo)
1491                 drm_intel_gem_bo_reference(target_bo);
1492         if (fenced_command)
1493                 bo_gem->reloc_target_info[bo_gem->reloc_count].flags =
1494                         DRM_INTEL_RELOC_FENCE;
1495         else
1496                 bo_gem->reloc_target_info[bo_gem->reloc_count].flags = 0;
1497
1498         bo_gem->reloc_count++;
1499
1500         return 0;
1501 }
1502
1503 static int
1504 drm_intel_gem_bo_emit_reloc(drm_intel_bo *bo, uint32_t offset,
1505                             drm_intel_bo *target_bo, uint32_t target_offset,
1506                             uint32_t read_domains, uint32_t write_domain)
1507 {
1508         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
1509
1510         return do_bo_emit_reloc(bo, offset, target_bo, target_offset,
1511                                 read_domains, write_domain,
1512                                 !bufmgr_gem->fenced_relocs);
1513 }
1514
1515 static int
1516 drm_intel_gem_bo_emit_reloc_fence(drm_intel_bo *bo, uint32_t offset,
1517                                   drm_intel_bo *target_bo,
1518                                   uint32_t target_offset,
1519                                   uint32_t read_domains, uint32_t write_domain)
1520 {
1521         return do_bo_emit_reloc(bo, offset, target_bo, target_offset,
1522                                 read_domains, write_domain, true);
1523 }
1524
1525 int
1526 drm_intel_gem_bo_get_reloc_count(drm_intel_bo *bo)
1527 {
1528         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1529
1530         return bo_gem->reloc_count;
1531 }
1532
1533 /**
1534  * Removes existing relocation entries in the BO after "start".
1535  *
1536  * This allows a user to avoid a two-step process for state setup with
1537  * counting up all the buffer objects and doing a
1538  * drm_intel_bufmgr_check_aperture_space() before emitting any of the
1539  * relocations for the state setup.  Instead, save the state of the
1540  * batchbuffer including drm_intel_gem_get_reloc_count(), emit all the
1541  * state, and then check if it still fits in the aperture.
1542  *
1543  * Any further drm_intel_bufmgr_check_aperture_space() queries
1544  * involving this buffer in the tree are undefined after this call.
1545  */
1546 void
1547 drm_intel_gem_bo_clear_relocs(drm_intel_bo *bo, int start)
1548 {
1549         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1550         int i;
1551         struct timespec time;
1552
1553         clock_gettime(CLOCK_MONOTONIC, &time);
1554
1555         assert(bo_gem->reloc_count >= start);
1556         /* Unreference the cleared target buffers */
1557         for (i = start; i < bo_gem->reloc_count; i++) {
1558                 if (bo_gem->reloc_target_info[i].bo != bo) {
1559                         drm_intel_gem_bo_unreference_locked_timed(bo_gem->
1560                                                                   reloc_target_info[i].bo,
1561                                                                   time.tv_sec);
1562                 }
1563         }
1564         bo_gem->reloc_count = start;
1565 }
1566
1567 /**
1568  * Walk the tree of relocations rooted at BO and accumulate the list of
1569  * validations to be performed and update the relocation buffers with
1570  * index values into the validation list.
1571  */
1572 static void
1573 drm_intel_gem_bo_process_reloc(drm_intel_bo *bo)
1574 {
1575         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1576         int i;
1577
1578         if (bo_gem->relocs == NULL)
1579                 return;
1580
1581         for (i = 0; i < bo_gem->reloc_count; i++) {
1582                 drm_intel_bo *target_bo = bo_gem->reloc_target_info[i].bo;
1583
1584                 if (target_bo == bo)
1585                         continue;
1586
1587                 /* Continue walking the tree depth-first. */
1588                 drm_intel_gem_bo_process_reloc(target_bo);
1589
1590                 /* Add the target to the validate list */
1591                 drm_intel_add_validate_buffer(target_bo);
1592         }
1593 }
1594
1595 static void
1596 drm_intel_gem_bo_process_reloc2(drm_intel_bo *bo)
1597 {
1598         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
1599         int i;
1600
1601         if (bo_gem->relocs == NULL)
1602                 return;
1603
1604         for (i = 0; i < bo_gem->reloc_count; i++) {
1605                 drm_intel_bo *target_bo = bo_gem->reloc_target_info[i].bo;
1606                 int need_fence;
1607
1608                 if (target_bo == bo)
1609                         continue;
1610
1611                 /* Continue walking the tree depth-first. */
1612                 drm_intel_gem_bo_process_reloc2(target_bo);
1613
1614                 need_fence = (bo_gem->reloc_target_info[i].flags &
1615                               DRM_INTEL_RELOC_FENCE);
1616
1617                 /* Add the target to the validate list */
1618                 drm_intel_add_validate_buffer2(target_bo, need_fence);
1619         }
1620 }
1621
1622
1623 static void
1624 drm_intel_update_buffer_offsets(drm_intel_bufmgr_gem *bufmgr_gem)
1625 {
1626         int i;
1627
1628         for (i = 0; i < bufmgr_gem->exec_count; i++) {
1629                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
1630                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1631
1632                 /* Update the buffer offset */
1633                 if (bufmgr_gem->exec_objects[i].offset != bo->offset) {
1634                         DBG("BO %d (%s) migrated: 0x%08lx -> 0x%08llx\n",
1635                             bo_gem->gem_handle, bo_gem->name, bo->offset,
1636                             (unsigned long long)bufmgr_gem->exec_objects[i].
1637                             offset);
1638                         bo->offset = bufmgr_gem->exec_objects[i].offset;
1639                 }
1640         }
1641 }
1642
1643 static void
1644 drm_intel_update_buffer_offsets2 (drm_intel_bufmgr_gem *bufmgr_gem)
1645 {
1646         int i;
1647
1648         for (i = 0; i < bufmgr_gem->exec_count; i++) {
1649                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
1650                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
1651
1652                 /* Update the buffer offset */
1653                 if (bufmgr_gem->exec2_objects[i].offset != bo->offset) {
1654                         DBG("BO %d (%s) migrated: 0x%08lx -> 0x%08llx\n",
1655                             bo_gem->gem_handle, bo_gem->name, bo->offset,
1656                             (unsigned long long)bufmgr_gem->exec2_objects[i].offset);
1657                         bo->offset = bufmgr_gem->exec2_objects[i].offset;
1658                 }
1659         }
1660 }
1661
1662 static int
1663 drm_intel_gem_bo_exec(drm_intel_bo *bo, int used,
1664                       drm_clip_rect_t * cliprects, int num_cliprects, int DR4)
1665 {
1666         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1667         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1668         struct drm_i915_gem_execbuffer execbuf;
1669         int ret, i;
1670
1671         if (bo_gem->has_error)
1672                 return -ENOMEM;
1673
1674         pthread_mutex_lock(&bufmgr_gem->lock);
1675         /* Update indices and set up the validate list. */
1676         drm_intel_gem_bo_process_reloc(bo);
1677
1678         /* Add the batch buffer to the validation list.  There are no
1679          * relocations pointing to it.
1680          */
1681         drm_intel_add_validate_buffer(bo);
1682
1683         execbuf.buffers_ptr = (uintptr_t) bufmgr_gem->exec_objects;
1684         execbuf.buffer_count = bufmgr_gem->exec_count;
1685         execbuf.batch_start_offset = 0;
1686         execbuf.batch_len = used;
1687         execbuf.cliprects_ptr = (uintptr_t) cliprects;
1688         execbuf.num_cliprects = num_cliprects;
1689         execbuf.DR1 = 0;
1690         execbuf.DR4 = DR4;
1691
1692         ret = drmIoctl(bufmgr_gem->fd,
1693                        DRM_IOCTL_I915_GEM_EXECBUFFER,
1694                        &execbuf);
1695         if (ret != 0) {
1696                 ret = -errno;
1697                 if (errno == ENOSPC) {
1698                         DBG("Execbuffer fails to pin. "
1699                             "Estimate: %u. Actual: %u. Available: %u\n",
1700                             drm_intel_gem_estimate_batch_space(bufmgr_gem->exec_bos,
1701                                                                bufmgr_gem->
1702                                                                exec_count),
1703                             drm_intel_gem_compute_batch_space(bufmgr_gem->exec_bos,
1704                                                               bufmgr_gem->
1705                                                               exec_count),
1706                             (unsigned int)bufmgr_gem->gtt_size);
1707                 }
1708         }
1709         drm_intel_update_buffer_offsets(bufmgr_gem);
1710
1711         if (bufmgr_gem->bufmgr.debug)
1712                 drm_intel_gem_dump_validation_list(bufmgr_gem);
1713
1714         for (i = 0; i < bufmgr_gem->exec_count; i++) {
1715                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
1716                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1717
1718                 /* Disconnect the buffer from the validate list */
1719                 bo_gem->validate_index = -1;
1720                 bufmgr_gem->exec_bos[i] = NULL;
1721         }
1722         bufmgr_gem->exec_count = 0;
1723         pthread_mutex_unlock(&bufmgr_gem->lock);
1724
1725         return ret;
1726 }
1727
1728 static int
1729 drm_intel_gem_bo_mrb_exec2(drm_intel_bo *bo, int used,
1730                         drm_clip_rect_t *cliprects, int num_cliprects, int DR4,
1731                         unsigned int flags)
1732 {
1733         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
1734         struct drm_i915_gem_execbuffer2 execbuf;
1735         int ret, i;
1736
1737         switch (flags & 0x7) {
1738         default:
1739                 return -EINVAL;
1740         case I915_EXEC_BLT:
1741                 if (!bufmgr_gem->has_blt)
1742                         return -EINVAL;
1743                 break;
1744         case I915_EXEC_BSD:
1745                 if (!bufmgr_gem->has_bsd)
1746                         return -EINVAL;
1747                 break;
1748         case I915_EXEC_RENDER:
1749         case I915_EXEC_DEFAULT:
1750                 break;
1751         }
1752
1753         pthread_mutex_lock(&bufmgr_gem->lock);
1754         /* Update indices and set up the validate list. */
1755         drm_intel_gem_bo_process_reloc2(bo);
1756
1757         /* Add the batch buffer to the validation list.  There are no relocations
1758          * pointing to it.
1759          */
1760         drm_intel_add_validate_buffer2(bo, 0);
1761
1762         execbuf.buffers_ptr = (uintptr_t)bufmgr_gem->exec2_objects;
1763         execbuf.buffer_count = bufmgr_gem->exec_count;
1764         execbuf.batch_start_offset = 0;
1765         execbuf.batch_len = used;
1766         execbuf.cliprects_ptr = (uintptr_t)cliprects;
1767         execbuf.num_cliprects = num_cliprects;
1768         execbuf.DR1 = 0;
1769         execbuf.DR4 = DR4;
1770         execbuf.flags = flags;
1771         execbuf.rsvd1 = 0;
1772         execbuf.rsvd2 = 0;
1773
1774         ret = drmIoctl(bufmgr_gem->fd,
1775                        DRM_IOCTL_I915_GEM_EXECBUFFER2,
1776                        &execbuf);
1777         if (ret != 0) {
1778                 ret = -errno;
1779                 if (ret == -ENOSPC) {
1780                         DBG("Execbuffer fails to pin. "
1781                             "Estimate: %u. Actual: %u. Available: %u\n",
1782                             drm_intel_gem_estimate_batch_space(bufmgr_gem->exec_bos,
1783                                                                bufmgr_gem->exec_count),
1784                             drm_intel_gem_compute_batch_space(bufmgr_gem->exec_bos,
1785                                                               bufmgr_gem->exec_count),
1786                             (unsigned int) bufmgr_gem->gtt_size);
1787                 }
1788         }
1789         drm_intel_update_buffer_offsets2(bufmgr_gem);
1790
1791         if (bufmgr_gem->bufmgr.debug)
1792                 drm_intel_gem_dump_validation_list(bufmgr_gem);
1793
1794         for (i = 0; i < bufmgr_gem->exec_count; i++) {
1795                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
1796                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
1797
1798                 /* Disconnect the buffer from the validate list */
1799                 bo_gem->validate_index = -1;
1800                 bufmgr_gem->exec_bos[i] = NULL;
1801         }
1802         bufmgr_gem->exec_count = 0;
1803         pthread_mutex_unlock(&bufmgr_gem->lock);
1804
1805         return ret;
1806 }
1807
1808 static int
1809 drm_intel_gem_bo_exec2(drm_intel_bo *bo, int used,
1810                        drm_clip_rect_t *cliprects, int num_cliprects,
1811                        int DR4)
1812 {
1813         return drm_intel_gem_bo_mrb_exec2(bo, used,
1814                                         cliprects, num_cliprects, DR4,
1815                                         I915_EXEC_RENDER);
1816 }
1817
1818 static int
1819 drm_intel_gem_bo_pin(drm_intel_bo *bo, uint32_t alignment)
1820 {
1821         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1822         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1823         struct drm_i915_gem_pin pin;
1824         int ret;
1825
1826         memset(&pin, 0, sizeof(pin));
1827         pin.handle = bo_gem->gem_handle;
1828         pin.alignment = alignment;
1829
1830         ret = drmIoctl(bufmgr_gem->fd,
1831                        DRM_IOCTL_I915_GEM_PIN,
1832                        &pin);
1833         if (ret != 0)
1834                 return -errno;
1835
1836         bo->offset = pin.offset;
1837         return 0;
1838 }
1839
1840 static int
1841 drm_intel_gem_bo_unpin(drm_intel_bo *bo)
1842 {
1843         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1844         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1845         struct drm_i915_gem_unpin unpin;
1846         int ret;
1847
1848         memset(&unpin, 0, sizeof(unpin));
1849         unpin.handle = bo_gem->gem_handle;
1850
1851         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_UNPIN, &unpin);
1852         if (ret != 0)
1853                 return -errno;
1854
1855         return 0;
1856 }
1857
1858 static int
1859 drm_intel_gem_bo_set_tiling_internal(drm_intel_bo *bo,
1860                                      uint32_t tiling_mode,
1861                                      uint32_t stride)
1862 {
1863         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1864         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1865         struct drm_i915_gem_set_tiling set_tiling;
1866         int ret;
1867
1868         if (bo_gem->global_name == 0 &&
1869             tiling_mode == bo_gem->tiling_mode &&
1870             stride == bo_gem->stride)
1871                 return 0;
1872
1873         memset(&set_tiling, 0, sizeof(set_tiling));
1874         do {
1875                 /* set_tiling is slightly broken and overwrites the
1876                  * input on the error path, so we have to open code
1877                  * rmIoctl.
1878                  */
1879                 set_tiling.handle = bo_gem->gem_handle;
1880                 set_tiling.tiling_mode = tiling_mode;
1881                 set_tiling.stride = stride;
1882
1883                 ret = ioctl(bufmgr_gem->fd,
1884                             DRM_IOCTL_I915_GEM_SET_TILING,
1885                             &set_tiling);
1886         } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
1887         if (ret == -1)
1888                 return -errno;
1889
1890         bo_gem->tiling_mode = set_tiling.tiling_mode;
1891         bo_gem->swizzle_mode = set_tiling.swizzle_mode;
1892         bo_gem->stride = set_tiling.stride;
1893         return 0;
1894 }
1895
1896 static int
1897 drm_intel_gem_bo_set_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
1898                             uint32_t stride)
1899 {
1900         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1901         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1902         int ret;
1903
1904         /* Linear buffers have no stride. By ensuring that we only ever use
1905          * stride 0 with linear buffers, we simplify our code.
1906          */
1907         if (*tiling_mode == I915_TILING_NONE)
1908                 stride = 0;
1909
1910         ret = drm_intel_gem_bo_set_tiling_internal(bo, *tiling_mode, stride);
1911         if (ret == 0)
1912                 drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem);
1913
1914         *tiling_mode = bo_gem->tiling_mode;
1915         return ret;
1916 }
1917
1918 static int
1919 drm_intel_gem_bo_get_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
1920                             uint32_t * swizzle_mode)
1921 {
1922         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1923
1924         *tiling_mode = bo_gem->tiling_mode;
1925         *swizzle_mode = bo_gem->swizzle_mode;
1926         return 0;
1927 }
1928
1929 static int
1930 drm_intel_gem_bo_flink(drm_intel_bo *bo, uint32_t * name)
1931 {
1932         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1933         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1934         struct drm_gem_flink flink;
1935         int ret;
1936
1937         if (!bo_gem->global_name) {
1938                 memset(&flink, 0, sizeof(flink));
1939                 flink.handle = bo_gem->gem_handle;
1940
1941                 ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_GEM_FLINK, &flink);
1942                 if (ret != 0)
1943                         return -errno;
1944                 bo_gem->global_name = flink.name;
1945                 bo_gem->reusable = false;
1946
1947                 DRMLISTADDTAIL(&bo_gem->name_list, &bufmgr_gem->named);
1948         }
1949
1950         *name = bo_gem->global_name;
1951         return 0;
1952 }
1953
1954 /**
1955  * Enables unlimited caching of buffer objects for reuse.
1956  *
1957  * This is potentially very memory expensive, as the cache at each bucket
1958  * size is only bounded by how many buffers of that size we've managed to have
1959  * in flight at once.
1960  */
1961 void
1962 drm_intel_bufmgr_gem_enable_reuse(drm_intel_bufmgr *bufmgr)
1963 {
1964         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
1965
1966         bufmgr_gem->bo_reuse = true;
1967 }
1968
1969 /**
1970  * Enable use of fenced reloc type.
1971  *
1972  * New code should enable this to avoid unnecessary fence register
1973  * allocation.  If this option is not enabled, all relocs will have fence
1974  * register allocated.
1975  */
1976 void
1977 drm_intel_bufmgr_gem_enable_fenced_relocs(drm_intel_bufmgr *bufmgr)
1978 {
1979         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
1980
1981         if (bufmgr_gem->bufmgr.bo_exec == drm_intel_gem_bo_exec2)
1982                 bufmgr_gem->fenced_relocs = true;
1983 }
1984
1985 /**
1986  * Return the additional aperture space required by the tree of buffer objects
1987  * rooted at bo.
1988  */
1989 static int
1990 drm_intel_gem_bo_get_aperture_space(drm_intel_bo *bo)
1991 {
1992         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1993         int i;
1994         int total = 0;
1995
1996         if (bo == NULL || bo_gem->included_in_check_aperture)
1997                 return 0;
1998
1999         total += bo->size;
2000         bo_gem->included_in_check_aperture = true;
2001
2002         for (i = 0; i < bo_gem->reloc_count; i++)
2003                 total +=
2004                     drm_intel_gem_bo_get_aperture_space(bo_gem->
2005                                                         reloc_target_info[i].bo);
2006
2007         return total;
2008 }
2009
2010 /**
2011  * Count the number of buffers in this list that need a fence reg
2012  *
2013  * If the count is greater than the number of available regs, we'll have
2014  * to ask the caller to resubmit a batch with fewer tiled buffers.
2015  *
2016  * This function over-counts if the same buffer is used multiple times.
2017  */
2018 static unsigned int
2019 drm_intel_gem_total_fences(drm_intel_bo ** bo_array, int count)
2020 {
2021         int i;
2022         unsigned int total = 0;
2023
2024         for (i = 0; i < count; i++) {
2025                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo_array[i];
2026
2027                 if (bo_gem == NULL)
2028                         continue;
2029
2030                 total += bo_gem->reloc_tree_fences;
2031         }
2032         return total;
2033 }
2034
2035 /**
2036  * Clear the flag set by drm_intel_gem_bo_get_aperture_space() so we're ready
2037  * for the next drm_intel_bufmgr_check_aperture_space() call.
2038  */
2039 static void
2040 drm_intel_gem_bo_clear_aperture_space_flag(drm_intel_bo *bo)
2041 {
2042         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2043         int i;
2044
2045         if (bo == NULL || !bo_gem->included_in_check_aperture)
2046                 return;
2047
2048         bo_gem->included_in_check_aperture = false;
2049
2050         for (i = 0; i < bo_gem->reloc_count; i++)
2051                 drm_intel_gem_bo_clear_aperture_space_flag(bo_gem->
2052                                                            reloc_target_info[i].bo);
2053 }
2054
2055 /**
2056  * Return a conservative estimate for the amount of aperture required
2057  * for a collection of buffers. This may double-count some buffers.
2058  */
2059 static unsigned int
2060 drm_intel_gem_estimate_batch_space(drm_intel_bo **bo_array, int count)
2061 {
2062         int i;
2063         unsigned int total = 0;
2064
2065         for (i = 0; i < count; i++) {
2066                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo_array[i];
2067                 if (bo_gem != NULL)
2068                         total += bo_gem->reloc_tree_size;
2069         }
2070         return total;
2071 }
2072
2073 /**
2074  * Return the amount of aperture needed for a collection of buffers.
2075  * This avoids double counting any buffers, at the cost of looking
2076  * at every buffer in the set.
2077  */
2078 static unsigned int
2079 drm_intel_gem_compute_batch_space(drm_intel_bo **bo_array, int count)
2080 {
2081         int i;
2082         unsigned int total = 0;
2083
2084         for (i = 0; i < count; i++) {
2085                 total += drm_intel_gem_bo_get_aperture_space(bo_array[i]);
2086                 /* For the first buffer object in the array, we get an
2087                  * accurate count back for its reloc_tree size (since nothing
2088                  * had been flagged as being counted yet).  We can save that
2089                  * value out as a more conservative reloc_tree_size that
2090                  * avoids double-counting target buffers.  Since the first
2091                  * buffer happens to usually be the batch buffer in our
2092                  * callers, this can pull us back from doing the tree
2093                  * walk on every new batch emit.
2094                  */
2095                 if (i == 0) {
2096                         drm_intel_bo_gem *bo_gem =
2097                             (drm_intel_bo_gem *) bo_array[i];
2098                         bo_gem->reloc_tree_size = total;
2099                 }
2100         }
2101
2102         for (i = 0; i < count; i++)
2103                 drm_intel_gem_bo_clear_aperture_space_flag(bo_array[i]);
2104         return total;
2105 }
2106
2107 /**
2108  * Return -1 if the batchbuffer should be flushed before attempting to
2109  * emit rendering referencing the buffers pointed to by bo_array.
2110  *
2111  * This is required because if we try to emit a batchbuffer with relocations
2112  * to a tree of buffers that won't simultaneously fit in the aperture,
2113  * the rendering will return an error at a point where the software is not
2114  * prepared to recover from it.
2115  *
2116  * However, we also want to emit the batchbuffer significantly before we reach
2117  * the limit, as a series of batchbuffers each of which references buffers
2118  * covering almost all of the aperture means that at each emit we end up
2119  * waiting to evict a buffer from the last rendering, and we get synchronous
2120  * performance.  By emitting smaller batchbuffers, we eat some CPU overhead to
2121  * get better parallelism.
2122  */
2123 static int
2124 drm_intel_gem_check_aperture_space(drm_intel_bo **bo_array, int count)
2125 {
2126         drm_intel_bufmgr_gem *bufmgr_gem =
2127             (drm_intel_bufmgr_gem *) bo_array[0]->bufmgr;
2128         unsigned int total = 0;
2129         unsigned int threshold = bufmgr_gem->gtt_size * 3 / 4;
2130         int total_fences;
2131
2132         /* Check for fence reg constraints if necessary */
2133         if (bufmgr_gem->available_fences) {
2134                 total_fences = drm_intel_gem_total_fences(bo_array, count);
2135                 if (total_fences > bufmgr_gem->available_fences)
2136                         return -ENOSPC;
2137         }
2138
2139         total = drm_intel_gem_estimate_batch_space(bo_array, count);
2140
2141         if (total > threshold)
2142                 total = drm_intel_gem_compute_batch_space(bo_array, count);
2143
2144         if (total > threshold) {
2145                 DBG("check_space: overflowed available aperture, "
2146                     "%dkb vs %dkb\n",
2147                     total / 1024, (int)bufmgr_gem->gtt_size / 1024);
2148                 return -ENOSPC;
2149         } else {
2150                 DBG("drm_check_space: total %dkb vs bufgr %dkb\n", total / 1024,
2151                     (int)bufmgr_gem->gtt_size / 1024);
2152                 return 0;
2153         }
2154 }
2155
2156 /*
2157  * Disable buffer reuse for objects which are shared with the kernel
2158  * as scanout buffers
2159  */
2160 static int
2161 drm_intel_gem_bo_disable_reuse(drm_intel_bo *bo)
2162 {
2163         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2164
2165         bo_gem->reusable = false;
2166         return 0;
2167 }
2168
2169 static int
2170 drm_intel_gem_bo_is_reusable(drm_intel_bo *bo)
2171 {
2172         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2173
2174         return bo_gem->reusable;
2175 }
2176
2177 static int
2178 _drm_intel_gem_bo_references(drm_intel_bo *bo, drm_intel_bo *target_bo)
2179 {
2180         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2181         int i;
2182
2183         for (i = 0; i < bo_gem->reloc_count; i++) {
2184                 if (bo_gem->reloc_target_info[i].bo == target_bo)
2185                         return 1;
2186                 if (bo == bo_gem->reloc_target_info[i].bo)
2187                         continue;
2188                 if (_drm_intel_gem_bo_references(bo_gem->reloc_target_info[i].bo,
2189                                                 target_bo))
2190                         return 1;
2191         }
2192
2193         return 0;
2194 }
2195
2196 /** Return true if target_bo is referenced by bo's relocation tree. */
2197 static int
2198 drm_intel_gem_bo_references(drm_intel_bo *bo, drm_intel_bo *target_bo)
2199 {
2200         drm_intel_bo_gem *target_bo_gem = (drm_intel_bo_gem *) target_bo;
2201
2202         if (bo == NULL || target_bo == NULL)
2203                 return 0;
2204         if (target_bo_gem->used_as_reloc_target)
2205                 return _drm_intel_gem_bo_references(bo, target_bo);
2206         return 0;
2207 }
2208
2209 static void
2210 add_bucket(drm_intel_bufmgr_gem *bufmgr_gem, int size)
2211 {
2212         unsigned int i = bufmgr_gem->num_buckets;
2213
2214         assert(i < ARRAY_SIZE(bufmgr_gem->cache_bucket));
2215
2216         DRMINITLISTHEAD(&bufmgr_gem->cache_bucket[i].head);
2217         bufmgr_gem->cache_bucket[i].size = size;
2218         bufmgr_gem->num_buckets++;
2219 }
2220
2221 static void
2222 init_cache_buckets(drm_intel_bufmgr_gem *bufmgr_gem)
2223 {
2224         unsigned long size, cache_max_size = 64 * 1024 * 1024;
2225
2226         /* OK, so power of two buckets was too wasteful of memory.
2227          * Give 3 other sizes between each power of two, to hopefully
2228          * cover things accurately enough.  (The alternative is
2229          * probably to just go for exact matching of sizes, and assume
2230          * that for things like composited window resize the tiled
2231          * width/height alignment and rounding of sizes to pages will
2232          * get us useful cache hit rates anyway)
2233          */
2234         add_bucket(bufmgr_gem, 4096);
2235         add_bucket(bufmgr_gem, 4096 * 2);
2236         add_bucket(bufmgr_gem, 4096 * 3);
2237
2238         /* Initialize the linked lists for BO reuse cache. */
2239         for (size = 4 * 4096; size <= cache_max_size; size *= 2) {
2240                 add_bucket(bufmgr_gem, size);
2241
2242                 add_bucket(bufmgr_gem, size + size * 1 / 4);
2243                 add_bucket(bufmgr_gem, size + size * 2 / 4);
2244                 add_bucket(bufmgr_gem, size + size * 3 / 4);
2245         }
2246 }
2247
2248 void
2249 drm_intel_bufmgr_gem_set_vma_cache_size(drm_intel_bufmgr *bufmgr, int limit)
2250 {
2251         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
2252
2253         bufmgr_gem->vma_max = limit;
2254
2255         drm_intel_gem_bo_purge_vma_cache(bufmgr_gem);
2256 }
2257
2258 /**
2259  * Initializes the GEM buffer manager, which uses the kernel to allocate, map,
2260  * and manage map buffer objections.
2261  *
2262  * \param fd File descriptor of the opened DRM device.
2263  */
2264 drm_intel_bufmgr *
2265 drm_intel_bufmgr_gem_init(int fd, int batch_size)
2266 {
2267         drm_intel_bufmgr_gem *bufmgr_gem;
2268         struct drm_i915_gem_get_aperture aperture;
2269         drm_i915_getparam_t gp;
2270         int ret, tmp;
2271         bool exec2 = false;
2272
2273         bufmgr_gem = calloc(1, sizeof(*bufmgr_gem));
2274         if (bufmgr_gem == NULL)
2275                 return NULL;
2276
2277         bufmgr_gem->fd = fd;
2278
2279         if (pthread_mutex_init(&bufmgr_gem->lock, NULL) != 0) {
2280                 free(bufmgr_gem);
2281                 return NULL;
2282         }
2283
2284         ret = drmIoctl(bufmgr_gem->fd,
2285                        DRM_IOCTL_I915_GEM_GET_APERTURE,
2286                        &aperture);
2287
2288         if (ret == 0)
2289                 bufmgr_gem->gtt_size = aperture.aper_available_size;
2290         else {
2291                 fprintf(stderr, "DRM_IOCTL_I915_GEM_APERTURE failed: %s\n",
2292                         strerror(errno));
2293                 bufmgr_gem->gtt_size = 128 * 1024 * 1024;
2294                 fprintf(stderr, "Assuming %dkB available aperture size.\n"
2295                         "May lead to reduced performance or incorrect "
2296                         "rendering.\n",
2297                         (int)bufmgr_gem->gtt_size / 1024);
2298         }
2299
2300         gp.param = I915_PARAM_CHIPSET_ID;
2301         gp.value = &bufmgr_gem->pci_device;
2302         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2303         if (ret) {
2304                 fprintf(stderr, "get chip id failed: %d [%d]\n", ret, errno);
2305                 fprintf(stderr, "param: %d, val: %d\n", gp.param, *gp.value);
2306         }
2307
2308         if (IS_GEN2(bufmgr_gem))
2309                 bufmgr_gem->gen = 2;
2310         else if (IS_GEN3(bufmgr_gem))
2311                 bufmgr_gem->gen = 3;
2312         else if (IS_GEN4(bufmgr_gem))
2313                 bufmgr_gem->gen = 4;
2314         else
2315                 bufmgr_gem->gen = 6;
2316
2317         if (IS_GEN3(bufmgr_gem) && bufmgr_gem->gtt_size > 256*1024*1024) {
2318                 /* The unmappable part of gtt on gen 3 (i.e. above 256MB) can't
2319                  * be used for tiled blits. To simplify the accounting, just
2320                  * substract the unmappable part (fixed to 256MB on all known
2321                  * gen3 devices) if the kernel advertises it. */
2322                 bufmgr_gem->gtt_size -= 256*1024*1024;
2323         }
2324
2325         gp.value = &tmp;
2326
2327         gp.param = I915_PARAM_HAS_EXECBUF2;
2328         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2329         if (!ret)
2330                 exec2 = true;
2331
2332         gp.param = I915_PARAM_HAS_BSD;
2333         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2334         bufmgr_gem->has_bsd = ret == 0;
2335
2336         gp.param = I915_PARAM_HAS_BLT;
2337         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2338         bufmgr_gem->has_blt = ret == 0;
2339
2340         gp.param = I915_PARAM_HAS_RELAXED_FENCING;
2341         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2342         bufmgr_gem->has_relaxed_fencing = ret == 0;
2343
2344         if (bufmgr_gem->gen < 4) {
2345                 gp.param = I915_PARAM_NUM_FENCES_AVAIL;
2346                 gp.value = &bufmgr_gem->available_fences;
2347                 ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2348                 if (ret) {
2349                         fprintf(stderr, "get fences failed: %d [%d]\n", ret,
2350                                 errno);
2351                         fprintf(stderr, "param: %d, val: %d\n", gp.param,
2352                                 *gp.value);
2353                         bufmgr_gem->available_fences = 0;
2354                 } else {
2355                         /* XXX The kernel reports the total number of fences,
2356                          * including any that may be pinned.
2357                          *
2358                          * We presume that there will be at least one pinned
2359                          * fence for the scanout buffer, but there may be more
2360                          * than one scanout and the user may be manually
2361                          * pinning buffers. Let's move to execbuffer2 and
2362                          * thereby forget the insanity of using fences...
2363                          */
2364                         bufmgr_gem->available_fences -= 2;
2365                         if (bufmgr_gem->available_fences < 0)
2366                                 bufmgr_gem->available_fences = 0;
2367                 }
2368         }
2369
2370         /* Let's go with one relocation per every 2 dwords (but round down a bit
2371          * since a power of two will mean an extra page allocation for the reloc
2372          * buffer).
2373          *
2374          * Every 4 was too few for the blender benchmark.
2375          */
2376         bufmgr_gem->max_relocs = batch_size / sizeof(uint32_t) / 2 - 2;
2377
2378         bufmgr_gem->bufmgr.bo_alloc = drm_intel_gem_bo_alloc;
2379         bufmgr_gem->bufmgr.bo_alloc_for_render =
2380             drm_intel_gem_bo_alloc_for_render;
2381         bufmgr_gem->bufmgr.bo_alloc_tiled = drm_intel_gem_bo_alloc_tiled;
2382         bufmgr_gem->bufmgr.bo_reference = drm_intel_gem_bo_reference;
2383         bufmgr_gem->bufmgr.bo_unreference = drm_intel_gem_bo_unreference;
2384         bufmgr_gem->bufmgr.bo_map = drm_intel_gem_bo_map;
2385         bufmgr_gem->bufmgr.bo_unmap = drm_intel_gem_bo_unmap;
2386         bufmgr_gem->bufmgr.bo_subdata = drm_intel_gem_bo_subdata;
2387         bufmgr_gem->bufmgr.bo_get_subdata = drm_intel_gem_bo_get_subdata;
2388         bufmgr_gem->bufmgr.bo_wait_rendering = drm_intel_gem_bo_wait_rendering;
2389         bufmgr_gem->bufmgr.bo_emit_reloc = drm_intel_gem_bo_emit_reloc;
2390         bufmgr_gem->bufmgr.bo_emit_reloc_fence = drm_intel_gem_bo_emit_reloc_fence;
2391         bufmgr_gem->bufmgr.bo_pin = drm_intel_gem_bo_pin;
2392         bufmgr_gem->bufmgr.bo_unpin = drm_intel_gem_bo_unpin;
2393         bufmgr_gem->bufmgr.bo_get_tiling = drm_intel_gem_bo_get_tiling;
2394         bufmgr_gem->bufmgr.bo_set_tiling = drm_intel_gem_bo_set_tiling;
2395         bufmgr_gem->bufmgr.bo_flink = drm_intel_gem_bo_flink;
2396         /* Use the new one if available */
2397         if (exec2) {
2398                 bufmgr_gem->bufmgr.bo_exec = drm_intel_gem_bo_exec2;
2399                 bufmgr_gem->bufmgr.bo_mrb_exec = drm_intel_gem_bo_mrb_exec2;
2400         } else
2401                 bufmgr_gem->bufmgr.bo_exec = drm_intel_gem_bo_exec;
2402         bufmgr_gem->bufmgr.bo_busy = drm_intel_gem_bo_busy;
2403         bufmgr_gem->bufmgr.bo_madvise = drm_intel_gem_bo_madvise;
2404         bufmgr_gem->bufmgr.destroy = drm_intel_bufmgr_gem_destroy;
2405         bufmgr_gem->bufmgr.debug = 0;
2406         bufmgr_gem->bufmgr.check_aperture_space =
2407             drm_intel_gem_check_aperture_space;
2408         bufmgr_gem->bufmgr.bo_disable_reuse = drm_intel_gem_bo_disable_reuse;
2409         bufmgr_gem->bufmgr.bo_is_reusable = drm_intel_gem_bo_is_reusable;
2410         bufmgr_gem->bufmgr.get_pipe_from_crtc_id =
2411             drm_intel_gem_get_pipe_from_crtc_id;
2412         bufmgr_gem->bufmgr.bo_references = drm_intel_gem_bo_references;
2413
2414         DRMINITLISTHEAD(&bufmgr_gem->named);
2415         init_cache_buckets(bufmgr_gem);
2416
2417         DRMINITLISTHEAD(&bufmgr_gem->vma_cache);
2418         bufmgr_gem->vma_max = -1; /* unlimited by default */
2419
2420         return &bufmgr_gem->bufmgr;
2421 }