intel/intel_bufmgr_gem.c

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