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