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