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_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1787         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1788         int i;
1789         struct timespec time;
1790
1791         clock_gettime(CLOCK_MONOTONIC, &time);
1792
1793         assert(bo_gem->reloc_count >= start);
1794
1795         /* Unreference the cleared target buffers */
1796         pthread_mutex_lock(&bufmgr_gem->lock);
1797
1798         for (i = start; i < bo_gem->reloc_count; i++) {
1799                 drm_intel_bo_gem *target_bo_gem = (drm_intel_bo_gem *) bo_gem->reloc_target_info[i].bo;
1800                 if (&target_bo_gem->bo != bo) {
1801                         bo_gem->reloc_tree_fences -= target_bo_gem->reloc_tree_fences;
1802                         drm_intel_gem_bo_unreference_locked_timed(&target_bo_gem->bo,
1803                                                                   time.tv_sec);
1804                 }
1805         }
1806         bo_gem->reloc_count = start;
1807
1808         pthread_mutex_unlock(&bufmgr_gem->lock);
1809
1810 }
1811
1812 /**
1813  * Walk the tree of relocations rooted at BO and accumulate the list of
1814  * validations to be performed and update the relocation buffers with
1815  * index values into the validation list.
1816  */
1817 static void
1818 drm_intel_gem_bo_process_reloc(drm_intel_bo *bo)
1819 {
1820         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1821         int i;
1822
1823         if (bo_gem->relocs == NULL)
1824                 return;
1825
1826         for (i = 0; i < bo_gem->reloc_count; i++) {
1827                 drm_intel_bo *target_bo = bo_gem->reloc_target_info[i].bo;
1828
1829                 if (target_bo == bo)
1830                         continue;
1831
1832                 drm_intel_gem_bo_mark_mmaps_incoherent(bo);
1833
1834                 /* Continue walking the tree depth-first. */
1835                 drm_intel_gem_bo_process_reloc(target_bo);
1836
1837                 /* Add the target to the validate list */
1838                 drm_intel_add_validate_buffer(target_bo);
1839         }
1840 }
1841
1842 static void
1843 drm_intel_gem_bo_process_reloc2(drm_intel_bo *bo)
1844 {
1845         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
1846         int i;
1847
1848         if (bo_gem->relocs == NULL)
1849                 return;
1850
1851         for (i = 0; i < bo_gem->reloc_count; i++) {
1852                 drm_intel_bo *target_bo = bo_gem->reloc_target_info[i].bo;
1853                 int need_fence;
1854
1855                 if (target_bo == bo)
1856                         continue;
1857
1858                 drm_intel_gem_bo_mark_mmaps_incoherent(bo);
1859
1860                 /* Continue walking the tree depth-first. */
1861                 drm_intel_gem_bo_process_reloc2(target_bo);
1862
1863                 need_fence = (bo_gem->reloc_target_info[i].flags &
1864                               DRM_INTEL_RELOC_FENCE);
1865
1866                 /* Add the target to the validate list */
1867                 drm_intel_add_validate_buffer2(target_bo, need_fence);
1868         }
1869 }
1870
1871
1872 static void
1873 drm_intel_update_buffer_offsets(drm_intel_bufmgr_gem *bufmgr_gem)
1874 {
1875         int i;
1876
1877         for (i = 0; i < bufmgr_gem->exec_count; i++) {
1878                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
1879                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1880
1881                 /* Update the buffer offset */
1882                 if (bufmgr_gem->exec_objects[i].offset != bo->offset64) {
1883                         DBG("BO %d (%s) migrated: 0x%08lx -> 0x%08llx\n",
1884                             bo_gem->gem_handle, bo_gem->name, bo->offset64,
1885                             (unsigned long long)bufmgr_gem->exec_objects[i].
1886                             offset);
1887                         bo->offset64 = bufmgr_gem->exec_objects[i].offset;
1888                         bo->offset = bufmgr_gem->exec_objects[i].offset;
1889                 }
1890         }
1891 }
1892
1893 static void
1894 drm_intel_update_buffer_offsets2 (drm_intel_bufmgr_gem *bufmgr_gem)
1895 {
1896         int i;
1897
1898         for (i = 0; i < bufmgr_gem->exec_count; i++) {
1899                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
1900                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
1901
1902                 /* Update the buffer offset */
1903                 if (bufmgr_gem->exec2_objects[i].offset != bo->offset64) {
1904                         DBG("BO %d (%s) migrated: 0x%08lx -> 0x%08llx\n",
1905                             bo_gem->gem_handle, bo_gem->name, bo->offset64,
1906                             (unsigned long long)bufmgr_gem->exec2_objects[i].offset);
1907                         bo->offset64 = bufmgr_gem->exec2_objects[i].offset;
1908                         bo->offset = bufmgr_gem->exec2_objects[i].offset;
1909                 }
1910         }
1911 }
1912
1913 static void
1914 aub_out(drm_intel_bufmgr_gem *bufmgr_gem, uint32_t data)
1915 {
1916         fwrite(&data, 1, 4, bufmgr_gem->aub_file);
1917 }
1918
1919 static void
1920 aub_out_data(drm_intel_bufmgr_gem *bufmgr_gem, void *data, size_t size)
1921 {
1922         fwrite(data, 1, size, bufmgr_gem->aub_file);
1923 }
1924
1925 static void
1926 aub_write_bo_data(drm_intel_bo *bo, uint32_t offset, uint32_t size)
1927 {
1928         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1929         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1930         uint32_t *data;
1931         unsigned int i;
1932
1933         data = malloc(bo->size);
1934         drm_intel_bo_get_subdata(bo, offset, size, data);
1935
1936         /* Easy mode: write out bo with no relocations */
1937         if (!bo_gem->reloc_count) {
1938                 aub_out_data(bufmgr_gem, data, size);
1939                 free(data);
1940                 return;
1941         }
1942
1943         /* Otherwise, handle the relocations while writing. */
1944         for (i = 0; i < size / 4; i++) {
1945                 int r;
1946                 for (r = 0; r < bo_gem->reloc_count; r++) {
1947                         struct drm_i915_gem_relocation_entry *reloc;
1948                         drm_intel_reloc_target *info;
1949
1950                         reloc = &bo_gem->relocs[r];
1951                         info = &bo_gem->reloc_target_info[r];
1952
1953                         if (reloc->offset == offset + i * 4) {
1954                                 drm_intel_bo_gem *target_gem;
1955                                 uint32_t val;
1956
1957                                 target_gem = (drm_intel_bo_gem *)info->bo;
1958
1959                                 val = reloc->delta;
1960                                 val += target_gem->aub_offset;
1961
1962                                 aub_out(bufmgr_gem, val);
1963                                 data[i] = val;
1964                                 break;
1965                         }
1966                 }
1967                 if (r == bo_gem->reloc_count) {
1968                         /* no relocation, just the data */
1969                         aub_out(bufmgr_gem, data[i]);
1970                 }
1971         }
1972
1973         free(data);
1974 }
1975
1976 static void
1977 aub_bo_get_address(drm_intel_bo *bo)
1978 {
1979         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1980         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1981
1982         /* Give the object a graphics address in the AUB file.  We
1983          * don't just use the GEM object address because we do AUB
1984          * dumping before execution -- we want to successfully log
1985          * when the hardware might hang, and we might even want to aub
1986          * capture for a driver trying to execute on a different
1987          * generation of hardware by disabling the actual kernel exec
1988          * call.
1989          */
1990         bo_gem->aub_offset = bufmgr_gem->aub_offset;
1991         bufmgr_gem->aub_offset += bo->size;
1992         /* XXX: Handle aperture overflow. */
1993         assert(bufmgr_gem->aub_offset < 256 * 1024 * 1024);
1994 }
1995
1996 static void
1997 aub_write_trace_block(drm_intel_bo *bo, uint32_t type, uint32_t subtype,
1998                       uint32_t offset, uint32_t size)
1999 {
2000         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2001         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2002
2003         aub_out(bufmgr_gem,
2004                 CMD_AUB_TRACE_HEADER_BLOCK |
2005                 ((bufmgr_gem->gen >= 8 ? 6 : 5) - 2));
2006         aub_out(bufmgr_gem,
2007                 AUB_TRACE_MEMTYPE_GTT | type | AUB_TRACE_OP_DATA_WRITE);
2008         aub_out(bufmgr_gem, subtype);
2009         aub_out(bufmgr_gem, bo_gem->aub_offset + offset);
2010         aub_out(bufmgr_gem, size);
2011         if (bufmgr_gem->gen >= 8)
2012                 aub_out(bufmgr_gem, 0);
2013         aub_write_bo_data(bo, offset, size);
2014 }
2015
2016 /**
2017  * Break up large objects into multiple writes.  Otherwise a 128kb VBO
2018  * would overflow the 16 bits of size field in the packet header and
2019  * everything goes badly after that.
2020  */
2021 static void
2022 aub_write_large_trace_block(drm_intel_bo *bo, uint32_t type, uint32_t subtype,
2023                             uint32_t offset, uint32_t size)
2024 {
2025         uint32_t block_size;
2026         uint32_t sub_offset;
2027
2028         for (sub_offset = 0; sub_offset < size; sub_offset += block_size) {
2029                 block_size = size - sub_offset;
2030
2031                 if (block_size > 8 * 4096)
2032                         block_size = 8 * 4096;
2033
2034                 aub_write_trace_block(bo, type, subtype, offset + sub_offset,
2035                                       block_size);
2036         }
2037 }
2038
2039 static void
2040 aub_write_bo(drm_intel_bo *bo)
2041 {
2042         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2043         uint32_t offset = 0;
2044         unsigned i;
2045
2046         aub_bo_get_address(bo);
2047
2048         /* Write out each annotated section separately. */
2049         for (i = 0; i < bo_gem->aub_annotation_count; ++i) {
2050                 drm_intel_aub_annotation *annotation =
2051                         &bo_gem->aub_annotations[i];
2052                 uint32_t ending_offset = annotation->ending_offset;
2053                 if (ending_offset > bo->size)
2054                         ending_offset = bo->size;
2055                 if (ending_offset > offset) {
2056                         aub_write_large_trace_block(bo, annotation->type,
2057                                                     annotation->subtype,
2058                                                     offset,
2059                                                     ending_offset - offset);
2060                         offset = ending_offset;
2061                 }
2062         }
2063
2064         /* Write out any remaining unannotated data */
2065         if (offset < bo->size) {
2066                 aub_write_large_trace_block(bo, AUB_TRACE_TYPE_NOTYPE, 0,
2067                                             offset, bo->size - offset);
2068         }
2069 }
2070
2071 /*
2072  * Make a ringbuffer on fly and dump it
2073  */
2074 static void
2075 aub_build_dump_ringbuffer(drm_intel_bufmgr_gem *bufmgr_gem,
2076                           uint32_t batch_buffer, int ring_flag)
2077 {
2078         uint32_t ringbuffer[4096];
2079         int ring = AUB_TRACE_TYPE_RING_PRB0; /* The default ring */
2080         int ring_count = 0;
2081
2082         if (ring_flag == I915_EXEC_BSD)
2083                 ring = AUB_TRACE_TYPE_RING_PRB1;
2084         else if (ring_flag == I915_EXEC_BLT)
2085                 ring = AUB_TRACE_TYPE_RING_PRB2;
2086
2087         /* Make a ring buffer to execute our batchbuffer. */
2088         memset(ringbuffer, 0, sizeof(ringbuffer));
2089         if (bufmgr_gem->gen >= 8) {
2090                 ringbuffer[ring_count++] = AUB_MI_BATCH_BUFFER_START | (3 - 2);
2091                 ringbuffer[ring_count++] = batch_buffer;
2092                 ringbuffer[ring_count++] = 0;
2093         } else {
2094                 ringbuffer[ring_count++] = AUB_MI_BATCH_BUFFER_START;
2095                 ringbuffer[ring_count++] = batch_buffer;
2096         }
2097
2098         /* Write out the ring.  This appears to trigger execution of
2099          * the ring in the simulator.
2100          */
2101         aub_out(bufmgr_gem,
2102                 CMD_AUB_TRACE_HEADER_BLOCK |
2103                 ((bufmgr_gem->gen >= 8 ? 6 : 5) - 2));
2104         aub_out(bufmgr_gem,
2105                 AUB_TRACE_MEMTYPE_GTT | ring | AUB_TRACE_OP_COMMAND_WRITE);
2106         aub_out(bufmgr_gem, 0); /* general/surface subtype */
2107         aub_out(bufmgr_gem, bufmgr_gem->aub_offset);
2108         aub_out(bufmgr_gem, ring_count * 4);
2109         if (bufmgr_gem->gen >= 8)
2110                 aub_out(bufmgr_gem, 0);
2111
2112         /* FIXME: Need some flush operations here? */
2113         aub_out_data(bufmgr_gem, ringbuffer, ring_count * 4);
2114
2115         /* Update offset pointer */
2116         bufmgr_gem->aub_offset += 4096;
2117 }
2118
2119 drm_public void
2120 drm_intel_gem_bo_aub_dump_bmp(drm_intel_bo *bo,
2121                               int x1, int y1, int width, int height,
2122                               enum aub_dump_bmp_format format,
2123                               int pitch, int offset)
2124 {
2125         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2126         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
2127         uint32_t cpp;
2128
2129         switch (format) {
2130         case AUB_DUMP_BMP_FORMAT_8BIT:
2131                 cpp = 1;
2132                 break;
2133         case AUB_DUMP_BMP_FORMAT_ARGB_4444:
2134                 cpp = 2;
2135                 break;
2136         case AUB_DUMP_BMP_FORMAT_ARGB_0888:
2137         case AUB_DUMP_BMP_FORMAT_ARGB_8888:
2138                 cpp = 4;
2139                 break;
2140         default:
2141                 printf("Unknown AUB dump format %d\n", format);
2142                 return;
2143         }
2144
2145         if (!bufmgr_gem->aub_file)
2146                 return;
2147
2148         aub_out(bufmgr_gem, CMD_AUB_DUMP_BMP | 4);
2149         aub_out(bufmgr_gem, (y1 << 16) | x1);
2150         aub_out(bufmgr_gem,
2151                 (format << 24) |
2152                 (cpp << 19) |
2153                 pitch / 4);
2154         aub_out(bufmgr_gem, (height << 16) | width);
2155         aub_out(bufmgr_gem, bo_gem->aub_offset + offset);
2156         aub_out(bufmgr_gem,
2157                 ((bo_gem->tiling_mode != I915_TILING_NONE) ? (1 << 2) : 0) |
2158                 ((bo_gem->tiling_mode == I915_TILING_Y) ? (1 << 3) : 0));
2159 }
2160
2161 static void
2162 aub_exec(drm_intel_bo *bo, int ring_flag, int used)
2163 {
2164         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2165         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2166         int i;
2167         bool batch_buffer_needs_annotations;
2168
2169         if (!bufmgr_gem->aub_file)
2170                 return;
2171
2172         /* If batch buffer is not annotated, annotate it the best we
2173          * can.
2174          */
2175         batch_buffer_needs_annotations = bo_gem->aub_annotation_count == 0;
2176         if (batch_buffer_needs_annotations) {
2177                 drm_intel_aub_annotation annotations[2] = {
2178                         { AUB_TRACE_TYPE_BATCH, 0, used },
2179                         { AUB_TRACE_TYPE_NOTYPE, 0, bo->size }
2180                 };
2181                 drm_intel_bufmgr_gem_set_aub_annotations(bo, annotations, 2);
2182         }
2183
2184         /* Write out all buffers to AUB memory */
2185         for (i = 0; i < bufmgr_gem->exec_count; i++) {
2186                 aub_write_bo(bufmgr_gem->exec_bos[i]);
2187         }
2188
2189         /* Remove any annotations we added */
2190         if (batch_buffer_needs_annotations)
2191                 drm_intel_bufmgr_gem_set_aub_annotations(bo, NULL, 0);
2192
2193         /* Dump ring buffer */
2194         aub_build_dump_ringbuffer(bufmgr_gem, bo_gem->aub_offset, ring_flag);
2195
2196         fflush(bufmgr_gem->aub_file);
2197
2198         /*
2199          * One frame has been dumped. So reset the aub_offset for the next frame.
2200          *
2201          * FIXME: Can we do this?
2202          */
2203         bufmgr_gem->aub_offset = 0x10000;
2204 }
2205
2206 static int
2207 drm_intel_gem_bo_exec(drm_intel_bo *bo, int used,
2208                       drm_clip_rect_t * cliprects, int num_cliprects, int DR4)
2209 {
2210         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2211         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2212         struct drm_i915_gem_execbuffer execbuf;
2213         int ret, i;
2214
2215         if (bo_gem->has_error)
2216                 return -ENOMEM;
2217
2218         pthread_mutex_lock(&bufmgr_gem->lock);
2219         /* Update indices and set up the validate list. */
2220         drm_intel_gem_bo_process_reloc(bo);
2221
2222         /* Add the batch buffer to the validation list.  There are no
2223          * relocations pointing to it.
2224          */
2225         drm_intel_add_validate_buffer(bo);
2226
2227         VG_CLEAR(execbuf);
2228         execbuf.buffers_ptr = (uintptr_t) bufmgr_gem->exec_objects;
2229         execbuf.buffer_count = bufmgr_gem->exec_count;
2230         execbuf.batch_start_offset = 0;
2231         execbuf.batch_len = used;
2232         execbuf.cliprects_ptr = (uintptr_t) cliprects;
2233         execbuf.num_cliprects = num_cliprects;
2234         execbuf.DR1 = 0;
2235         execbuf.DR4 = DR4;
2236
2237         ret = drmIoctl(bufmgr_gem->fd,
2238                        DRM_IOCTL_I915_GEM_EXECBUFFER,
2239                        &execbuf);
2240         if (ret != 0) {
2241                 ret = -errno;
2242                 if (errno == ENOSPC) {
2243                         DBG("Execbuffer fails to pin. "
2244                             "Estimate: %u. Actual: %u. Available: %u\n",
2245                             drm_intel_gem_estimate_batch_space(bufmgr_gem->exec_bos,
2246                                                                bufmgr_gem->
2247                                                                exec_count),
2248                             drm_intel_gem_compute_batch_space(bufmgr_gem->exec_bos,
2249                                                               bufmgr_gem->
2250                                                               exec_count),
2251                             (unsigned int)bufmgr_gem->gtt_size);
2252                 }
2253         }
2254         drm_intel_update_buffer_offsets(bufmgr_gem);
2255
2256         if (bufmgr_gem->bufmgr.debug)
2257                 drm_intel_gem_dump_validation_list(bufmgr_gem);
2258
2259         for (i = 0; i < bufmgr_gem->exec_count; i++) {
2260                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
2261                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2262
2263                 bo_gem->idle = false;
2264
2265                 /* Disconnect the buffer from the validate list */
2266                 bo_gem->validate_index = -1;
2267                 bufmgr_gem->exec_bos[i] = NULL;
2268         }
2269         bufmgr_gem->exec_count = 0;
2270         pthread_mutex_unlock(&bufmgr_gem->lock);
2271
2272         return ret;
2273 }
2274
2275 static int
2276 do_exec2(drm_intel_bo *bo, int used, drm_intel_context *ctx,
2277          drm_clip_rect_t *cliprects, int num_cliprects, int DR4,
2278          unsigned int flags)
2279 {
2280         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
2281         struct drm_i915_gem_execbuffer2 execbuf;
2282         int ret = 0;
2283         int i;
2284
2285         switch (flags & 0x7) {
2286         default:
2287                 return -EINVAL;
2288         case I915_EXEC_BLT:
2289                 if (!bufmgr_gem->has_blt)
2290                         return -EINVAL;
2291                 break;
2292         case I915_EXEC_BSD:
2293                 if (!bufmgr_gem->has_bsd)
2294                         return -EINVAL;
2295                 break;
2296         case I915_EXEC_VEBOX:
2297                 if (!bufmgr_gem->has_vebox)
2298                         return -EINVAL;
2299                 break;
2300         case I915_EXEC_RENDER:
2301         case I915_EXEC_DEFAULT:
2302                 break;
2303         }
2304
2305         pthread_mutex_lock(&bufmgr_gem->lock);
2306         /* Update indices and set up the validate list. */
2307         drm_intel_gem_bo_process_reloc2(bo);
2308
2309         /* Add the batch buffer to the validation list.  There are no relocations
2310          * pointing to it.
2311          */
2312         drm_intel_add_validate_buffer2(bo, 0);
2313
2314         VG_CLEAR(execbuf);
2315         execbuf.buffers_ptr = (uintptr_t)bufmgr_gem->exec2_objects;
2316         execbuf.buffer_count = bufmgr_gem->exec_count;
2317         execbuf.batch_start_offset = 0;
2318         execbuf.batch_len = used;
2319         execbuf.cliprects_ptr = (uintptr_t)cliprects;
2320         execbuf.num_cliprects = num_cliprects;
2321         execbuf.DR1 = 0;
2322         execbuf.DR4 = DR4;
2323         execbuf.flags = flags;
2324         if (ctx == NULL)
2325                 i915_execbuffer2_set_context_id(execbuf, 0);
2326         else
2327                 i915_execbuffer2_set_context_id(execbuf, ctx->ctx_id);
2328         execbuf.rsvd2 = 0;
2329
2330         aub_exec(bo, flags, used);
2331
2332         if (bufmgr_gem->no_exec)
2333                 goto skip_execution;
2334
2335         ret = drmIoctl(bufmgr_gem->fd,
2336                        DRM_IOCTL_I915_GEM_EXECBUFFER2,
2337                        &execbuf);
2338         if (ret != 0) {
2339                 ret = -errno;
2340                 if (ret == -ENOSPC) {
2341                         DBG("Execbuffer fails to pin. "
2342                             "Estimate: %u. Actual: %u. Available: %u\n",
2343                             drm_intel_gem_estimate_batch_space(bufmgr_gem->exec_bos,
2344                                                                bufmgr_gem->exec_count),
2345                             drm_intel_gem_compute_batch_space(bufmgr_gem->exec_bos,
2346                                                               bufmgr_gem->exec_count),
2347                             (unsigned int) bufmgr_gem->gtt_size);
2348                 }
2349         }
2350         drm_intel_update_buffer_offsets2(bufmgr_gem);
2351
2352 skip_execution:
2353         if (bufmgr_gem->bufmgr.debug)
2354                 drm_intel_gem_dump_validation_list(bufmgr_gem);
2355
2356         for (i = 0; i < bufmgr_gem->exec_count; i++) {
2357                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
2358                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
2359
2360                 bo_gem->idle = false;
2361
2362                 /* Disconnect the buffer from the validate list */
2363                 bo_gem->validate_index = -1;
2364                 bufmgr_gem->exec_bos[i] = NULL;
2365         }
2366         bufmgr_gem->exec_count = 0;
2367         pthread_mutex_unlock(&bufmgr_gem->lock);
2368
2369         return ret;
2370 }
2371
2372 static int
2373 drm_intel_gem_bo_exec2(drm_intel_bo *bo, int used,
2374                        drm_clip_rect_t *cliprects, int num_cliprects,
2375                        int DR4)
2376 {
2377         return do_exec2(bo, used, NULL, cliprects, num_cliprects, DR4,
2378                         I915_EXEC_RENDER);
2379 }
2380
2381 static int
2382 drm_intel_gem_bo_mrb_exec2(drm_intel_bo *bo, int used,
2383                         drm_clip_rect_t *cliprects, int num_cliprects, int DR4,
2384                         unsigned int flags)
2385 {
2386         return do_exec2(bo, used, NULL, cliprects, num_cliprects, DR4,
2387                         flags);
2388 }
2389
2390 drm_public int
2391 drm_intel_gem_bo_context_exec(drm_intel_bo *bo, drm_intel_context *ctx,
2392                               int used, unsigned int flags)
2393 {
2394         return do_exec2(bo, used, ctx, NULL, 0, 0, flags);
2395 }
2396
2397 static int
2398 drm_intel_gem_bo_pin(drm_intel_bo *bo, uint32_t alignment)
2399 {
2400         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2401         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2402         struct drm_i915_gem_pin pin;
2403         int ret;
2404
2405         VG_CLEAR(pin);
2406         pin.handle = bo_gem->gem_handle;
2407         pin.alignment = alignment;
2408
2409         ret = drmIoctl(bufmgr_gem->fd,
2410                        DRM_IOCTL_I915_GEM_PIN,
2411                        &pin);
2412         if (ret != 0)
2413                 return -errno;
2414
2415         bo->offset64 = pin.offset;
2416         bo->offset = pin.offset;
2417         return 0;
2418 }
2419
2420 static int
2421 drm_intel_gem_bo_unpin(drm_intel_bo *bo)
2422 {
2423         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2424         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2425         struct drm_i915_gem_unpin unpin;
2426         int ret;
2427
2428         VG_CLEAR(unpin);
2429         unpin.handle = bo_gem->gem_handle;
2430
2431         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_UNPIN, &unpin);
2432         if (ret != 0)
2433                 return -errno;
2434
2435         return 0;
2436 }
2437
2438 static int
2439 drm_intel_gem_bo_set_tiling_internal(drm_intel_bo *bo,
2440                                      uint32_t tiling_mode,
2441                                      uint32_t stride)
2442 {
2443         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2444         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2445         struct drm_i915_gem_set_tiling set_tiling;
2446         int ret;
2447
2448         if (bo_gem->global_name == 0 &&
2449             tiling_mode == bo_gem->tiling_mode &&
2450             stride == bo_gem->stride)
2451                 return 0;
2452
2453         memset(&set_tiling, 0, sizeof(set_tiling));
2454         do {
2455                 /* set_tiling is slightly broken and overwrites the
2456                  * input on the error path, so we have to open code
2457                  * rmIoctl.
2458                  */
2459                 set_tiling.handle = bo_gem->gem_handle;
2460                 set_tiling.tiling_mode = tiling_mode;
2461                 set_tiling.stride = stride;
2462
2463                 ret = ioctl(bufmgr_gem->fd,
2464                             DRM_IOCTL_I915_GEM_SET_TILING,
2465                             &set_tiling);
2466         } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
2467         if (ret == -1)
2468                 return -errno;
2469
2470         bo_gem->tiling_mode = set_tiling.tiling_mode;
2471         bo_gem->swizzle_mode = set_tiling.swizzle_mode;
2472         bo_gem->stride = set_tiling.stride;
2473         return 0;
2474 }
2475
2476 static int
2477 drm_intel_gem_bo_set_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
2478                             uint32_t stride)
2479 {
2480         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2481         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2482         int ret;
2483
2484         /* Linear buffers have no stride. By ensuring that we only ever use
2485          * stride 0 with linear buffers, we simplify our code.
2486          */
2487         if (*tiling_mode == I915_TILING_NONE)
2488                 stride = 0;
2489
2490         ret = drm_intel_gem_bo_set_tiling_internal(bo, *tiling_mode, stride);
2491         if (ret == 0)
2492                 drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem);
2493
2494         *tiling_mode = bo_gem->tiling_mode;
2495         return ret;
2496 }
2497
2498 static int
2499 drm_intel_gem_bo_get_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
2500                             uint32_t * swizzle_mode)
2501 {
2502         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2503
2504         *tiling_mode = bo_gem->tiling_mode;
2505         *swizzle_mode = bo_gem->swizzle_mode;
2506         return 0;
2507 }
2508
2509 drm_public drm_intel_bo *
2510 drm_intel_bo_gem_create_from_prime(drm_intel_bufmgr *bufmgr, int prime_fd, int size)
2511 {
2512         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
2513         int ret;
2514         uint32_t handle;
2515         drm_intel_bo_gem *bo_gem;
2516         struct drm_i915_gem_get_tiling get_tiling;
2517         drmMMListHead *list;
2518
2519         ret = drmPrimeFDToHandle(bufmgr_gem->fd, prime_fd, &handle);
2520
2521         /*
2522          * See if the kernel has already returned this buffer to us. Just as
2523          * for named buffers, we must not create two bo's pointing at the same
2524          * kernel object
2525          */
2526         for (list = bufmgr_gem->named.next;
2527              list != &bufmgr_gem->named;
2528              list = list->next) {
2529                 bo_gem = DRMLISTENTRY(drm_intel_bo_gem, list, name_list);
2530                 if (bo_gem->gem_handle == handle) {
2531                         drm_intel_gem_bo_reference(&bo_gem->bo);
2532                         return &bo_gem->bo;
2533                 }
2534         }
2535
2536         if (ret) {
2537           fprintf(stderr,"ret is %d %d\n", ret, errno);
2538                 return NULL;
2539         }
2540
2541         bo_gem = calloc(1, sizeof(*bo_gem));
2542         if (!bo_gem)
2543                 return NULL;
2544
2545         /* Determine size of bo.  The fd-to-handle ioctl really should
2546          * return the size, but it doesn't.  If we have kernel 3.12 or
2547          * later, we can lseek on the prime fd to get the size.  Older
2548          * kernels will just fail, in which case we fall back to the
2549          * provided (estimated or guess size). */
2550         ret = lseek(prime_fd, 0, SEEK_END);
2551         if (ret != -1)
2552                 bo_gem->bo.size = ret;
2553         else
2554                 bo_gem->bo.size = size;
2555
2556         bo_gem->bo.handle = handle;
2557         bo_gem->bo.bufmgr = bufmgr;
2558
2559         bo_gem->gem_handle = handle;
2560
2561         atomic_set(&bo_gem->refcount, 1);
2562
2563         bo_gem->name = "prime";
2564         bo_gem->validate_index = -1;
2565         bo_gem->reloc_tree_fences = 0;
2566         bo_gem->used_as_reloc_target = false;
2567         bo_gem->has_error = false;
2568         bo_gem->reusable = false;
2569
2570         DRMINITLISTHEAD(&bo_gem->vma_list);
2571         DRMLISTADDTAIL(&bo_gem->name_list, &bufmgr_gem->named);
2572
2573         VG_CLEAR(get_tiling);
2574         get_tiling.handle = bo_gem->gem_handle;
2575         ret = drmIoctl(bufmgr_gem->fd,
2576                        DRM_IOCTL_I915_GEM_GET_TILING,
2577                        &get_tiling);
2578         if (ret != 0) {
2579                 drm_intel_gem_bo_unreference(&bo_gem->bo);
2580                 return NULL;
2581         }
2582         bo_gem->tiling_mode = get_tiling.tiling_mode;
2583         bo_gem->swizzle_mode = get_tiling.swizzle_mode;
2584         /* XXX stride is unknown */
2585         drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem);
2586
2587         return &bo_gem->bo;
2588 }
2589
2590 drm_public int
2591 drm_intel_bo_gem_export_to_prime(drm_intel_bo *bo, int *prime_fd)
2592 {
2593         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2594         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2595
2596         if (DRMLISTEMPTY(&bo_gem->name_list))
2597                 DRMLISTADDTAIL(&bo_gem->name_list, &bufmgr_gem->named);
2598
2599         if (drmPrimeHandleToFD(bufmgr_gem->fd, bo_gem->gem_handle,
2600                                DRM_CLOEXEC, prime_fd) != 0)
2601                 return -errno;
2602
2603         bo_gem->reusable = false;
2604
2605         return 0;
2606 }
2607
2608 static int
2609 drm_intel_gem_bo_flink(drm_intel_bo *bo, uint32_t * name)
2610 {
2611         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2612         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2613         int ret;
2614
2615         if (!bo_gem->global_name) {
2616                 struct drm_gem_flink flink;
2617
2618                 VG_CLEAR(flink);
2619                 flink.handle = bo_gem->gem_handle;
2620
2621                 ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_GEM_FLINK, &flink);
2622                 if (ret != 0)
2623                         return -errno;
2624
2625                 bo_gem->global_name = flink.name;
2626                 bo_gem->reusable = false;
2627
2628                 if (DRMLISTEMPTY(&bo_gem->name_list))
2629                         DRMLISTADDTAIL(&bo_gem->name_list, &bufmgr_gem->named);
2630         }
2631
2632         *name = bo_gem->global_name;
2633         return 0;
2634 }
2635
2636 /**
2637  * Enables unlimited caching of buffer objects for reuse.
2638  *
2639  * This is potentially very memory expensive, as the cache at each bucket
2640  * size is only bounded by how many buffers of that size we've managed to have
2641  * in flight at once.
2642  */
2643 drm_public void
2644 drm_intel_bufmgr_gem_enable_reuse(drm_intel_bufmgr *bufmgr)
2645 {
2646         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
2647
2648         bufmgr_gem->bo_reuse = true;
2649 }
2650
2651 /**
2652  * Enable use of fenced reloc type.
2653  *
2654  * New code should enable this to avoid unnecessary fence register
2655  * allocation.  If this option is not enabled, all relocs will have fence
2656  * register allocated.
2657  */
2658 drm_public void
2659 drm_intel_bufmgr_gem_enable_fenced_relocs(drm_intel_bufmgr *bufmgr)
2660 {
2661         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
2662
2663         if (bufmgr_gem->bufmgr.bo_exec == drm_intel_gem_bo_exec2)
2664                 bufmgr_gem->fenced_relocs = true;
2665 }
2666
2667 /**
2668  * Return the additional aperture space required by the tree of buffer objects
2669  * rooted at bo.
2670  */
2671 static int
2672 drm_intel_gem_bo_get_aperture_space(drm_intel_bo *bo)
2673 {
2674         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2675         int i;
2676         int total = 0;
2677
2678         if (bo == NULL || bo_gem->included_in_check_aperture)
2679                 return 0;
2680
2681         total += bo->size;
2682         bo_gem->included_in_check_aperture = true;
2683
2684         for (i = 0; i < bo_gem->reloc_count; i++)
2685                 total +=
2686                     drm_intel_gem_bo_get_aperture_space(bo_gem->
2687                                                         reloc_target_info[i].bo);
2688
2689         return total;
2690 }
2691
2692 /**
2693  * Count the number of buffers in this list that need a fence reg
2694  *
2695  * If the count is greater than the number of available regs, we'll have
2696  * to ask the caller to resubmit a batch with fewer tiled buffers.
2697  *
2698  * This function over-counts if the same buffer is used multiple times.
2699  */
2700 static unsigned int
2701 drm_intel_gem_total_fences(drm_intel_bo ** bo_array, int count)
2702 {
2703         int i;
2704         unsigned int total = 0;
2705
2706         for (i = 0; i < count; i++) {
2707                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo_array[i];
2708
2709                 if (bo_gem == NULL)
2710                         continue;
2711
2712                 total += bo_gem->reloc_tree_fences;
2713         }
2714         return total;
2715 }
2716
2717 /**
2718  * Clear the flag set by drm_intel_gem_bo_get_aperture_space() so we're ready
2719  * for the next drm_intel_bufmgr_check_aperture_space() call.
2720  */
2721 static void
2722 drm_intel_gem_bo_clear_aperture_space_flag(drm_intel_bo *bo)
2723 {
2724         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2725         int i;
2726
2727         if (bo == NULL || !bo_gem->included_in_check_aperture)
2728                 return;
2729
2730         bo_gem->included_in_check_aperture = false;
2731
2732         for (i = 0; i < bo_gem->reloc_count; i++)
2733                 drm_intel_gem_bo_clear_aperture_space_flag(bo_gem->
2734                                                            reloc_target_info[i].bo);
2735 }
2736
2737 /**
2738  * Return a conservative estimate for the amount of aperture required
2739  * for a collection of buffers. This may double-count some buffers.
2740  */
2741 static unsigned int
2742 drm_intel_gem_estimate_batch_space(drm_intel_bo **bo_array, int count)
2743 {
2744         int i;
2745         unsigned int total = 0;
2746
2747         for (i = 0; i < count; i++) {
2748                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo_array[i];
2749                 if (bo_gem != NULL)
2750                         total += bo_gem->reloc_tree_size;
2751         }
2752         return total;
2753 }
2754
2755 /**
2756  * Return the amount of aperture needed for a collection of buffers.
2757  * This avoids double counting any buffers, at the cost of looking
2758  * at every buffer in the set.
2759  */
2760 static unsigned int
2761 drm_intel_gem_compute_batch_space(drm_intel_bo **bo_array, int count)
2762 {
2763         int i;
2764         unsigned int total = 0;
2765
2766         for (i = 0; i < count; i++) {
2767                 total += drm_intel_gem_bo_get_aperture_space(bo_array[i]);
2768                 /* For the first buffer object in the array, we get an
2769                  * accurate count back for its reloc_tree size (since nothing
2770                  * had been flagged as being counted yet).  We can save that
2771                  * value out as a more conservative reloc_tree_size that
2772                  * avoids double-counting target buffers.  Since the first
2773                  * buffer happens to usually be the batch buffer in our
2774                  * callers, this can pull us back from doing the tree
2775                  * walk on every new batch emit.
2776                  */
2777                 if (i == 0) {
2778                         drm_intel_bo_gem *bo_gem =
2779                             (drm_intel_bo_gem *) bo_array[i];
2780                         bo_gem->reloc_tree_size = total;
2781                 }
2782         }
2783
2784         for (i = 0; i < count; i++)
2785                 drm_intel_gem_bo_clear_aperture_space_flag(bo_array[i]);
2786         return total;
2787 }
2788
2789 /**
2790  * Return -1 if the batchbuffer should be flushed before attempting to
2791  * emit rendering referencing the buffers pointed to by bo_array.
2792  *
2793  * This is required because if we try to emit a batchbuffer with relocations
2794  * to a tree of buffers that won't simultaneously fit in the aperture,
2795  * the rendering will return an error at a point where the software is not
2796  * prepared to recover from it.
2797  *
2798  * However, we also want to emit the batchbuffer significantly before we reach
2799  * the limit, as a series of batchbuffers each of which references buffers
2800  * covering almost all of the aperture means that at each emit we end up
2801  * waiting to evict a buffer from the last rendering, and we get synchronous
2802  * performance.  By emitting smaller batchbuffers, we eat some CPU overhead to
2803  * get better parallelism.
2804  */
2805 static int
2806 drm_intel_gem_check_aperture_space(drm_intel_bo **bo_array, int count)
2807 {
2808         drm_intel_bufmgr_gem *bufmgr_gem =
2809             (drm_intel_bufmgr_gem *) bo_array[0]->bufmgr;
2810         unsigned int total = 0;
2811         unsigned int threshold = bufmgr_gem->gtt_size * 3 / 4;
2812         int total_fences;
2813
2814         /* Check for fence reg constraints if necessary */
2815         if (bufmgr_gem->available_fences) {
2816                 total_fences = drm_intel_gem_total_fences(bo_array, count);
2817                 if (total_fences > bufmgr_gem->available_fences)
2818                         return -ENOSPC;
2819         }
2820
2821         total = drm_intel_gem_estimate_batch_space(bo_array, count);
2822
2823         if (total > threshold)
2824                 total = drm_intel_gem_compute_batch_space(bo_array, count);
2825
2826         if (total > threshold) {
2827                 DBG("check_space: overflowed available aperture, "
2828                     "%dkb vs %dkb\n",
2829                     total / 1024, (int)bufmgr_gem->gtt_size / 1024);
2830                 return -ENOSPC;
2831         } else {
2832                 DBG("drm_check_space: total %dkb vs bufgr %dkb\n", total / 1024,
2833                     (int)bufmgr_gem->gtt_size / 1024);
2834                 return 0;
2835         }
2836 }
2837
2838 /*
2839  * Disable buffer reuse for objects which are shared with the kernel
2840  * as scanout buffers
2841  */
2842 static int
2843 drm_intel_gem_bo_disable_reuse(drm_intel_bo *bo)
2844 {
2845         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2846
2847         bo_gem->reusable = false;
2848         return 0;
2849 }
2850
2851 static int
2852 drm_intel_gem_bo_is_reusable(drm_intel_bo *bo)
2853 {
2854         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2855
2856         return bo_gem->reusable;
2857 }
2858
2859 static int
2860 _drm_intel_gem_bo_references(drm_intel_bo *bo, drm_intel_bo *target_bo)
2861 {
2862         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2863         int i;
2864
2865         for (i = 0; i < bo_gem->reloc_count; i++) {
2866                 if (bo_gem->reloc_target_info[i].bo == target_bo)
2867                         return 1;
2868                 if (bo == bo_gem->reloc_target_info[i].bo)
2869                         continue;
2870                 if (_drm_intel_gem_bo_references(bo_gem->reloc_target_info[i].bo,
2871                                                 target_bo))
2872                         return 1;
2873         }
2874
2875         return 0;
2876 }
2877
2878 /** Return true if target_bo is referenced by bo's relocation tree. */
2879 static int
2880 drm_intel_gem_bo_references(drm_intel_bo *bo, drm_intel_bo *target_bo)
2881 {
2882         drm_intel_bo_gem *target_bo_gem = (drm_intel_bo_gem *) target_bo;
2883
2884         if (bo == NULL || target_bo == NULL)
2885                 return 0;
2886         if (target_bo_gem->used_as_reloc_target)
2887                 return _drm_intel_gem_bo_references(bo, target_bo);
2888         return 0;
2889 }
2890
2891 static void
2892 add_bucket(drm_intel_bufmgr_gem *bufmgr_gem, int size)
2893 {
2894         unsigned int i = bufmgr_gem->num_buckets;
2895
2896         assert(i < ARRAY_SIZE(bufmgr_gem->cache_bucket));
2897
2898         DRMINITLISTHEAD(&bufmgr_gem->cache_bucket[i].head);
2899         bufmgr_gem->cache_bucket[i].size = size;
2900         bufmgr_gem->num_buckets++;
2901 }
2902
2903 static void
2904 init_cache_buckets(drm_intel_bufmgr_gem *bufmgr_gem)
2905 {
2906         unsigned long size, cache_max_size = 64 * 1024 * 1024;
2907
2908         /* OK, so power of two buckets was too wasteful of memory.
2909          * Give 3 other sizes between each power of two, to hopefully
2910          * cover things accurately enough.  (The alternative is
2911          * probably to just go for exact matching of sizes, and assume
2912          * that for things like composited window resize the tiled
2913          * width/height alignment and rounding of sizes to pages will
2914          * get us useful cache hit rates anyway)
2915          */
2916         add_bucket(bufmgr_gem, 4096);
2917         add_bucket(bufmgr_gem, 4096 * 2);
2918         add_bucket(bufmgr_gem, 4096 * 3);
2919
2920         /* Initialize the linked lists for BO reuse cache. */
2921         for (size = 4 * 4096; size <= cache_max_size; size *= 2) {
2922                 add_bucket(bufmgr_gem, size);
2923
2924                 add_bucket(bufmgr_gem, size + size * 1 / 4);
2925                 add_bucket(bufmgr_gem, size + size * 2 / 4);
2926                 add_bucket(bufmgr_gem, size + size * 3 / 4);
2927         }
2928 }
2929
2930 drm_public void
2931 drm_intel_bufmgr_gem_set_vma_cache_size(drm_intel_bufmgr *bufmgr, int limit)
2932 {
2933         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
2934
2935         bufmgr_gem->vma_max = limit;
2936
2937         drm_intel_gem_bo_purge_vma_cache(bufmgr_gem);
2938 }
2939
2940 /**
2941  * Get the PCI ID for the device.  This can be overridden by setting the
2942  * INTEL_DEVID_OVERRIDE environment variable to the desired ID.
2943  */
2944 static int
2945 get_pci_device_id(drm_intel_bufmgr_gem *bufmgr_gem)
2946 {
2947         char *devid_override;
2948         int devid;
2949         int ret;
2950         drm_i915_getparam_t gp;
2951
2952         if (geteuid() == getuid()) {
2953                 devid_override = getenv("INTEL_DEVID_OVERRIDE");
2954                 if (devid_override) {
2955                         bufmgr_gem->no_exec = true;
2956                         return strtod(devid_override, NULL);
2957                 }
2958         }
2959
2960         VG_CLEAR(devid);
2961         VG_CLEAR(gp);
2962         gp.param = I915_PARAM_CHIPSET_ID;
2963         gp.value = &devid;
2964         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2965         if (ret) {
2966                 fprintf(stderr, "get chip id failed: %d [%d]\n", ret, errno);
2967                 fprintf(stderr, "param: %d, val: %d\n", gp.param, *gp.value);
2968         }
2969         return devid;
2970 }
2971
2972 drm_public int
2973 drm_intel_bufmgr_gem_get_devid(drm_intel_bufmgr *bufmgr)
2974 {
2975         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
2976
2977         return bufmgr_gem->pci_device;
2978 }
2979
2980 /**
2981  * Sets the AUB filename.
2982  *
2983  * This function has to be called before drm_intel_bufmgr_gem_set_aub_dump()
2984  * for it to have any effect.
2985  */
2986 drm_public void
2987 drm_intel_bufmgr_gem_set_aub_filename(drm_intel_bufmgr *bufmgr,
2988                                       const char *filename)
2989 {
2990         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
2991
2992         free(bufmgr_gem->aub_filename);
2993         if (filename)
2994                 bufmgr_gem->aub_filename = strdup(filename);
2995 }
2996
2997 /**
2998  * Sets up AUB dumping.
2999  *
3000  * This is a trace file format that can be used with the simulator.
3001  * Packets are emitted in a format somewhat like GPU command packets.
3002  * You can set up a GTT and upload your objects into the referenced
3003  * space, then send off batchbuffers and get BMPs out the other end.
3004  */
3005 drm_public void
3006 drm_intel_bufmgr_gem_set_aub_dump(drm_intel_bufmgr *bufmgr, int enable)
3007 {
3008         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
3009         int entry = 0x200003;
3010         int i;
3011         int gtt_size = 0x10000;
3012         const char *filename;
3013
3014         if (!enable) {
3015                 if (bufmgr_gem->aub_file) {
3016                         fclose(bufmgr_gem->aub_file);
3017                         bufmgr_gem->aub_file = NULL;
3018                 }
3019                 return;
3020         }
3021
3022         if (geteuid() != getuid())
3023                 return;
3024
3025         if (bufmgr_gem->aub_filename)
3026                 filename = bufmgr_gem->aub_filename;
3027         else
3028                 filename = "intel.aub";
3029         bufmgr_gem->aub_file = fopen(filename, "w+");
3030         if (!bufmgr_gem->aub_file)
3031                 return;
3032
3033         /* Start allocating objects from just after the GTT. */
3034         bufmgr_gem->aub_offset = gtt_size;
3035
3036         /* Start with a (required) version packet. */
3037         aub_out(bufmgr_gem, CMD_AUB_HEADER | (13 - 2));
3038         aub_out(bufmgr_gem,
3039                 (4 << AUB_HEADER_MAJOR_SHIFT) |
3040                 (0 << AUB_HEADER_MINOR_SHIFT));
3041         for (i = 0; i < 8; i++) {
3042                 aub_out(bufmgr_gem, 0); /* app name */
3043         }
3044         aub_out(bufmgr_gem, 0); /* timestamp */
3045         aub_out(bufmgr_gem, 0); /* timestamp */
3046         aub_out(bufmgr_gem, 0); /* comment len */
3047
3048         /* Set up the GTT. The max we can handle is 256M */
3049         aub_out(bufmgr_gem, CMD_AUB_TRACE_HEADER_BLOCK | ((bufmgr_gem->gen >= 8 ? 6 : 5) - 2));
3050         aub_out(bufmgr_gem, AUB_TRACE_MEMTYPE_NONLOCAL | 0 | AUB_TRACE_OP_DATA_WRITE);
3051         aub_out(bufmgr_gem, 0); /* subtype */
3052         aub_out(bufmgr_gem, 0); /* offset */
3053         aub_out(bufmgr_gem, gtt_size); /* size */
3054         if (bufmgr_gem->gen >= 8)
3055                 aub_out(bufmgr_gem, 0);
3056         for (i = 0x000; i < gtt_size; i += 4, entry += 0x1000) {
3057                 aub_out(bufmgr_gem, entry);
3058         }
3059 }
3060
3061 drm_public drm_intel_context *
3062 drm_intel_gem_context_create(drm_intel_bufmgr *bufmgr)
3063 {
3064         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
3065         struct drm_i915_gem_context_create create;
3066         drm_intel_context *context = NULL;
3067         int ret;
3068
3069         context = calloc(1, sizeof(*context));
3070         if (!context)
3071                 return NULL;
3072
3073         VG_CLEAR(create);
3074         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_CONTEXT_CREATE, &create);
3075         if (ret != 0) {
3076                 DBG("DRM_IOCTL_I915_GEM_CONTEXT_CREATE failed: %s\n",
3077                     strerror(errno));
3078                 free(context);
3079                 return NULL;
3080         }
3081
3082         context->ctx_id = create.ctx_id;
3083         context->bufmgr = bufmgr;
3084
3085         return context;
3086 }
3087
3088 drm_public void
3089 drm_intel_gem_context_destroy(drm_intel_context *ctx)
3090 {
3091         drm_intel_bufmgr_gem *bufmgr_gem;
3092         struct drm_i915_gem_context_destroy destroy;
3093         int ret;
3094
3095         if (ctx == NULL)
3096                 return;
3097
3098         VG_CLEAR(destroy);
3099
3100         bufmgr_gem = (drm_intel_bufmgr_gem *)ctx->bufmgr;
3101         destroy.ctx_id = ctx->ctx_id;
3102         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_CONTEXT_DESTROY,
3103                        &destroy);
3104         if (ret != 0)
3105                 fprintf(stderr, "DRM_IOCTL_I915_GEM_CONTEXT_DESTROY failed: %s\n",
3106                         strerror(errno));
3107
3108         free(ctx);
3109 }
3110
3111 drm_public int
3112 drm_intel_get_reset_stats(drm_intel_context *ctx,
3113                           uint32_t *reset_count,
3114                           uint32_t *active,
3115                           uint32_t *pending)
3116 {
3117         drm_intel_bufmgr_gem *bufmgr_gem;
3118         struct drm_i915_reset_stats stats;
3119         int ret;
3120
3121         if (ctx == NULL)
3122                 return -EINVAL;
3123
3124         memset(&stats, 0, sizeof(stats));
3125
3126         bufmgr_gem = (drm_intel_bufmgr_gem *)ctx->bufmgr;
3127         stats.ctx_id = ctx->ctx_id;
3128         ret = drmIoctl(bufmgr_gem->fd,
3129                        DRM_IOCTL_I915_GET_RESET_STATS,
3130                        &stats);
3131         if (ret == 0) {
3132                 if (reset_count != NULL)
3133                         *reset_count = stats.reset_count;
3134
3135                 if (active != NULL)
3136                         *active = stats.batch_active;
3137
3138                 if (pending != NULL)
3139                         *pending = stats.batch_pending;
3140         }
3141
3142         return ret;
3143 }
3144
3145 drm_public int
3146 drm_intel_reg_read(drm_intel_bufmgr *bufmgr,
3147                    uint32_t offset,
3148                    uint64_t *result)
3149 {
3150         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
3151         struct drm_i915_reg_read reg_read;
3152         int ret;
3153
3154         VG_CLEAR(reg_read);
3155         reg_read.offset = offset;
3156
3157         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_REG_READ, &reg_read);
3158
3159         *result = reg_read.val;
3160         return ret;
3161 }
3162
3163
3164 /**
3165  * Annotate the given bo for use in aub dumping.
3166  *
3167  * \param annotations is an array of drm_intel_aub_annotation objects
3168  * describing the type of data in various sections of the bo.  Each
3169  * element of the array specifies the type and subtype of a section of
3170  * the bo, and the past-the-end offset of that section.  The elements
3171  * of \c annotations must be sorted so that ending_offset is
3172  * increasing.
3173  *
3174  * \param count is the number of elements in the \c annotations array.
3175  * If \c count is zero, then \c annotations will not be dereferenced.
3176  *
3177  * Annotations are copied into a private data structure, so caller may
3178  * re-use the memory pointed to by \c annotations after the call
3179  * returns.
3180  *
3181  * Annotations are stored for the lifetime of the bo; to reset to the
3182  * default state (no annotations), call this function with a \c count
3183  * of zero.
3184  */
3185 drm_public void
3186 drm_intel_bufmgr_gem_set_aub_annotations(drm_intel_bo *bo,
3187                                          drm_intel_aub_annotation *annotations,
3188                                          unsigned count)
3189 {
3190         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
3191         unsigned size = sizeof(*annotations) * count;
3192         drm_intel_aub_annotation *new_annotations =
3193                 count > 0 ? realloc(bo_gem->aub_annotations, size) : NULL;
3194         if (new_annotations == NULL) {
3195                 free(bo_gem->aub_annotations);
3196                 bo_gem->aub_annotations = NULL;
3197                 bo_gem->aub_annotation_count = 0;
3198                 return;
3199         }
3200         memcpy(new_annotations, annotations, size);
3201         bo_gem->aub_annotations = new_annotations;
3202         bo_gem->aub_annotation_count = count;
3203 }
3204
3205 static pthread_mutex_t bufmgr_list_mutex = PTHREAD_MUTEX_INITIALIZER;
3206 static drmMMListHead bufmgr_list = { &bufmgr_list, &bufmgr_list };
3207
3208 static drm_intel_bufmgr_gem *
3209 drm_intel_bufmgr_gem_find(int fd)
3210 {
3211         drm_intel_bufmgr_gem *bufmgr_gem;
3212
3213         DRMLISTFOREACHENTRY(bufmgr_gem, &bufmgr_list, managers) {
3214                 if (bufmgr_gem->fd == fd) {
3215                         atomic_inc(&bufmgr_gem->refcount);
3216                         return bufmgr_gem;
3217                 }
3218         }
3219
3220         return NULL;
3221 }
3222
3223 static void
3224 drm_intel_bufmgr_gem_unref(drm_intel_bufmgr *bufmgr)
3225 {
3226         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
3227
3228         if (atomic_add_unless(&bufmgr_gem->refcount, -1, 1)) {
3229                 pthread_mutex_lock(&bufmgr_list_mutex);
3230
3231                 if (atomic_dec_and_test(&bufmgr_gem->refcount)) {
3232                         DRMLISTDEL(&bufmgr_gem->managers);
3233                         drm_intel_bufmgr_gem_destroy(bufmgr);
3234                 }
3235
3236                 pthread_mutex_unlock(&bufmgr_list_mutex);
3237         }
3238 }
3239
3240 /**
3241  * Initializes the GEM buffer manager, which uses the kernel to allocate, map,
3242  * and manage map buffer objections.
3243  *
3244  * \param fd File descriptor of the opened DRM device.
3245  */
3246 drm_public drm_intel_bufmgr *
3247 drm_intel_bufmgr_gem_init(int fd, int batch_size)
3248 {
3249         drm_intel_bufmgr_gem *bufmgr_gem;
3250         struct drm_i915_gem_get_aperture aperture;
3251         drm_i915_getparam_t gp;
3252         int ret, tmp;
3253         bool exec2 = false;
3254
3255         pthread_mutex_lock(&bufmgr_list_mutex);
3256
3257         bufmgr_gem = drm_intel_bufmgr_gem_find(fd);
3258         if (bufmgr_gem)
3259                 goto exit;
3260
3261         bufmgr_gem = calloc(1, sizeof(*bufmgr_gem));
3262         if (bufmgr_gem == NULL)
3263                 goto exit;
3264
3265         bufmgr_gem->fd = fd;
3266         atomic_set(&bufmgr_gem->refcount, 1);
3267
3268         if (pthread_mutex_init(&bufmgr_gem->lock, NULL) != 0) {
3269                 free(bufmgr_gem);
3270                 bufmgr_gem = NULL;
3271                 goto exit;
3272         }
3273
3274         ret = drmIoctl(bufmgr_gem->fd,
3275                        DRM_IOCTL_I915_GEM_GET_APERTURE,
3276                        &aperture);
3277
3278         if (ret == 0)
3279                 bufmgr_gem->gtt_size = aperture.aper_available_size;
3280         else {
3281                 fprintf(stderr, "DRM_IOCTL_I915_GEM_APERTURE failed: %s\n",
3282                         strerror(errno));
3283                 bufmgr_gem->gtt_size = 128 * 1024 * 1024;
3284                 fprintf(stderr, "Assuming %dkB available aperture size.\n"
3285                         "May lead to reduced performance or incorrect "
3286                         "rendering.\n",
3287                         (int)bufmgr_gem->gtt_size / 1024);
3288         }
3289
3290         bufmgr_gem->pci_device = get_pci_device_id(bufmgr_gem);
3291
3292         if (IS_GEN2(bufmgr_gem->pci_device))
3293                 bufmgr_gem->gen = 2;
3294         else if (IS_GEN3(bufmgr_gem->pci_device))
3295                 bufmgr_gem->gen = 3;
3296         else if (IS_GEN4(bufmgr_gem->pci_device))
3297                 bufmgr_gem->gen = 4;
3298         else if (IS_GEN5(bufmgr_gem->pci_device))
3299                 bufmgr_gem->gen = 5;
3300         else if (IS_GEN6(bufmgr_gem->pci_device))
3301                 bufmgr_gem->gen = 6;
3302         else if (IS_GEN7(bufmgr_gem->pci_device))
3303                 bufmgr_gem->gen = 7;
3304         else if (IS_GEN8(bufmgr_gem->pci_device))
3305                 bufmgr_gem->gen = 8;
3306         else {
3307                 free(bufmgr_gem);
3308                 bufmgr_gem = NULL;
3309                 goto exit;
3310         }
3311
3312         if (IS_GEN3(bufmgr_gem->pci_device) &&
3313             bufmgr_gem->gtt_size > 256*1024*1024) {
3314                 /* The unmappable part of gtt on gen 3 (i.e. above 256MB) can't
3315                  * be used for tiled blits. To simplify the accounting, just
3316                  * substract the unmappable part (fixed to 256MB on all known
3317                  * gen3 devices) if the kernel advertises it. */
3318                 bufmgr_gem->gtt_size -= 256*1024*1024;
3319         }
3320
3321         VG_CLEAR(gp);
3322         gp.value = &tmp;
3323
3324         gp.param = I915_PARAM_HAS_EXECBUF2;
3325         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3326         if (!ret)
3327                 exec2 = true;
3328
3329         gp.param = I915_PARAM_HAS_BSD;
3330         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3331         bufmgr_gem->has_bsd = ret == 0;
3332
3333         gp.param = I915_PARAM_HAS_BLT;
3334         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3335         bufmgr_gem->has_blt = ret == 0;
3336
3337         gp.param = I915_PARAM_HAS_RELAXED_FENCING;
3338         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3339         bufmgr_gem->has_relaxed_fencing = ret == 0;
3340
3341         gp.param = I915_PARAM_HAS_WAIT_TIMEOUT;
3342         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3343         bufmgr_gem->has_wait_timeout = ret == 0;
3344
3345         gp.param = I915_PARAM_HAS_LLC;
3346         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3347         if (ret != 0) {
3348                 /* Kernel does not supports HAS_LLC query, fallback to GPU
3349                  * generation detection and assume that we have LLC on GEN6/7
3350                  */
3351                 bufmgr_gem->has_llc = (IS_GEN6(bufmgr_gem->pci_device) |
3352                                 IS_GEN7(bufmgr_gem->pci_device));
3353         } else
3354                 bufmgr_gem->has_llc = *gp.value;
3355
3356         gp.param = I915_PARAM_HAS_VEBOX;
3357         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3358         bufmgr_gem->has_vebox = (ret == 0) & (*gp.value > 0);
3359
3360         if (bufmgr_gem->gen < 4) {
3361                 gp.param = I915_PARAM_NUM_FENCES_AVAIL;
3362                 gp.value = &bufmgr_gem->available_fences;
3363                 ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3364                 if (ret) {
3365                         fprintf(stderr, "get fences failed: %d [%d]\n", ret,
3366                                 errno);
3367                         fprintf(stderr, "param: %d, val: %d\n", gp.param,
3368                                 *gp.value);
3369                         bufmgr_gem->available_fences = 0;
3370                 } else {
3371                         /* XXX The kernel reports the total number of fences,
3372                          * including any that may be pinned.
3373                          *
3374                          * We presume that there will be at least one pinned
3375                          * fence for the scanout buffer, but there may be more
3376                          * than one scanout and the user may be manually
3377                          * pinning buffers. Let's move to execbuffer2 and
3378                          * thereby forget the insanity of using fences...
3379                          */
3380                         bufmgr_gem->available_fences -= 2;
3381                         if (bufmgr_gem->available_fences < 0)
3382                                 bufmgr_gem->available_fences = 0;
3383                 }
3384         }
3385
3386         /* Let's go with one relocation per every 2 dwords (but round down a bit
3387          * since a power of two will mean an extra page allocation for the reloc
3388          * buffer).
3389          *
3390          * Every 4 was too few for the blender benchmark.
3391          */
3392         bufmgr_gem->max_relocs = batch_size / sizeof(uint32_t) / 2 - 2;
3393
3394         bufmgr_gem->bufmgr.bo_alloc = drm_intel_gem_bo_alloc;
3395         bufmgr_gem->bufmgr.bo_alloc_for_render =
3396             drm_intel_gem_bo_alloc_for_render;
3397         bufmgr_gem->bufmgr.bo_alloc_tiled = drm_intel_gem_bo_alloc_tiled;
3398         bufmgr_gem->bufmgr.bo_reference = drm_intel_gem_bo_reference;
3399         bufmgr_gem->bufmgr.bo_unreference = drm_intel_gem_bo_unreference;
3400         bufmgr_gem->bufmgr.bo_map = drm_intel_gem_bo_map;
3401         bufmgr_gem->bufmgr.bo_unmap = drm_intel_gem_bo_unmap;
3402         bufmgr_gem->bufmgr.bo_subdata = drm_intel_gem_bo_subdata;
3403         bufmgr_gem->bufmgr.bo_get_subdata = drm_intel_gem_bo_get_subdata;
3404         bufmgr_gem->bufmgr.bo_wait_rendering = drm_intel_gem_bo_wait_rendering;
3405         bufmgr_gem->bufmgr.bo_emit_reloc = drm_intel_gem_bo_emit_reloc;
3406         bufmgr_gem->bufmgr.bo_emit_reloc_fence = drm_intel_gem_bo_emit_reloc_fence;
3407         bufmgr_gem->bufmgr.bo_pin = drm_intel_gem_bo_pin;
3408         bufmgr_gem->bufmgr.bo_unpin = drm_intel_gem_bo_unpin;
3409         bufmgr_gem->bufmgr.bo_get_tiling = drm_intel_gem_bo_get_tiling;
3410         bufmgr_gem->bufmgr.bo_set_tiling = drm_intel_gem_bo_set_tiling;
3411         bufmgr_gem->bufmgr.bo_flink = drm_intel_gem_bo_flink;
3412         /* Use the new one if available */
3413         if (exec2) {
3414                 bufmgr_gem->bufmgr.bo_exec = drm_intel_gem_bo_exec2;
3415                 bufmgr_gem->bufmgr.bo_mrb_exec = drm_intel_gem_bo_mrb_exec2;
3416         } else
3417                 bufmgr_gem->bufmgr.bo_exec = drm_intel_gem_bo_exec;
3418         bufmgr_gem->bufmgr.bo_busy = drm_intel_gem_bo_busy;
3419         bufmgr_gem->bufmgr.bo_madvise = drm_intel_gem_bo_madvise;
3420         bufmgr_gem->bufmgr.destroy = drm_intel_bufmgr_gem_unref;
3421         bufmgr_gem->bufmgr.debug = 0;
3422         bufmgr_gem->bufmgr.check_aperture_space =
3423             drm_intel_gem_check_aperture_space;
3424         bufmgr_gem->bufmgr.bo_disable_reuse = drm_intel_gem_bo_disable_reuse;
3425         bufmgr_gem->bufmgr.bo_is_reusable = drm_intel_gem_bo_is_reusable;
3426         bufmgr_gem->bufmgr.get_pipe_from_crtc_id =
3427             drm_intel_gem_get_pipe_from_crtc_id;
3428         bufmgr_gem->bufmgr.bo_references = drm_intel_gem_bo_references;
3429
3430         DRMINITLISTHEAD(&bufmgr_gem->named);
3431         init_cache_buckets(bufmgr_gem);
3432
3433         DRMINITLISTHEAD(&bufmgr_gem->vma_cache);
3434         bufmgr_gem->vma_max = -1; /* unlimited by default */
3435
3436         DRMLISTADD(&bufmgr_gem->managers, &bufmgr_list);
3437
3438 exit:
3439         pthread_mutex_unlock(&bufmgr_list_mutex);
3440
3441         return bufmgr_gem != NULL ? &bufmgr_gem->bufmgr : NULL;
3442 }