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         if (atomic_dec_and_test(&bo_gem->refcount)) {
1161                 drm_intel_bufmgr_gem *bufmgr_gem =
1162                     (drm_intel_bufmgr_gem *) bo->bufmgr;
1163                 struct timespec time;
1164
1165                 clock_gettime(CLOCK_MONOTONIC, &time);
1166
1167                 pthread_mutex_lock(&bufmgr_gem->lock);
1168                 drm_intel_gem_bo_unreference_final(bo, time.tv_sec);
1169                 drm_intel_gem_cleanup_bo_cache(bufmgr_gem, time.tv_sec);
1170                 pthread_mutex_unlock(&bufmgr_gem->lock);
1171         }
1172 }
1173
1174 static int drm_intel_gem_bo_map(drm_intel_bo *bo, int write_enable)
1175 {
1176         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1177         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1178         struct drm_i915_gem_set_domain set_domain;
1179         int ret;
1180
1181         pthread_mutex_lock(&bufmgr_gem->lock);
1182
1183         if (bo_gem->map_count++ == 0)
1184                 drm_intel_gem_bo_open_vma(bufmgr_gem, bo_gem);
1185
1186         if (!bo_gem->mem_virtual) {
1187                 struct drm_i915_gem_mmap mmap_arg;
1188
1189                 DBG("bo_map: %d (%s), map_count=%d\n",
1190                     bo_gem->gem_handle, bo_gem->name, bo_gem->map_count);
1191
1192                 VG_CLEAR(mmap_arg);
1193                 mmap_arg.handle = bo_gem->gem_handle;
1194                 mmap_arg.offset = 0;
1195                 mmap_arg.size = bo->size;
1196                 ret = drmIoctl(bufmgr_gem->fd,
1197                                DRM_IOCTL_I915_GEM_MMAP,
1198                                &mmap_arg);
1199                 if (ret != 0) {
1200                         ret = -errno;
1201                         DBG("%s:%d: Error mapping buffer %d (%s): %s .\n",
1202                             __FILE__, __LINE__, bo_gem->gem_handle,
1203                             bo_gem->name, strerror(errno));
1204                         if (--bo_gem->map_count == 0)
1205                                 drm_intel_gem_bo_close_vma(bufmgr_gem, bo_gem);
1206                         pthread_mutex_unlock(&bufmgr_gem->lock);
1207                         return ret;
1208                 }
1209                 VG(VALGRIND_MALLOCLIKE_BLOCK(mmap_arg.addr_ptr, mmap_arg.size, 0, 1));
1210                 bo_gem->mem_virtual = (void *)(uintptr_t) mmap_arg.addr_ptr;
1211         }
1212         DBG("bo_map: %d (%s) -> %p\n", bo_gem->gem_handle, bo_gem->name,
1213             bo_gem->mem_virtual);
1214         bo->virtual = bo_gem->mem_virtual;
1215
1216         VG_CLEAR(set_domain);
1217         set_domain.handle = bo_gem->gem_handle;
1218         set_domain.read_domains = I915_GEM_DOMAIN_CPU;
1219         if (write_enable)
1220                 set_domain.write_domain = I915_GEM_DOMAIN_CPU;
1221         else
1222                 set_domain.write_domain = 0;
1223         ret = drmIoctl(bufmgr_gem->fd,
1224                        DRM_IOCTL_I915_GEM_SET_DOMAIN,
1225                        &set_domain);
1226         if (ret != 0) {
1227                 DBG("%s:%d: Error setting to CPU domain %d: %s\n",
1228                     __FILE__, __LINE__, bo_gem->gem_handle,
1229                     strerror(errno));
1230         }
1231
1232         if (write_enable)
1233                 bo_gem->mapped_cpu_write = true;
1234
1235         drm_intel_gem_bo_mark_mmaps_incoherent(bo);
1236         VG(VALGRIND_MAKE_MEM_DEFINED(bo_gem->mem_virtual, bo->size));
1237         pthread_mutex_unlock(&bufmgr_gem->lock);
1238
1239         return 0;
1240 }
1241
1242 static int
1243 map_gtt(drm_intel_bo *bo)
1244 {
1245         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1246         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1247         int ret;
1248
1249         if (bo_gem->map_count++ == 0)
1250                 drm_intel_gem_bo_open_vma(bufmgr_gem, bo_gem);
1251
1252         /* Get a mapping of the buffer if we haven't before. */
1253         if (bo_gem->gtt_virtual == NULL) {
1254                 struct drm_i915_gem_mmap_gtt mmap_arg;
1255
1256                 DBG("bo_map_gtt: mmap %d (%s), map_count=%d\n",
1257                     bo_gem->gem_handle, bo_gem->name, bo_gem->map_count);
1258
1259                 VG_CLEAR(mmap_arg);
1260                 mmap_arg.handle = bo_gem->gem_handle;
1261
1262                 /* Get the fake offset back... */
1263                 ret = drmIoctl(bufmgr_gem->fd,
1264                                DRM_IOCTL_I915_GEM_MMAP_GTT,
1265                                &mmap_arg);
1266                 if (ret != 0) {
1267                         ret = -errno;
1268                         DBG("%s:%d: Error preparing buffer map %d (%s): %s .\n",
1269                             __FILE__, __LINE__,
1270                             bo_gem->gem_handle, bo_gem->name,
1271                             strerror(errno));
1272                         if (--bo_gem->map_count == 0)
1273                                 drm_intel_gem_bo_close_vma(bufmgr_gem, bo_gem);
1274                         return ret;
1275                 }
1276
1277                 /* and mmap it */
1278                 bo_gem->gtt_virtual = mmap(0, bo->size, PROT_READ | PROT_WRITE,
1279                                            MAP_SHARED, bufmgr_gem->fd,
1280                                            mmap_arg.offset);
1281                 if (bo_gem->gtt_virtual == MAP_FAILED) {
1282                         bo_gem->gtt_virtual = NULL;
1283                         ret = -errno;
1284                         DBG("%s:%d: Error mapping buffer %d (%s): %s .\n",
1285                             __FILE__, __LINE__,
1286                             bo_gem->gem_handle, bo_gem->name,
1287                             strerror(errno));
1288                         if (--bo_gem->map_count == 0)
1289                                 drm_intel_gem_bo_close_vma(bufmgr_gem, bo_gem);
1290                         return ret;
1291                 }
1292         }
1293
1294         bo->virtual = bo_gem->gtt_virtual;
1295
1296         DBG("bo_map_gtt: %d (%s) -> %p\n", bo_gem->gem_handle, bo_gem->name,
1297             bo_gem->gtt_virtual);
1298
1299         return 0;
1300 }
1301
1302 drm_public int
1303 drm_intel_gem_bo_map_gtt(drm_intel_bo *bo)
1304 {
1305         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1306         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1307         struct drm_i915_gem_set_domain set_domain;
1308         int ret;
1309
1310         pthread_mutex_lock(&bufmgr_gem->lock);
1311
1312         ret = map_gtt(bo);
1313         if (ret) {
1314                 pthread_mutex_unlock(&bufmgr_gem->lock);
1315                 return ret;
1316         }
1317
1318         /* Now move it to the GTT domain so that the GPU and CPU
1319          * caches are flushed and the GPU isn't actively using the
1320          * buffer.
1321          *
1322          * The pagefault handler does this domain change for us when
1323          * it has unbound the BO from the GTT, but it's up to us to
1324          * tell it when we're about to use things if we had done
1325          * rendering and it still happens to be bound to the GTT.
1326          */
1327         VG_CLEAR(set_domain);
1328         set_domain.handle = bo_gem->gem_handle;
1329         set_domain.read_domains = I915_GEM_DOMAIN_GTT;
1330         set_domain.write_domain = I915_GEM_DOMAIN_GTT;
1331         ret = drmIoctl(bufmgr_gem->fd,
1332                        DRM_IOCTL_I915_GEM_SET_DOMAIN,
1333                        &set_domain);
1334         if (ret != 0) {
1335                 DBG("%s:%d: Error setting domain %d: %s\n",
1336                     __FILE__, __LINE__, bo_gem->gem_handle,
1337                     strerror(errno));
1338         }
1339
1340         drm_intel_gem_bo_mark_mmaps_incoherent(bo);
1341         VG(VALGRIND_MAKE_MEM_DEFINED(bo_gem->gtt_virtual, bo->size));
1342         pthread_mutex_unlock(&bufmgr_gem->lock);
1343
1344         return 0;
1345 }
1346
1347 /**
1348  * Performs a mapping of the buffer object like the normal GTT
1349  * mapping, but avoids waiting for the GPU to be done reading from or
1350  * rendering to the buffer.
1351  *
1352  * This is used in the implementation of GL_ARB_map_buffer_range: The
1353  * user asks to create a buffer, then does a mapping, fills some
1354  * space, runs a drawing command, then asks to map it again without
1355  * synchronizing because it guarantees that it won't write over the
1356  * data that the GPU is busy using (or, more specifically, that if it
1357  * does write over the data, it acknowledges that rendering is
1358  * undefined).
1359  */
1360
1361 drm_public int
1362 drm_intel_gem_bo_map_unsynchronized(drm_intel_bo *bo)
1363 {
1364         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1365 #ifdef HAVE_VALGRIND
1366         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1367 #endif
1368         int ret;
1369
1370         /* If the CPU cache isn't coherent with the GTT, then use a
1371          * regular synchronized mapping.  The problem is that we don't
1372          * track where the buffer was last used on the CPU side in
1373          * terms of drm_intel_bo_map vs drm_intel_gem_bo_map_gtt, so
1374          * we would potentially corrupt the buffer even when the user
1375          * does reasonable things.
1376          */
1377         if (!bufmgr_gem->has_llc)
1378                 return drm_intel_gem_bo_map_gtt(bo);
1379
1380         pthread_mutex_lock(&bufmgr_gem->lock);
1381
1382         ret = map_gtt(bo);
1383         if (ret == 0) {
1384                 drm_intel_gem_bo_mark_mmaps_incoherent(bo);
1385                 VG(VALGRIND_MAKE_MEM_DEFINED(bo_gem->gtt_virtual, bo->size));
1386         }
1387
1388         pthread_mutex_unlock(&bufmgr_gem->lock);
1389
1390         return ret;
1391 }
1392
1393 static int drm_intel_gem_bo_unmap(drm_intel_bo *bo)
1394 {
1395         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1396         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1397         int ret = 0;
1398
1399         if (bo == NULL)
1400                 return 0;
1401
1402         pthread_mutex_lock(&bufmgr_gem->lock);
1403
1404         if (bo_gem->map_count <= 0) {
1405                 DBG("attempted to unmap an unmapped bo\n");
1406                 pthread_mutex_unlock(&bufmgr_gem->lock);
1407                 /* Preserve the old behaviour of just treating this as a
1408                  * no-op rather than reporting the error.
1409                  */
1410                 return 0;
1411         }
1412
1413         if (bo_gem->mapped_cpu_write) {
1414                 struct drm_i915_gem_sw_finish sw_finish;
1415
1416                 /* Cause a flush to happen if the buffer's pinned for
1417                  * scanout, so the results show up in a timely manner.
1418                  * Unlike GTT set domains, this only does work if the
1419                  * buffer should be scanout-related.
1420                  */
1421                 VG_CLEAR(sw_finish);
1422                 sw_finish.handle = bo_gem->gem_handle;
1423                 ret = drmIoctl(bufmgr_gem->fd,
1424                                DRM_IOCTL_I915_GEM_SW_FINISH,
1425                                &sw_finish);
1426                 ret = ret == -1 ? -errno : 0;
1427
1428                 bo_gem->mapped_cpu_write = false;
1429         }
1430
1431         /* We need to unmap after every innovation as we cannot track
1432          * an open vma for every bo as that will exhaasut the system
1433          * limits and cause later failures.
1434          */
1435         if (--bo_gem->map_count == 0) {
1436                 drm_intel_gem_bo_close_vma(bufmgr_gem, bo_gem);
1437                 drm_intel_gem_bo_mark_mmaps_incoherent(bo);
1438                 bo->virtual = NULL;
1439         }
1440         pthread_mutex_unlock(&bufmgr_gem->lock);
1441
1442         return ret;
1443 }
1444
1445 drm_public int
1446 drm_intel_gem_bo_unmap_gtt(drm_intel_bo *bo)
1447 {
1448         return drm_intel_gem_bo_unmap(bo);
1449 }
1450
1451 static int
1452 drm_intel_gem_bo_subdata(drm_intel_bo *bo, unsigned long offset,
1453                          unsigned long size, const void *data)
1454 {
1455         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1456         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1457         struct drm_i915_gem_pwrite pwrite;
1458         int ret;
1459
1460         VG_CLEAR(pwrite);
1461         pwrite.handle = bo_gem->gem_handle;
1462         pwrite.offset = offset;
1463         pwrite.size = size;
1464         pwrite.data_ptr = (uint64_t) (uintptr_t) data;
1465         ret = drmIoctl(bufmgr_gem->fd,
1466                        DRM_IOCTL_I915_GEM_PWRITE,
1467                        &pwrite);
1468         if (ret != 0) {
1469                 ret = -errno;
1470                 DBG("%s:%d: Error writing data to buffer %d: (%d %d) %s .\n",
1471                     __FILE__, __LINE__, bo_gem->gem_handle, (int)offset,
1472                     (int)size, strerror(errno));
1473         }
1474
1475         return ret;
1476 }
1477
1478 static int
1479 drm_intel_gem_get_pipe_from_crtc_id(drm_intel_bufmgr *bufmgr, int crtc_id)
1480 {
1481         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
1482         struct drm_i915_get_pipe_from_crtc_id get_pipe_from_crtc_id;
1483         int ret;
1484
1485         VG_CLEAR(get_pipe_from_crtc_id);
1486         get_pipe_from_crtc_id.crtc_id = crtc_id;
1487         ret = drmIoctl(bufmgr_gem->fd,
1488                        DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID,
1489                        &get_pipe_from_crtc_id);
1490         if (ret != 0) {
1491                 /* We return -1 here to signal that we don't
1492                  * know which pipe is associated with this crtc.
1493                  * This lets the caller know that this information
1494                  * isn't available; using the wrong pipe for
1495                  * vblank waiting can cause the chipset to lock up
1496                  */
1497                 return -1;
1498         }
1499
1500         return get_pipe_from_crtc_id.pipe;
1501 }
1502
1503 static int
1504 drm_intel_gem_bo_get_subdata(drm_intel_bo *bo, unsigned long offset,
1505                              unsigned long size, void *data)
1506 {
1507         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1508         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1509         struct drm_i915_gem_pread pread;
1510         int ret;
1511
1512         VG_CLEAR(pread);
1513         pread.handle = bo_gem->gem_handle;
1514         pread.offset = offset;
1515         pread.size = size;
1516         pread.data_ptr = (uint64_t) (uintptr_t) data;
1517         ret = drmIoctl(bufmgr_gem->fd,
1518                        DRM_IOCTL_I915_GEM_PREAD,
1519                        &pread);
1520         if (ret != 0) {
1521                 ret = -errno;
1522                 DBG("%s:%d: Error reading data from buffer %d: (%d %d) %s .\n",
1523                     __FILE__, __LINE__, bo_gem->gem_handle, (int)offset,
1524                     (int)size, strerror(errno));
1525         }
1526
1527         return ret;
1528 }
1529
1530 /** Waits for all GPU rendering with the object to have completed. */
1531 static void
1532 drm_intel_gem_bo_wait_rendering(drm_intel_bo *bo)
1533 {
1534         drm_intel_gem_bo_start_gtt_access(bo, 1);
1535 }
1536
1537 /**
1538  * Waits on a BO for the given amount of time.
1539  *
1540  * @bo: buffer object to wait for
1541  * @timeout_ns: amount of time to wait in nanoseconds.
1542  *   If value is less than 0, an infinite wait will occur.
1543  *
1544  * Returns 0 if the wait was successful ie. the last batch referencing the
1545  * object has completed within the allotted time. Otherwise some negative return
1546  * value describes the error. Of particular interest is -ETIME when the wait has
1547  * failed to yield the desired result.
1548  *
1549  * Similar to drm_intel_gem_bo_wait_rendering except a timeout parameter allows
1550  * the operation to give up after a certain amount of time. Another subtle
1551  * difference is the internal locking semantics are different (this variant does
1552  * not hold the lock for the duration of the wait). This makes the wait subject
1553  * to a larger userspace race window.
1554  *
1555  * The implementation shall wait until the object is no longer actively
1556  * referenced within a batch buffer at the time of the call. The wait will
1557  * not guarantee that the buffer is re-issued via another thread, or an flinked
1558  * handle. Userspace must make sure this race does not occur if such precision
1559  * is important.
1560  */
1561 drm_public int
1562 drm_intel_gem_bo_wait(drm_intel_bo *bo, int64_t timeout_ns)
1563 {
1564         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1565         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1566         struct drm_i915_gem_wait wait;
1567         int ret;
1568
1569         if (!bufmgr_gem->has_wait_timeout) {
1570                 DBG("%s:%d: Timed wait is not supported. Falling back to "
1571                     "infinite wait\n", __FILE__, __LINE__);
1572                 if (timeout_ns) {
1573                         drm_intel_gem_bo_wait_rendering(bo);
1574                         return 0;
1575                 } else {
1576                         return drm_intel_gem_bo_busy(bo) ? -ETIME : 0;
1577                 }
1578         }
1579
1580         wait.bo_handle = bo_gem->gem_handle;
1581         wait.timeout_ns = timeout_ns;
1582         wait.flags = 0;
1583         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_WAIT, &wait);
1584         if (ret == -1)
1585                 return -errno;
1586
1587         return ret;
1588 }
1589
1590 /**
1591  * Sets the object to the GTT read and possibly write domain, used by the X
1592  * 2D driver in the absence of kernel support to do drm_intel_gem_bo_map_gtt().
1593  *
1594  * In combination with drm_intel_gem_bo_pin() and manual fence management, we
1595  * can do tiled pixmaps this way.
1596  */
1597 drm_public void
1598 drm_intel_gem_bo_start_gtt_access(drm_intel_bo *bo, int write_enable)
1599 {
1600         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1601         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1602         struct drm_i915_gem_set_domain set_domain;
1603         int ret;
1604
1605         VG_CLEAR(set_domain);
1606         set_domain.handle = bo_gem->gem_handle;
1607         set_domain.read_domains = I915_GEM_DOMAIN_GTT;
1608         set_domain.write_domain = write_enable ? I915_GEM_DOMAIN_GTT : 0;
1609         ret = drmIoctl(bufmgr_gem->fd,
1610                        DRM_IOCTL_I915_GEM_SET_DOMAIN,
1611                        &set_domain);
1612         if (ret != 0) {
1613                 DBG("%s:%d: Error setting memory domains %d (%08x %08x): %s .\n",
1614                     __FILE__, __LINE__, bo_gem->gem_handle,
1615                     set_domain.read_domains, set_domain.write_domain,
1616                     strerror(errno));
1617         }
1618 }
1619
1620 static void
1621 drm_intel_bufmgr_gem_destroy(drm_intel_bufmgr *bufmgr)
1622 {
1623         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
1624         int i;
1625
1626         free(bufmgr_gem->exec2_objects);
1627         free(bufmgr_gem->exec_objects);
1628         free(bufmgr_gem->exec_bos);
1629         free(bufmgr_gem->aub_filename);
1630
1631         pthread_mutex_destroy(&bufmgr_gem->lock);
1632
1633         /* Free any cached buffer objects we were going to reuse */
1634         for (i = 0; i < bufmgr_gem->num_buckets; i++) {
1635                 struct drm_intel_gem_bo_bucket *bucket =
1636                     &bufmgr_gem->cache_bucket[i];
1637                 drm_intel_bo_gem *bo_gem;
1638
1639                 while (!DRMLISTEMPTY(&bucket->head)) {
1640                         bo_gem = DRMLISTENTRY(drm_intel_bo_gem,
1641                                               bucket->head.next, head);
1642                         DRMLISTDEL(&bo_gem->head);
1643
1644                         drm_intel_gem_bo_free(&bo_gem->bo);
1645                 }
1646         }
1647
1648         free(bufmgr);
1649 }
1650
1651 /**
1652  * Adds the target buffer to the validation list and adds the relocation
1653  * to the reloc_buffer's relocation list.
1654  *
1655  * The relocation entry at the given offset must already contain the
1656  * precomputed relocation value, because the kernel will optimize out
1657  * the relocation entry write when the buffer hasn't moved from the
1658  * last known offset in target_bo.
1659  */
1660 static int
1661 do_bo_emit_reloc(drm_intel_bo *bo, uint32_t offset,
1662                  drm_intel_bo *target_bo, uint32_t target_offset,
1663                  uint32_t read_domains, uint32_t write_domain,
1664                  bool need_fence)
1665 {
1666         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1667         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1668         drm_intel_bo_gem *target_bo_gem = (drm_intel_bo_gem *) target_bo;
1669         bool fenced_command;
1670
1671         if (bo_gem->has_error)
1672                 return -ENOMEM;
1673
1674         if (target_bo_gem->has_error) {
1675                 bo_gem->has_error = true;
1676                 return -ENOMEM;
1677         }
1678
1679         /* We never use HW fences for rendering on 965+ */
1680         if (bufmgr_gem->gen >= 4)
1681                 need_fence = false;
1682
1683         fenced_command = need_fence;
1684         if (target_bo_gem->tiling_mode == I915_TILING_NONE)
1685                 need_fence = false;
1686
1687         /* Create a new relocation list if needed */
1688         if (bo_gem->relocs == NULL && drm_intel_setup_reloc_list(bo))
1689                 return -ENOMEM;
1690
1691         /* Check overflow */
1692         assert(bo_gem->reloc_count < bufmgr_gem->max_relocs);
1693
1694         /* Check args */
1695         assert(offset <= bo->size - 4);
1696         assert((write_domain & (write_domain - 1)) == 0);
1697
1698         /* Make sure that we're not adding a reloc to something whose size has
1699          * already been accounted for.
1700          */
1701         assert(!bo_gem->used_as_reloc_target);
1702         if (target_bo_gem != bo_gem) {
1703                 target_bo_gem->used_as_reloc_target = true;
1704                 bo_gem->reloc_tree_size += target_bo_gem->reloc_tree_size;
1705         }
1706         /* An object needing a fence is a tiled buffer, so it won't have
1707          * relocs to other buffers.
1708          */
1709         if (need_fence)
1710                 target_bo_gem->reloc_tree_fences = 1;
1711         bo_gem->reloc_tree_fences += target_bo_gem->reloc_tree_fences;
1712
1713         bo_gem->relocs[bo_gem->reloc_count].offset = offset;
1714         bo_gem->relocs[bo_gem->reloc_count].delta = target_offset;
1715         bo_gem->relocs[bo_gem->reloc_count].target_handle =
1716             target_bo_gem->gem_handle;
1717         bo_gem->relocs[bo_gem->reloc_count].read_domains = read_domains;
1718         bo_gem->relocs[bo_gem->reloc_count].write_domain = write_domain;
1719         bo_gem->relocs[bo_gem->reloc_count].presumed_offset = target_bo->offset64;
1720
1721         bo_gem->reloc_target_info[bo_gem->reloc_count].bo = target_bo;
1722         if (target_bo != bo)
1723                 drm_intel_gem_bo_reference(target_bo);
1724         if (fenced_command)
1725                 bo_gem->reloc_target_info[bo_gem->reloc_count].flags =
1726                         DRM_INTEL_RELOC_FENCE;
1727         else
1728                 bo_gem->reloc_target_info[bo_gem->reloc_count].flags = 0;
1729
1730         bo_gem->reloc_count++;
1731
1732         return 0;
1733 }
1734
1735 static int
1736 drm_intel_gem_bo_emit_reloc(drm_intel_bo *bo, uint32_t offset,
1737                             drm_intel_bo *target_bo, uint32_t target_offset,
1738                             uint32_t read_domains, uint32_t write_domain)
1739 {
1740         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
1741
1742         return do_bo_emit_reloc(bo, offset, target_bo, target_offset,
1743                                 read_domains, write_domain,
1744                                 !bufmgr_gem->fenced_relocs);
1745 }
1746
1747 static int
1748 drm_intel_gem_bo_emit_reloc_fence(drm_intel_bo *bo, uint32_t offset,
1749                                   drm_intel_bo *target_bo,
1750                                   uint32_t target_offset,
1751                                   uint32_t read_domains, uint32_t write_domain)
1752 {
1753         return do_bo_emit_reloc(bo, offset, target_bo, target_offset,
1754                                 read_domains, write_domain, true);
1755 }
1756
1757 drm_public int
1758 drm_intel_gem_bo_get_reloc_count(drm_intel_bo *bo)
1759 {
1760         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1761
1762         return bo_gem->reloc_count;
1763 }
1764
1765 /**
1766  * Removes existing relocation entries in the BO after "start".
1767  *
1768  * This allows a user to avoid a two-step process for state setup with
1769  * counting up all the buffer objects and doing a
1770  * drm_intel_bufmgr_check_aperture_space() before emitting any of the
1771  * relocations for the state setup.  Instead, save the state of the
1772  * batchbuffer including drm_intel_gem_get_reloc_count(), emit all the
1773  * state, and then check if it still fits in the aperture.
1774  *
1775  * Any further drm_intel_bufmgr_check_aperture_space() queries
1776  * involving this buffer in the tree are undefined after this call.
1777  */
1778 drm_public void
1779 drm_intel_gem_bo_clear_relocs(drm_intel_bo *bo, int start)
1780 {
1781         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1782         int i;
1783         struct timespec time;
1784
1785         clock_gettime(CLOCK_MONOTONIC, &time);
1786
1787         assert(bo_gem->reloc_count >= start);
1788         /* Unreference the cleared target buffers */
1789         for (i = start; i < bo_gem->reloc_count; i++) {
1790                 drm_intel_bo_gem *target_bo_gem = (drm_intel_bo_gem *) bo_gem->reloc_target_info[i].bo;
1791                 if (&target_bo_gem->bo != bo) {
1792                         bo_gem->reloc_tree_fences -= target_bo_gem->reloc_tree_fences;
1793                         drm_intel_gem_bo_unreference_locked_timed(&target_bo_gem->bo,
1794                                                                   time.tv_sec);
1795                 }
1796         }
1797         bo_gem->reloc_count = start;
1798 }
1799
1800 /**
1801  * Walk the tree of relocations rooted at BO and accumulate the list of
1802  * validations to be performed and update the relocation buffers with
1803  * index values into the validation list.
1804  */
1805 static void
1806 drm_intel_gem_bo_process_reloc(drm_intel_bo *bo)
1807 {
1808         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1809         int i;
1810
1811         if (bo_gem->relocs == NULL)
1812                 return;
1813
1814         for (i = 0; i < bo_gem->reloc_count; i++) {
1815                 drm_intel_bo *target_bo = bo_gem->reloc_target_info[i].bo;
1816
1817                 if (target_bo == bo)
1818                         continue;
1819
1820                 drm_intel_gem_bo_mark_mmaps_incoherent(bo);
1821
1822                 /* Continue walking the tree depth-first. */
1823                 drm_intel_gem_bo_process_reloc(target_bo);
1824
1825                 /* Add the target to the validate list */
1826                 drm_intel_add_validate_buffer(target_bo);
1827         }
1828 }
1829
1830 static void
1831 drm_intel_gem_bo_process_reloc2(drm_intel_bo *bo)
1832 {
1833         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
1834         int i;
1835
1836         if (bo_gem->relocs == NULL)
1837                 return;
1838
1839         for (i = 0; i < bo_gem->reloc_count; i++) {
1840                 drm_intel_bo *target_bo = bo_gem->reloc_target_info[i].bo;
1841                 int need_fence;
1842
1843                 if (target_bo == bo)
1844                         continue;
1845
1846                 drm_intel_gem_bo_mark_mmaps_incoherent(bo);
1847
1848                 /* Continue walking the tree depth-first. */
1849                 drm_intel_gem_bo_process_reloc2(target_bo);
1850
1851                 need_fence = (bo_gem->reloc_target_info[i].flags &
1852                               DRM_INTEL_RELOC_FENCE);
1853
1854                 /* Add the target to the validate list */
1855                 drm_intel_add_validate_buffer2(target_bo, need_fence);
1856         }
1857 }
1858
1859
1860 static void
1861 drm_intel_update_buffer_offsets(drm_intel_bufmgr_gem *bufmgr_gem)
1862 {
1863         int i;
1864
1865         for (i = 0; i < bufmgr_gem->exec_count; i++) {
1866                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
1867                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1868
1869                 /* Update the buffer offset */
1870                 if (bufmgr_gem->exec_objects[i].offset != bo->offset64) {
1871                         DBG("BO %d (%s) migrated: 0x%08lx -> 0x%08llx\n",
1872                             bo_gem->gem_handle, bo_gem->name, bo->offset64,
1873                             (unsigned long long)bufmgr_gem->exec_objects[i].
1874                             offset);
1875                         bo->offset64 = bufmgr_gem->exec_objects[i].offset;
1876                         bo->offset = bufmgr_gem->exec_objects[i].offset;
1877                 }
1878         }
1879 }
1880
1881 static void
1882 drm_intel_update_buffer_offsets2 (drm_intel_bufmgr_gem *bufmgr_gem)
1883 {
1884         int i;
1885
1886         for (i = 0; i < bufmgr_gem->exec_count; i++) {
1887                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
1888                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
1889
1890                 /* Update the buffer offset */
1891                 if (bufmgr_gem->exec2_objects[i].offset != bo->offset64) {
1892                         DBG("BO %d (%s) migrated: 0x%08lx -> 0x%08llx\n",
1893                             bo_gem->gem_handle, bo_gem->name, bo->offset64,
1894                             (unsigned long long)bufmgr_gem->exec2_objects[i].offset);
1895                         bo->offset64 = bufmgr_gem->exec2_objects[i].offset;
1896                         bo->offset = bufmgr_gem->exec2_objects[i].offset;
1897                 }
1898         }
1899 }
1900
1901 static void
1902 aub_out(drm_intel_bufmgr_gem *bufmgr_gem, uint32_t data)
1903 {
1904         fwrite(&data, 1, 4, bufmgr_gem->aub_file);
1905 }
1906
1907 static void
1908 aub_out_data(drm_intel_bufmgr_gem *bufmgr_gem, void *data, size_t size)
1909 {
1910         fwrite(data, 1, size, bufmgr_gem->aub_file);
1911 }
1912
1913 static void
1914 aub_write_bo_data(drm_intel_bo *bo, uint32_t offset, uint32_t size)
1915 {
1916         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1917         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1918         uint32_t *data;
1919         unsigned int i;
1920
1921         data = malloc(bo->size);
1922         drm_intel_bo_get_subdata(bo, offset, size, data);
1923
1924         /* Easy mode: write out bo with no relocations */
1925         if (!bo_gem->reloc_count) {
1926                 aub_out_data(bufmgr_gem, data, size);
1927                 free(data);
1928                 return;
1929         }
1930
1931         /* Otherwise, handle the relocations while writing. */
1932         for (i = 0; i < size / 4; i++) {
1933                 int r;
1934                 for (r = 0; r < bo_gem->reloc_count; r++) {
1935                         struct drm_i915_gem_relocation_entry *reloc;
1936                         drm_intel_reloc_target *info;
1937
1938                         reloc = &bo_gem->relocs[r];
1939                         info = &bo_gem->reloc_target_info[r];
1940
1941                         if (reloc->offset == offset + i * 4) {
1942                                 drm_intel_bo_gem *target_gem;
1943                                 uint32_t val;
1944
1945                                 target_gem = (drm_intel_bo_gem *)info->bo;
1946
1947                                 val = reloc->delta;
1948                                 val += target_gem->aub_offset;
1949
1950                                 aub_out(bufmgr_gem, val);
1951                                 data[i] = val;
1952                                 break;
1953                         }
1954                 }
1955                 if (r == bo_gem->reloc_count) {
1956                         /* no relocation, just the data */
1957                         aub_out(bufmgr_gem, data[i]);
1958                 }
1959         }
1960
1961         free(data);
1962 }
1963
1964 static void
1965 aub_bo_get_address(drm_intel_bo *bo)
1966 {
1967         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1968         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1969
1970         /* Give the object a graphics address in the AUB file.  We
1971          * don't just use the GEM object address because we do AUB
1972          * dumping before execution -- we want to successfully log
1973          * when the hardware might hang, and we might even want to aub
1974          * capture for a driver trying to execute on a different
1975          * generation of hardware by disabling the actual kernel exec
1976          * call.
1977          */
1978         bo_gem->aub_offset = bufmgr_gem->aub_offset;
1979         bufmgr_gem->aub_offset += bo->size;
1980         /* XXX: Handle aperture overflow. */
1981         assert(bufmgr_gem->aub_offset < 256 * 1024 * 1024);
1982 }
1983
1984 static void
1985 aub_write_trace_block(drm_intel_bo *bo, uint32_t type, uint32_t subtype,
1986                       uint32_t offset, uint32_t size)
1987 {
1988         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
1989         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
1990
1991         aub_out(bufmgr_gem,
1992                 CMD_AUB_TRACE_HEADER_BLOCK |
1993                 ((bufmgr_gem->gen >= 8 ? 6 : 5) - 2));
1994         aub_out(bufmgr_gem,
1995                 AUB_TRACE_MEMTYPE_GTT | type | AUB_TRACE_OP_DATA_WRITE);
1996         aub_out(bufmgr_gem, subtype);
1997         aub_out(bufmgr_gem, bo_gem->aub_offset + offset);
1998         aub_out(bufmgr_gem, size);
1999         if (bufmgr_gem->gen >= 8)
2000                 aub_out(bufmgr_gem, 0);
2001         aub_write_bo_data(bo, offset, size);
2002 }
2003
2004 /**
2005  * Break up large objects into multiple writes.  Otherwise a 128kb VBO
2006  * would overflow the 16 bits of size field in the packet header and
2007  * everything goes badly after that.
2008  */
2009 static void
2010 aub_write_large_trace_block(drm_intel_bo *bo, uint32_t type, uint32_t subtype,
2011                             uint32_t offset, uint32_t size)
2012 {
2013         uint32_t block_size;
2014         uint32_t sub_offset;
2015
2016         for (sub_offset = 0; sub_offset < size; sub_offset += block_size) {
2017                 block_size = size - sub_offset;
2018
2019                 if (block_size > 8 * 4096)
2020                         block_size = 8 * 4096;
2021
2022                 aub_write_trace_block(bo, type, subtype, offset + sub_offset,
2023                                       block_size);
2024         }
2025 }
2026
2027 static void
2028 aub_write_bo(drm_intel_bo *bo)
2029 {
2030         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2031         uint32_t offset = 0;
2032         unsigned i;
2033
2034         aub_bo_get_address(bo);
2035
2036         /* Write out each annotated section separately. */
2037         for (i = 0; i < bo_gem->aub_annotation_count; ++i) {
2038                 drm_intel_aub_annotation *annotation =
2039                         &bo_gem->aub_annotations[i];
2040                 uint32_t ending_offset = annotation->ending_offset;
2041                 if (ending_offset > bo->size)
2042                         ending_offset = bo->size;
2043                 if (ending_offset > offset) {
2044                         aub_write_large_trace_block(bo, annotation->type,
2045                                                     annotation->subtype,
2046                                                     offset,
2047                                                     ending_offset - offset);
2048                         offset = ending_offset;
2049                 }
2050         }
2051
2052         /* Write out any remaining unannotated data */
2053         if (offset < bo->size) {
2054                 aub_write_large_trace_block(bo, AUB_TRACE_TYPE_NOTYPE, 0,
2055                                             offset, bo->size - offset);
2056         }
2057 }
2058
2059 /*
2060  * Make a ringbuffer on fly and dump it
2061  */
2062 static void
2063 aub_build_dump_ringbuffer(drm_intel_bufmgr_gem *bufmgr_gem,
2064                           uint32_t batch_buffer, int ring_flag)
2065 {
2066         uint32_t ringbuffer[4096];
2067         int ring = AUB_TRACE_TYPE_RING_PRB0; /* The default ring */
2068         int ring_count = 0;
2069
2070         if (ring_flag == I915_EXEC_BSD)
2071                 ring = AUB_TRACE_TYPE_RING_PRB1;
2072         else if (ring_flag == I915_EXEC_BLT)
2073                 ring = AUB_TRACE_TYPE_RING_PRB2;
2074
2075         /* Make a ring buffer to execute our batchbuffer. */
2076         memset(ringbuffer, 0, sizeof(ringbuffer));
2077         if (bufmgr_gem->gen >= 8) {
2078                 ringbuffer[ring_count++] = AUB_MI_BATCH_BUFFER_START | (3 - 2);
2079                 ringbuffer[ring_count++] = batch_buffer;
2080                 ringbuffer[ring_count++] = 0;
2081         } else {
2082                 ringbuffer[ring_count++] = AUB_MI_BATCH_BUFFER_START;
2083                 ringbuffer[ring_count++] = batch_buffer;
2084         }
2085
2086         /* Write out the ring.  This appears to trigger execution of
2087          * the ring in the simulator.
2088          */
2089         aub_out(bufmgr_gem,
2090                 CMD_AUB_TRACE_HEADER_BLOCK |
2091                 ((bufmgr_gem->gen >= 8 ? 6 : 5) - 2));
2092         aub_out(bufmgr_gem,
2093                 AUB_TRACE_MEMTYPE_GTT | ring | AUB_TRACE_OP_COMMAND_WRITE);
2094         aub_out(bufmgr_gem, 0); /* general/surface subtype */
2095         aub_out(bufmgr_gem, bufmgr_gem->aub_offset);
2096         aub_out(bufmgr_gem, ring_count * 4);
2097         if (bufmgr_gem->gen >= 8)
2098                 aub_out(bufmgr_gem, 0);
2099
2100         /* FIXME: Need some flush operations here? */
2101         aub_out_data(bufmgr_gem, ringbuffer, ring_count * 4);
2102
2103         /* Update offset pointer */
2104         bufmgr_gem->aub_offset += 4096;
2105 }
2106
2107 drm_public void
2108 drm_intel_gem_bo_aub_dump_bmp(drm_intel_bo *bo,
2109                               int x1, int y1, int width, int height,
2110                               enum aub_dump_bmp_format format,
2111                               int pitch, int offset)
2112 {
2113         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2114         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
2115         uint32_t cpp;
2116
2117         switch (format) {
2118         case AUB_DUMP_BMP_FORMAT_8BIT:
2119                 cpp = 1;
2120                 break;
2121         case AUB_DUMP_BMP_FORMAT_ARGB_4444:
2122                 cpp = 2;
2123                 break;
2124         case AUB_DUMP_BMP_FORMAT_ARGB_0888:
2125         case AUB_DUMP_BMP_FORMAT_ARGB_8888:
2126                 cpp = 4;
2127                 break;
2128         default:
2129                 printf("Unknown AUB dump format %d\n", format);
2130                 return;
2131         }
2132
2133         if (!bufmgr_gem->aub_file)
2134                 return;
2135
2136         aub_out(bufmgr_gem, CMD_AUB_DUMP_BMP | 4);
2137         aub_out(bufmgr_gem, (y1 << 16) | x1);
2138         aub_out(bufmgr_gem,
2139                 (format << 24) |
2140                 (cpp << 19) |
2141                 pitch / 4);
2142         aub_out(bufmgr_gem, (height << 16) | width);
2143         aub_out(bufmgr_gem, bo_gem->aub_offset + offset);
2144         aub_out(bufmgr_gem,
2145                 ((bo_gem->tiling_mode != I915_TILING_NONE) ? (1 << 2) : 0) |
2146                 ((bo_gem->tiling_mode == I915_TILING_Y) ? (1 << 3) : 0));
2147 }
2148
2149 static void
2150 aub_exec(drm_intel_bo *bo, int ring_flag, int used)
2151 {
2152         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2153         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2154         int i;
2155         bool batch_buffer_needs_annotations;
2156
2157         if (!bufmgr_gem->aub_file)
2158                 return;
2159
2160         /* If batch buffer is not annotated, annotate it the best we
2161          * can.
2162          */
2163         batch_buffer_needs_annotations = bo_gem->aub_annotation_count == 0;
2164         if (batch_buffer_needs_annotations) {
2165                 drm_intel_aub_annotation annotations[2] = {
2166                         { AUB_TRACE_TYPE_BATCH, 0, used },
2167                         { AUB_TRACE_TYPE_NOTYPE, 0, bo->size }
2168                 };
2169                 drm_intel_bufmgr_gem_set_aub_annotations(bo, annotations, 2);
2170         }
2171
2172         /* Write out all buffers to AUB memory */
2173         for (i = 0; i < bufmgr_gem->exec_count; i++) {
2174                 aub_write_bo(bufmgr_gem->exec_bos[i]);
2175         }
2176
2177         /* Remove any annotations we added */
2178         if (batch_buffer_needs_annotations)
2179                 drm_intel_bufmgr_gem_set_aub_annotations(bo, NULL, 0);
2180
2181         /* Dump ring buffer */
2182         aub_build_dump_ringbuffer(bufmgr_gem, bo_gem->aub_offset, ring_flag);
2183
2184         fflush(bufmgr_gem->aub_file);
2185
2186         /*
2187          * One frame has been dumped. So reset the aub_offset for the next frame.
2188          *
2189          * FIXME: Can we do this?
2190          */
2191         bufmgr_gem->aub_offset = 0x10000;
2192 }
2193
2194 static int
2195 drm_intel_gem_bo_exec(drm_intel_bo *bo, int used,
2196                       drm_clip_rect_t * cliprects, int num_cliprects, int DR4)
2197 {
2198         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2199         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2200         struct drm_i915_gem_execbuffer execbuf;
2201         int ret, i;
2202
2203         if (bo_gem->has_error)
2204                 return -ENOMEM;
2205
2206         pthread_mutex_lock(&bufmgr_gem->lock);
2207         /* Update indices and set up the validate list. */
2208         drm_intel_gem_bo_process_reloc(bo);
2209
2210         /* Add the batch buffer to the validation list.  There are no
2211          * relocations pointing to it.
2212          */
2213         drm_intel_add_validate_buffer(bo);
2214
2215         VG_CLEAR(execbuf);
2216         execbuf.buffers_ptr = (uintptr_t) bufmgr_gem->exec_objects;
2217         execbuf.buffer_count = bufmgr_gem->exec_count;
2218         execbuf.batch_start_offset = 0;
2219         execbuf.batch_len = used;
2220         execbuf.cliprects_ptr = (uintptr_t) cliprects;
2221         execbuf.num_cliprects = num_cliprects;
2222         execbuf.DR1 = 0;
2223         execbuf.DR4 = DR4;
2224
2225         ret = drmIoctl(bufmgr_gem->fd,
2226                        DRM_IOCTL_I915_GEM_EXECBUFFER,
2227                        &execbuf);
2228         if (ret != 0) {
2229                 ret = -errno;
2230                 if (errno == ENOSPC) {
2231                         DBG("Execbuffer fails to pin. "
2232                             "Estimate: %u. Actual: %u. Available: %u\n",
2233                             drm_intel_gem_estimate_batch_space(bufmgr_gem->exec_bos,
2234                                                                bufmgr_gem->
2235                                                                exec_count),
2236                             drm_intel_gem_compute_batch_space(bufmgr_gem->exec_bos,
2237                                                               bufmgr_gem->
2238                                                               exec_count),
2239                             (unsigned int)bufmgr_gem->gtt_size);
2240                 }
2241         }
2242         drm_intel_update_buffer_offsets(bufmgr_gem);
2243
2244         if (bufmgr_gem->bufmgr.debug)
2245                 drm_intel_gem_dump_validation_list(bufmgr_gem);
2246
2247         for (i = 0; i < bufmgr_gem->exec_count; i++) {
2248                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
2249                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2250
2251                 bo_gem->idle = false;
2252
2253                 /* Disconnect the buffer from the validate list */
2254                 bo_gem->validate_index = -1;
2255                 bufmgr_gem->exec_bos[i] = NULL;
2256         }
2257         bufmgr_gem->exec_count = 0;
2258         pthread_mutex_unlock(&bufmgr_gem->lock);
2259
2260         return ret;
2261 }
2262
2263 static int
2264 do_exec2(drm_intel_bo *bo, int used, drm_intel_context *ctx,
2265          drm_clip_rect_t *cliprects, int num_cliprects, int DR4,
2266          unsigned int flags)
2267 {
2268         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
2269         struct drm_i915_gem_execbuffer2 execbuf;
2270         int ret = 0;
2271         int i;
2272
2273         switch (flags & 0x7) {
2274         default:
2275                 return -EINVAL;
2276         case I915_EXEC_BLT:
2277                 if (!bufmgr_gem->has_blt)
2278                         return -EINVAL;
2279                 break;
2280         case I915_EXEC_BSD:
2281                 if (!bufmgr_gem->has_bsd)
2282                         return -EINVAL;
2283                 break;
2284         case I915_EXEC_VEBOX:
2285                 if (!bufmgr_gem->has_vebox)
2286                         return -EINVAL;
2287                 break;
2288         case I915_EXEC_RENDER:
2289         case I915_EXEC_DEFAULT:
2290                 break;
2291         }
2292
2293         pthread_mutex_lock(&bufmgr_gem->lock);
2294         /* Update indices and set up the validate list. */
2295         drm_intel_gem_bo_process_reloc2(bo);
2296
2297         /* Add the batch buffer to the validation list.  There are no relocations
2298          * pointing to it.
2299          */
2300         drm_intel_add_validate_buffer2(bo, 0);
2301
2302         VG_CLEAR(execbuf);
2303         execbuf.buffers_ptr = (uintptr_t)bufmgr_gem->exec2_objects;
2304         execbuf.buffer_count = bufmgr_gem->exec_count;
2305         execbuf.batch_start_offset = 0;
2306         execbuf.batch_len = used;
2307         execbuf.cliprects_ptr = (uintptr_t)cliprects;
2308         execbuf.num_cliprects = num_cliprects;
2309         execbuf.DR1 = 0;
2310         execbuf.DR4 = DR4;
2311         execbuf.flags = flags;
2312         if (ctx == NULL)
2313                 i915_execbuffer2_set_context_id(execbuf, 0);
2314         else
2315                 i915_execbuffer2_set_context_id(execbuf, ctx->ctx_id);
2316         execbuf.rsvd2 = 0;
2317
2318         aub_exec(bo, flags, used);
2319
2320         if (bufmgr_gem->no_exec)
2321                 goto skip_execution;
2322
2323         ret = drmIoctl(bufmgr_gem->fd,
2324                        DRM_IOCTL_I915_GEM_EXECBUFFER2,
2325                        &execbuf);
2326         if (ret != 0) {
2327                 ret = -errno;
2328                 if (ret == -ENOSPC) {
2329                         DBG("Execbuffer fails to pin. "
2330                             "Estimate: %u. Actual: %u. Available: %u\n",
2331                             drm_intel_gem_estimate_batch_space(bufmgr_gem->exec_bos,
2332                                                                bufmgr_gem->exec_count),
2333                             drm_intel_gem_compute_batch_space(bufmgr_gem->exec_bos,
2334                                                               bufmgr_gem->exec_count),
2335                             (unsigned int) bufmgr_gem->gtt_size);
2336                 }
2337         }
2338         drm_intel_update_buffer_offsets2(bufmgr_gem);
2339
2340 skip_execution:
2341         if (bufmgr_gem->bufmgr.debug)
2342                 drm_intel_gem_dump_validation_list(bufmgr_gem);
2343
2344         for (i = 0; i < bufmgr_gem->exec_count; i++) {
2345                 drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
2346                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
2347
2348                 bo_gem->idle = false;
2349
2350                 /* Disconnect the buffer from the validate list */
2351                 bo_gem->validate_index = -1;
2352                 bufmgr_gem->exec_bos[i] = NULL;
2353         }
2354         bufmgr_gem->exec_count = 0;
2355         pthread_mutex_unlock(&bufmgr_gem->lock);
2356
2357         return ret;
2358 }
2359
2360 static int
2361 drm_intel_gem_bo_exec2(drm_intel_bo *bo, int used,
2362                        drm_clip_rect_t *cliprects, int num_cliprects,
2363                        int DR4)
2364 {
2365         return do_exec2(bo, used, NULL, cliprects, num_cliprects, DR4,
2366                         I915_EXEC_RENDER);
2367 }
2368
2369 static int
2370 drm_intel_gem_bo_mrb_exec2(drm_intel_bo *bo, int used,
2371                         drm_clip_rect_t *cliprects, int num_cliprects, int DR4,
2372                         unsigned int flags)
2373 {
2374         return do_exec2(bo, used, NULL, cliprects, num_cliprects, DR4,
2375                         flags);
2376 }
2377
2378 drm_public int
2379 drm_intel_gem_bo_context_exec(drm_intel_bo *bo, drm_intel_context *ctx,
2380                               int used, unsigned int flags)
2381 {
2382         return do_exec2(bo, used, ctx, NULL, 0, 0, flags);
2383 }
2384
2385 static int
2386 drm_intel_gem_bo_pin(drm_intel_bo *bo, uint32_t alignment)
2387 {
2388         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2389         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2390         struct drm_i915_gem_pin pin;
2391         int ret;
2392
2393         VG_CLEAR(pin);
2394         pin.handle = bo_gem->gem_handle;
2395         pin.alignment = alignment;
2396
2397         ret = drmIoctl(bufmgr_gem->fd,
2398                        DRM_IOCTL_I915_GEM_PIN,
2399                        &pin);
2400         if (ret != 0)
2401                 return -errno;
2402
2403         bo->offset64 = pin.offset;
2404         bo->offset = pin.offset;
2405         return 0;
2406 }
2407
2408 static int
2409 drm_intel_gem_bo_unpin(drm_intel_bo *bo)
2410 {
2411         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2412         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2413         struct drm_i915_gem_unpin unpin;
2414         int ret;
2415
2416         VG_CLEAR(unpin);
2417         unpin.handle = bo_gem->gem_handle;
2418
2419         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_UNPIN, &unpin);
2420         if (ret != 0)
2421                 return -errno;
2422
2423         return 0;
2424 }
2425
2426 static int
2427 drm_intel_gem_bo_set_tiling_internal(drm_intel_bo *bo,
2428                                      uint32_t tiling_mode,
2429                                      uint32_t stride)
2430 {
2431         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2432         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2433         struct drm_i915_gem_set_tiling set_tiling;
2434         int ret;
2435
2436         if (bo_gem->global_name == 0 &&
2437             tiling_mode == bo_gem->tiling_mode &&
2438             stride == bo_gem->stride)
2439                 return 0;
2440
2441         memset(&set_tiling, 0, sizeof(set_tiling));
2442         do {
2443                 /* set_tiling is slightly broken and overwrites the
2444                  * input on the error path, so we have to open code
2445                  * rmIoctl.
2446                  */
2447                 set_tiling.handle = bo_gem->gem_handle;
2448                 set_tiling.tiling_mode = tiling_mode;
2449                 set_tiling.stride = stride;
2450
2451                 ret = ioctl(bufmgr_gem->fd,
2452                             DRM_IOCTL_I915_GEM_SET_TILING,
2453                             &set_tiling);
2454         } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
2455         if (ret == -1)
2456                 return -errno;
2457
2458         bo_gem->tiling_mode = set_tiling.tiling_mode;
2459         bo_gem->swizzle_mode = set_tiling.swizzle_mode;
2460         bo_gem->stride = set_tiling.stride;
2461         return 0;
2462 }
2463
2464 static int
2465 drm_intel_gem_bo_set_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
2466                             uint32_t stride)
2467 {
2468         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2469         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2470         int ret;
2471
2472         /* Linear buffers have no stride. By ensuring that we only ever use
2473          * stride 0 with linear buffers, we simplify our code.
2474          */
2475         if (*tiling_mode == I915_TILING_NONE)
2476                 stride = 0;
2477
2478         ret = drm_intel_gem_bo_set_tiling_internal(bo, *tiling_mode, stride);
2479         if (ret == 0)
2480                 drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem);
2481
2482         *tiling_mode = bo_gem->tiling_mode;
2483         return ret;
2484 }
2485
2486 static int
2487 drm_intel_gem_bo_get_tiling(drm_intel_bo *bo, uint32_t * tiling_mode,
2488                             uint32_t * swizzle_mode)
2489 {
2490         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2491
2492         *tiling_mode = bo_gem->tiling_mode;
2493         *swizzle_mode = bo_gem->swizzle_mode;
2494         return 0;
2495 }
2496
2497 drm_public drm_intel_bo *
2498 drm_intel_bo_gem_create_from_prime(drm_intel_bufmgr *bufmgr, int prime_fd, int size)
2499 {
2500         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
2501         int ret;
2502         uint32_t handle;
2503         drm_intel_bo_gem *bo_gem;
2504         struct drm_i915_gem_get_tiling get_tiling;
2505         drmMMListHead *list;
2506
2507         ret = drmPrimeFDToHandle(bufmgr_gem->fd, prime_fd, &handle);
2508
2509         /*
2510          * See if the kernel has already returned this buffer to us. Just as
2511          * for named buffers, we must not create two bo's pointing at the same
2512          * kernel object
2513          */
2514         for (list = bufmgr_gem->named.next;
2515              list != &bufmgr_gem->named;
2516              list = list->next) {
2517                 bo_gem = DRMLISTENTRY(drm_intel_bo_gem, list, name_list);
2518                 if (bo_gem->gem_handle == handle) {
2519                         drm_intel_gem_bo_reference(&bo_gem->bo);
2520                         return &bo_gem->bo;
2521                 }
2522         }
2523
2524         if (ret) {
2525           fprintf(stderr,"ret is %d %d\n", ret, errno);
2526                 return NULL;
2527         }
2528
2529         bo_gem = calloc(1, sizeof(*bo_gem));
2530         if (!bo_gem)
2531                 return NULL;
2532
2533         /* Determine size of bo.  The fd-to-handle ioctl really should
2534          * return the size, but it doesn't.  If we have kernel 3.12 or
2535          * later, we can lseek on the prime fd to get the size.  Older
2536          * kernels will just fail, in which case we fall back to the
2537          * provided (estimated or guess size). */
2538         ret = lseek(prime_fd, 0, SEEK_END);
2539         if (ret != -1)
2540                 bo_gem->bo.size = ret;
2541         else
2542                 bo_gem->bo.size = size;
2543
2544         bo_gem->bo.handle = handle;
2545         bo_gem->bo.bufmgr = bufmgr;
2546
2547         bo_gem->gem_handle = handle;
2548
2549         atomic_set(&bo_gem->refcount, 1);
2550
2551         bo_gem->name = "prime";
2552         bo_gem->validate_index = -1;
2553         bo_gem->reloc_tree_fences = 0;
2554         bo_gem->used_as_reloc_target = false;
2555         bo_gem->has_error = false;
2556         bo_gem->reusable = false;
2557
2558         DRMINITLISTHEAD(&bo_gem->vma_list);
2559         DRMLISTADDTAIL(&bo_gem->name_list, &bufmgr_gem->named);
2560
2561         VG_CLEAR(get_tiling);
2562         get_tiling.handle = bo_gem->gem_handle;
2563         ret = drmIoctl(bufmgr_gem->fd,
2564                        DRM_IOCTL_I915_GEM_GET_TILING,
2565                        &get_tiling);
2566         if (ret != 0) {
2567                 drm_intel_gem_bo_unreference(&bo_gem->bo);
2568                 return NULL;
2569         }
2570         bo_gem->tiling_mode = get_tiling.tiling_mode;
2571         bo_gem->swizzle_mode = get_tiling.swizzle_mode;
2572         /* XXX stride is unknown */
2573         drm_intel_bo_gem_set_in_aperture_size(bufmgr_gem, bo_gem);
2574
2575         return &bo_gem->bo;
2576 }
2577
2578 drm_public int
2579 drm_intel_bo_gem_export_to_prime(drm_intel_bo *bo, int *prime_fd)
2580 {
2581         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2582         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2583
2584         if (DRMLISTEMPTY(&bo_gem->name_list))
2585                 DRMLISTADDTAIL(&bo_gem->name_list, &bufmgr_gem->named);
2586
2587         if (drmPrimeHandleToFD(bufmgr_gem->fd, bo_gem->gem_handle,
2588                                DRM_CLOEXEC, prime_fd) != 0)
2589                 return -errno;
2590
2591         bo_gem->reusable = false;
2592
2593         return 0;
2594 }
2595
2596 static int
2597 drm_intel_gem_bo_flink(drm_intel_bo *bo, uint32_t * name)
2598 {
2599         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bo->bufmgr;
2600         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2601         int ret;
2602
2603         if (!bo_gem->global_name) {
2604                 struct drm_gem_flink flink;
2605
2606                 VG_CLEAR(flink);
2607                 flink.handle = bo_gem->gem_handle;
2608
2609                 ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_GEM_FLINK, &flink);
2610                 if (ret != 0)
2611                         return -errno;
2612
2613                 bo_gem->global_name = flink.name;
2614                 bo_gem->reusable = false;
2615
2616                 if (DRMLISTEMPTY(&bo_gem->name_list))
2617                         DRMLISTADDTAIL(&bo_gem->name_list, &bufmgr_gem->named);
2618         }
2619
2620         *name = bo_gem->global_name;
2621         return 0;
2622 }
2623
2624 /**
2625  * Enables unlimited caching of buffer objects for reuse.
2626  *
2627  * This is potentially very memory expensive, as the cache at each bucket
2628  * size is only bounded by how many buffers of that size we've managed to have
2629  * in flight at once.
2630  */
2631 drm_public void
2632 drm_intel_bufmgr_gem_enable_reuse(drm_intel_bufmgr *bufmgr)
2633 {
2634         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *) bufmgr;
2635
2636         bufmgr_gem->bo_reuse = true;
2637 }
2638
2639 /**
2640  * Enable use of fenced reloc type.
2641  *
2642  * New code should enable this to avoid unnecessary fence register
2643  * allocation.  If this option is not enabled, all relocs will have fence
2644  * register allocated.
2645  */
2646 drm_public void
2647 drm_intel_bufmgr_gem_enable_fenced_relocs(drm_intel_bufmgr *bufmgr)
2648 {
2649         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
2650
2651         if (bufmgr_gem->bufmgr.bo_exec == drm_intel_gem_bo_exec2)
2652                 bufmgr_gem->fenced_relocs = true;
2653 }
2654
2655 /**
2656  * Return the additional aperture space required by the tree of buffer objects
2657  * rooted at bo.
2658  */
2659 static int
2660 drm_intel_gem_bo_get_aperture_space(drm_intel_bo *bo)
2661 {
2662         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2663         int i;
2664         int total = 0;
2665
2666         if (bo == NULL || bo_gem->included_in_check_aperture)
2667                 return 0;
2668
2669         total += bo->size;
2670         bo_gem->included_in_check_aperture = true;
2671
2672         for (i = 0; i < bo_gem->reloc_count; i++)
2673                 total +=
2674                     drm_intel_gem_bo_get_aperture_space(bo_gem->
2675                                                         reloc_target_info[i].bo);
2676
2677         return total;
2678 }
2679
2680 /**
2681  * Count the number of buffers in this list that need a fence reg
2682  *
2683  * If the count is greater than the number of available regs, we'll have
2684  * to ask the caller to resubmit a batch with fewer tiled buffers.
2685  *
2686  * This function over-counts if the same buffer is used multiple times.
2687  */
2688 static unsigned int
2689 drm_intel_gem_total_fences(drm_intel_bo ** bo_array, int count)
2690 {
2691         int i;
2692         unsigned int total = 0;
2693
2694         for (i = 0; i < count; i++) {
2695                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo_array[i];
2696
2697                 if (bo_gem == NULL)
2698                         continue;
2699
2700                 total += bo_gem->reloc_tree_fences;
2701         }
2702         return total;
2703 }
2704
2705 /**
2706  * Clear the flag set by drm_intel_gem_bo_get_aperture_space() so we're ready
2707  * for the next drm_intel_bufmgr_check_aperture_space() call.
2708  */
2709 static void
2710 drm_intel_gem_bo_clear_aperture_space_flag(drm_intel_bo *bo)
2711 {
2712         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2713         int i;
2714
2715         if (bo == NULL || !bo_gem->included_in_check_aperture)
2716                 return;
2717
2718         bo_gem->included_in_check_aperture = false;
2719
2720         for (i = 0; i < bo_gem->reloc_count; i++)
2721                 drm_intel_gem_bo_clear_aperture_space_flag(bo_gem->
2722                                                            reloc_target_info[i].bo);
2723 }
2724
2725 /**
2726  * Return a conservative estimate for the amount of aperture required
2727  * for a collection of buffers. This may double-count some buffers.
2728  */
2729 static unsigned int
2730 drm_intel_gem_estimate_batch_space(drm_intel_bo **bo_array, int count)
2731 {
2732         int i;
2733         unsigned int total = 0;
2734
2735         for (i = 0; i < count; i++) {
2736                 drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo_array[i];
2737                 if (bo_gem != NULL)
2738                         total += bo_gem->reloc_tree_size;
2739         }
2740         return total;
2741 }
2742
2743 /**
2744  * Return the amount of aperture needed for a collection of buffers.
2745  * This avoids double counting any buffers, at the cost of looking
2746  * at every buffer in the set.
2747  */
2748 static unsigned int
2749 drm_intel_gem_compute_batch_space(drm_intel_bo **bo_array, int count)
2750 {
2751         int i;
2752         unsigned int total = 0;
2753
2754         for (i = 0; i < count; i++) {
2755                 total += drm_intel_gem_bo_get_aperture_space(bo_array[i]);
2756                 /* For the first buffer object in the array, we get an
2757                  * accurate count back for its reloc_tree size (since nothing
2758                  * had been flagged as being counted yet).  We can save that
2759                  * value out as a more conservative reloc_tree_size that
2760                  * avoids double-counting target buffers.  Since the first
2761                  * buffer happens to usually be the batch buffer in our
2762                  * callers, this can pull us back from doing the tree
2763                  * walk on every new batch emit.
2764                  */
2765                 if (i == 0) {
2766                         drm_intel_bo_gem *bo_gem =
2767                             (drm_intel_bo_gem *) bo_array[i];
2768                         bo_gem->reloc_tree_size = total;
2769                 }
2770         }
2771
2772         for (i = 0; i < count; i++)
2773                 drm_intel_gem_bo_clear_aperture_space_flag(bo_array[i]);
2774         return total;
2775 }
2776
2777 /**
2778  * Return -1 if the batchbuffer should be flushed before attempting to
2779  * emit rendering referencing the buffers pointed to by bo_array.
2780  *
2781  * This is required because if we try to emit a batchbuffer with relocations
2782  * to a tree of buffers that won't simultaneously fit in the aperture,
2783  * the rendering will return an error at a point where the software is not
2784  * prepared to recover from it.
2785  *
2786  * However, we also want to emit the batchbuffer significantly before we reach
2787  * the limit, as a series of batchbuffers each of which references buffers
2788  * covering almost all of the aperture means that at each emit we end up
2789  * waiting to evict a buffer from the last rendering, and we get synchronous
2790  * performance.  By emitting smaller batchbuffers, we eat some CPU overhead to
2791  * get better parallelism.
2792  */
2793 static int
2794 drm_intel_gem_check_aperture_space(drm_intel_bo **bo_array, int count)
2795 {
2796         drm_intel_bufmgr_gem *bufmgr_gem =
2797             (drm_intel_bufmgr_gem *) bo_array[0]->bufmgr;
2798         unsigned int total = 0;
2799         unsigned int threshold = bufmgr_gem->gtt_size * 3 / 4;
2800         int total_fences;
2801
2802         /* Check for fence reg constraints if necessary */
2803         if (bufmgr_gem->available_fences) {
2804                 total_fences = drm_intel_gem_total_fences(bo_array, count);
2805                 if (total_fences > bufmgr_gem->available_fences)
2806                         return -ENOSPC;
2807         }
2808
2809         total = drm_intel_gem_estimate_batch_space(bo_array, count);
2810
2811         if (total > threshold)
2812                 total = drm_intel_gem_compute_batch_space(bo_array, count);
2813
2814         if (total > threshold) {
2815                 DBG("check_space: overflowed available aperture, "
2816                     "%dkb vs %dkb\n",
2817                     total / 1024, (int)bufmgr_gem->gtt_size / 1024);
2818                 return -ENOSPC;
2819         } else {
2820                 DBG("drm_check_space: total %dkb vs bufgr %dkb\n", total / 1024,
2821                     (int)bufmgr_gem->gtt_size / 1024);
2822                 return 0;
2823         }
2824 }
2825
2826 /*
2827  * Disable buffer reuse for objects which are shared with the kernel
2828  * as scanout buffers
2829  */
2830 static int
2831 drm_intel_gem_bo_disable_reuse(drm_intel_bo *bo)
2832 {
2833         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2834
2835         bo_gem->reusable = false;
2836         return 0;
2837 }
2838
2839 static int
2840 drm_intel_gem_bo_is_reusable(drm_intel_bo *bo)
2841 {
2842         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2843
2844         return bo_gem->reusable;
2845 }
2846
2847 static int
2848 _drm_intel_gem_bo_references(drm_intel_bo *bo, drm_intel_bo *target_bo)
2849 {
2850         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
2851         int i;
2852
2853         for (i = 0; i < bo_gem->reloc_count; i++) {
2854                 if (bo_gem->reloc_target_info[i].bo == target_bo)
2855                         return 1;
2856                 if (bo == bo_gem->reloc_target_info[i].bo)
2857                         continue;
2858                 if (_drm_intel_gem_bo_references(bo_gem->reloc_target_info[i].bo,
2859                                                 target_bo))
2860                         return 1;
2861         }
2862
2863         return 0;
2864 }
2865
2866 /** Return true if target_bo is referenced by bo's relocation tree. */
2867 static int
2868 drm_intel_gem_bo_references(drm_intel_bo *bo, drm_intel_bo *target_bo)
2869 {
2870         drm_intel_bo_gem *target_bo_gem = (drm_intel_bo_gem *) target_bo;
2871
2872         if (bo == NULL || target_bo == NULL)
2873                 return 0;
2874         if (target_bo_gem->used_as_reloc_target)
2875                 return _drm_intel_gem_bo_references(bo, target_bo);
2876         return 0;
2877 }
2878
2879 static void
2880 add_bucket(drm_intel_bufmgr_gem *bufmgr_gem, int size)
2881 {
2882         unsigned int i = bufmgr_gem->num_buckets;
2883
2884         assert(i < ARRAY_SIZE(bufmgr_gem->cache_bucket));
2885
2886         DRMINITLISTHEAD(&bufmgr_gem->cache_bucket[i].head);
2887         bufmgr_gem->cache_bucket[i].size = size;
2888         bufmgr_gem->num_buckets++;
2889 }
2890
2891 static void
2892 init_cache_buckets(drm_intel_bufmgr_gem *bufmgr_gem)
2893 {
2894         unsigned long size, cache_max_size = 64 * 1024 * 1024;
2895
2896         /* OK, so power of two buckets was too wasteful of memory.
2897          * Give 3 other sizes between each power of two, to hopefully
2898          * cover things accurately enough.  (The alternative is
2899          * probably to just go for exact matching of sizes, and assume
2900          * that for things like composited window resize the tiled
2901          * width/height alignment and rounding of sizes to pages will
2902          * get us useful cache hit rates anyway)
2903          */
2904         add_bucket(bufmgr_gem, 4096);
2905         add_bucket(bufmgr_gem, 4096 * 2);
2906         add_bucket(bufmgr_gem, 4096 * 3);
2907
2908         /* Initialize the linked lists for BO reuse cache. */
2909         for (size = 4 * 4096; size <= cache_max_size; size *= 2) {
2910                 add_bucket(bufmgr_gem, size);
2911
2912                 add_bucket(bufmgr_gem, size + size * 1 / 4);
2913                 add_bucket(bufmgr_gem, size + size * 2 / 4);
2914                 add_bucket(bufmgr_gem, size + size * 3 / 4);
2915         }
2916 }
2917
2918 drm_public void
2919 drm_intel_bufmgr_gem_set_vma_cache_size(drm_intel_bufmgr *bufmgr, int limit)
2920 {
2921         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
2922
2923         bufmgr_gem->vma_max = limit;
2924
2925         drm_intel_gem_bo_purge_vma_cache(bufmgr_gem);
2926 }
2927
2928 /**
2929  * Get the PCI ID for the device.  This can be overridden by setting the
2930  * INTEL_DEVID_OVERRIDE environment variable to the desired ID.
2931  */
2932 static int
2933 get_pci_device_id(drm_intel_bufmgr_gem *bufmgr_gem)
2934 {
2935         char *devid_override;
2936         int devid;
2937         int ret;
2938         drm_i915_getparam_t gp;
2939
2940         if (geteuid() == getuid()) {
2941                 devid_override = getenv("INTEL_DEVID_OVERRIDE");
2942                 if (devid_override) {
2943                         bufmgr_gem->no_exec = true;
2944                         return strtod(devid_override, NULL);
2945                 }
2946         }
2947
2948         VG_CLEAR(devid);
2949         VG_CLEAR(gp);
2950         gp.param = I915_PARAM_CHIPSET_ID;
2951         gp.value = &devid;
2952         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
2953         if (ret) {
2954                 fprintf(stderr, "get chip id failed: %d [%d]\n", ret, errno);
2955                 fprintf(stderr, "param: %d, val: %d\n", gp.param, *gp.value);
2956         }
2957         return devid;
2958 }
2959
2960 drm_public int
2961 drm_intel_bufmgr_gem_get_devid(drm_intel_bufmgr *bufmgr)
2962 {
2963         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
2964
2965         return bufmgr_gem->pci_device;
2966 }
2967
2968 /**
2969  * Sets the AUB filename.
2970  *
2971  * This function has to be called before drm_intel_bufmgr_gem_set_aub_dump()
2972  * for it to have any effect.
2973  */
2974 drm_public void
2975 drm_intel_bufmgr_gem_set_aub_filename(drm_intel_bufmgr *bufmgr,
2976                                       const char *filename)
2977 {
2978         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
2979
2980         free(bufmgr_gem->aub_filename);
2981         if (filename)
2982                 bufmgr_gem->aub_filename = strdup(filename);
2983 }
2984
2985 /**
2986  * Sets up AUB dumping.
2987  *
2988  * This is a trace file format that can be used with the simulator.
2989  * Packets are emitted in a format somewhat like GPU command packets.
2990  * You can set up a GTT and upload your objects into the referenced
2991  * space, then send off batchbuffers and get BMPs out the other end.
2992  */
2993 drm_public void
2994 drm_intel_bufmgr_gem_set_aub_dump(drm_intel_bufmgr *bufmgr, int enable)
2995 {
2996         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
2997         int entry = 0x200003;
2998         int i;
2999         int gtt_size = 0x10000;
3000         const char *filename;
3001
3002         if (!enable) {
3003                 if (bufmgr_gem->aub_file) {
3004                         fclose(bufmgr_gem->aub_file);
3005                         bufmgr_gem->aub_file = NULL;
3006                 }
3007                 return;
3008         }
3009
3010         if (geteuid() != getuid())
3011                 return;
3012
3013         if (bufmgr_gem->aub_filename)
3014                 filename = bufmgr_gem->aub_filename;
3015         else
3016                 filename = "intel.aub";
3017         bufmgr_gem->aub_file = fopen(filename, "w+");
3018         if (!bufmgr_gem->aub_file)
3019                 return;
3020
3021         /* Start allocating objects from just after the GTT. */
3022         bufmgr_gem->aub_offset = gtt_size;
3023
3024         /* Start with a (required) version packet. */
3025         aub_out(bufmgr_gem, CMD_AUB_HEADER | (13 - 2));
3026         aub_out(bufmgr_gem,
3027                 (4 << AUB_HEADER_MAJOR_SHIFT) |
3028                 (0 << AUB_HEADER_MINOR_SHIFT));
3029         for (i = 0; i < 8; i++) {
3030                 aub_out(bufmgr_gem, 0); /* app name */
3031         }
3032         aub_out(bufmgr_gem, 0); /* timestamp */
3033         aub_out(bufmgr_gem, 0); /* timestamp */
3034         aub_out(bufmgr_gem, 0); /* comment len */
3035
3036         /* Set up the GTT. The max we can handle is 256M */
3037         aub_out(bufmgr_gem, CMD_AUB_TRACE_HEADER_BLOCK | ((bufmgr_gem->gen >= 8 ? 6 : 5) - 2));
3038         aub_out(bufmgr_gem, AUB_TRACE_MEMTYPE_NONLOCAL | 0 | AUB_TRACE_OP_DATA_WRITE);
3039         aub_out(bufmgr_gem, 0); /* subtype */
3040         aub_out(bufmgr_gem, 0); /* offset */
3041         aub_out(bufmgr_gem, gtt_size); /* size */
3042         if (bufmgr_gem->gen >= 8)
3043                 aub_out(bufmgr_gem, 0);
3044         for (i = 0x000; i < gtt_size; i += 4, entry += 0x1000) {
3045                 aub_out(bufmgr_gem, entry);
3046         }
3047 }
3048
3049 drm_public drm_intel_context *
3050 drm_intel_gem_context_create(drm_intel_bufmgr *bufmgr)
3051 {
3052         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
3053         struct drm_i915_gem_context_create create;
3054         drm_intel_context *context = NULL;
3055         int ret;
3056
3057         context = calloc(1, sizeof(*context));
3058         if (!context)
3059                 return NULL;
3060
3061         VG_CLEAR(create);
3062         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_CONTEXT_CREATE, &create);
3063         if (ret != 0) {
3064                 DBG("DRM_IOCTL_I915_GEM_CONTEXT_CREATE failed: %s\n",
3065                     strerror(errno));
3066                 free(context);
3067                 return NULL;
3068         }
3069
3070         context->ctx_id = create.ctx_id;
3071         context->bufmgr = bufmgr;
3072
3073         return context;
3074 }
3075
3076 drm_public void
3077 drm_intel_gem_context_destroy(drm_intel_context *ctx)
3078 {
3079         drm_intel_bufmgr_gem *bufmgr_gem;
3080         struct drm_i915_gem_context_destroy destroy;
3081         int ret;
3082
3083         if (ctx == NULL)
3084                 return;
3085
3086         VG_CLEAR(destroy);
3087
3088         bufmgr_gem = (drm_intel_bufmgr_gem *)ctx->bufmgr;
3089         destroy.ctx_id = ctx->ctx_id;
3090         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_CONTEXT_DESTROY,
3091                        &destroy);
3092         if (ret != 0)
3093                 fprintf(stderr, "DRM_IOCTL_I915_GEM_CONTEXT_DESTROY failed: %s\n",
3094                         strerror(errno));
3095
3096         free(ctx);
3097 }
3098
3099 drm_public int
3100 drm_intel_get_reset_stats(drm_intel_context *ctx,
3101                           uint32_t *reset_count,
3102                           uint32_t *active,
3103                           uint32_t *pending)
3104 {
3105         drm_intel_bufmgr_gem *bufmgr_gem;
3106         struct drm_i915_reset_stats stats;
3107         int ret;
3108
3109         if (ctx == NULL)
3110                 return -EINVAL;
3111
3112         memset(&stats, 0, sizeof(stats));
3113
3114         bufmgr_gem = (drm_intel_bufmgr_gem *)ctx->bufmgr;
3115         stats.ctx_id = ctx->ctx_id;
3116         ret = drmIoctl(bufmgr_gem->fd,
3117                        DRM_IOCTL_I915_GET_RESET_STATS,
3118                        &stats);
3119         if (ret == 0) {
3120                 if (reset_count != NULL)
3121                         *reset_count = stats.reset_count;
3122
3123                 if (active != NULL)
3124                         *active = stats.batch_active;
3125
3126                 if (pending != NULL)
3127                         *pending = stats.batch_pending;
3128         }
3129
3130         return ret;
3131 }
3132
3133 drm_public int
3134 drm_intel_reg_read(drm_intel_bufmgr *bufmgr,
3135                    uint32_t offset,
3136                    uint64_t *result)
3137 {
3138         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
3139         struct drm_i915_reg_read reg_read;
3140         int ret;
3141
3142         VG_CLEAR(reg_read);
3143         reg_read.offset = offset;
3144
3145         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_REG_READ, &reg_read);
3146
3147         *result = reg_read.val;
3148         return ret;
3149 }
3150
3151
3152 /**
3153  * Annotate the given bo for use in aub dumping.
3154  *
3155  * \param annotations is an array of drm_intel_aub_annotation objects
3156  * describing the type of data in various sections of the bo.  Each
3157  * element of the array specifies the type and subtype of a section of
3158  * the bo, and the past-the-end offset of that section.  The elements
3159  * of \c annotations must be sorted so that ending_offset is
3160  * increasing.
3161  *
3162  * \param count is the number of elements in the \c annotations array.
3163  * If \c count is zero, then \c annotations will not be dereferenced.
3164  *
3165  * Annotations are copied into a private data structure, so caller may
3166  * re-use the memory pointed to by \c annotations after the call
3167  * returns.
3168  *
3169  * Annotations are stored for the lifetime of the bo; to reset to the
3170  * default state (no annotations), call this function with a \c count
3171  * of zero.
3172  */
3173 drm_public void
3174 drm_intel_bufmgr_gem_set_aub_annotations(drm_intel_bo *bo,
3175                                          drm_intel_aub_annotation *annotations,
3176                                          unsigned count)
3177 {
3178         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *) bo;
3179         unsigned size = sizeof(*annotations) * count;
3180         drm_intel_aub_annotation *new_annotations =
3181                 count > 0 ? realloc(bo_gem->aub_annotations, size) : NULL;
3182         if (new_annotations == NULL) {
3183                 free(bo_gem->aub_annotations);
3184                 bo_gem->aub_annotations = NULL;
3185                 bo_gem->aub_annotation_count = 0;
3186                 return;
3187         }
3188         memcpy(new_annotations, annotations, size);
3189         bo_gem->aub_annotations = new_annotations;
3190         bo_gem->aub_annotation_count = count;
3191 }
3192
3193 static pthread_mutex_t bufmgr_list_mutex = PTHREAD_MUTEX_INITIALIZER;
3194 static drmMMListHead bufmgr_list = { &bufmgr_list, &bufmgr_list };
3195
3196 static drm_intel_bufmgr_gem *
3197 drm_intel_bufmgr_gem_find(int fd)
3198 {
3199         drm_intel_bufmgr_gem *bufmgr_gem;
3200
3201         DRMLISTFOREACHENTRY(bufmgr_gem, &bufmgr_list, managers) {
3202                 if (bufmgr_gem->fd == fd) {
3203                         atomic_inc(&bufmgr_gem->refcount);
3204                         return bufmgr_gem;
3205                 }
3206         }
3207
3208         return NULL;
3209 }
3210
3211 static void
3212 drm_intel_bufmgr_gem_unref(drm_intel_bufmgr *bufmgr)
3213 {
3214         drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
3215
3216         if (atomic_add_unless(&bufmgr_gem->refcount, -1, 1)) {
3217                 pthread_mutex_lock(&bufmgr_list_mutex);
3218
3219                 if (atomic_dec_and_test(&bufmgr_gem->refcount)) {
3220                         DRMLISTDEL(&bufmgr_gem->managers);
3221                         drm_intel_bufmgr_gem_destroy(bufmgr);
3222                 }
3223
3224                 pthread_mutex_unlock(&bufmgr_list_mutex);
3225         }
3226 }
3227
3228 /**
3229  * Initializes the GEM buffer manager, which uses the kernel to allocate, map,
3230  * and manage map buffer objections.
3231  *
3232  * \param fd File descriptor of the opened DRM device.
3233  */
3234 drm_public drm_intel_bufmgr *
3235 drm_intel_bufmgr_gem_init(int fd, int batch_size)
3236 {
3237         drm_intel_bufmgr_gem *bufmgr_gem;
3238         struct drm_i915_gem_get_aperture aperture;
3239         drm_i915_getparam_t gp;
3240         int ret, tmp;
3241         bool exec2 = false;
3242
3243         pthread_mutex_lock(&bufmgr_list_mutex);
3244
3245         bufmgr_gem = drm_intel_bufmgr_gem_find(fd);
3246         if (bufmgr_gem)
3247                 goto exit;
3248
3249         bufmgr_gem = calloc(1, sizeof(*bufmgr_gem));
3250         if (bufmgr_gem == NULL)
3251                 goto exit;
3252
3253         bufmgr_gem->fd = fd;
3254         atomic_set(&bufmgr_gem->refcount, 1);
3255
3256         if (pthread_mutex_init(&bufmgr_gem->lock, NULL) != 0) {
3257                 free(bufmgr_gem);
3258                 bufmgr_gem = NULL;
3259                 goto exit;
3260         }
3261
3262         ret = drmIoctl(bufmgr_gem->fd,
3263                        DRM_IOCTL_I915_GEM_GET_APERTURE,
3264                        &aperture);
3265
3266         if (ret == 0)
3267                 bufmgr_gem->gtt_size = aperture.aper_available_size;
3268         else {
3269                 fprintf(stderr, "DRM_IOCTL_I915_GEM_APERTURE failed: %s\n",
3270                         strerror(errno));
3271                 bufmgr_gem->gtt_size = 128 * 1024 * 1024;
3272                 fprintf(stderr, "Assuming %dkB available aperture size.\n"
3273                         "May lead to reduced performance or incorrect "
3274                         "rendering.\n",
3275                         (int)bufmgr_gem->gtt_size / 1024);
3276         }
3277
3278         bufmgr_gem->pci_device = get_pci_device_id(bufmgr_gem);
3279
3280         if (IS_GEN2(bufmgr_gem->pci_device))
3281                 bufmgr_gem->gen = 2;
3282         else if (IS_GEN3(bufmgr_gem->pci_device))
3283                 bufmgr_gem->gen = 3;
3284         else if (IS_GEN4(bufmgr_gem->pci_device))
3285                 bufmgr_gem->gen = 4;
3286         else if (IS_GEN5(bufmgr_gem->pci_device))
3287                 bufmgr_gem->gen = 5;
3288         else if (IS_GEN6(bufmgr_gem->pci_device))
3289                 bufmgr_gem->gen = 6;
3290         else if (IS_GEN7(bufmgr_gem->pci_device))
3291                 bufmgr_gem->gen = 7;
3292         else if (IS_GEN8(bufmgr_gem->pci_device))
3293                 bufmgr_gem->gen = 8;
3294         else {
3295                 free(bufmgr_gem);
3296                 bufmgr_gem = NULL;
3297                 goto exit;
3298         }
3299
3300         if (IS_GEN3(bufmgr_gem->pci_device) &&
3301             bufmgr_gem->gtt_size > 256*1024*1024) {
3302                 /* The unmappable part of gtt on gen 3 (i.e. above 256MB) can't
3303                  * be used for tiled blits. To simplify the accounting, just
3304                  * substract the unmappable part (fixed to 256MB on all known
3305                  * gen3 devices) if the kernel advertises it. */
3306                 bufmgr_gem->gtt_size -= 256*1024*1024;
3307         }
3308
3309         VG_CLEAR(gp);
3310         gp.value = &tmp;
3311
3312         gp.param = I915_PARAM_HAS_EXECBUF2;
3313         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3314         if (!ret)
3315                 exec2 = true;
3316
3317         gp.param = I915_PARAM_HAS_BSD;
3318         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3319         bufmgr_gem->has_bsd = ret == 0;
3320
3321         gp.param = I915_PARAM_HAS_BLT;
3322         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3323         bufmgr_gem->has_blt = ret == 0;
3324
3325         gp.param = I915_PARAM_HAS_RELAXED_FENCING;
3326         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3327         bufmgr_gem->has_relaxed_fencing = ret == 0;
3328
3329         gp.param = I915_PARAM_HAS_WAIT_TIMEOUT;
3330         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3331         bufmgr_gem->has_wait_timeout = ret == 0;
3332
3333         gp.param = I915_PARAM_HAS_LLC;
3334         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3335         if (ret != 0) {
3336                 /* Kernel does not supports HAS_LLC query, fallback to GPU
3337                  * generation detection and assume that we have LLC on GEN6/7
3338                  */
3339                 bufmgr_gem->has_llc = (IS_GEN6(bufmgr_gem->pci_device) |
3340                                 IS_GEN7(bufmgr_gem->pci_device));
3341         } else
3342                 bufmgr_gem->has_llc = *gp.value;
3343
3344         gp.param = I915_PARAM_HAS_VEBOX;
3345         ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3346         bufmgr_gem->has_vebox = (ret == 0) & (*gp.value > 0);
3347
3348         if (bufmgr_gem->gen < 4) {
3349                 gp.param = I915_PARAM_NUM_FENCES_AVAIL;
3350                 gp.value = &bufmgr_gem->available_fences;
3351                 ret = drmIoctl(bufmgr_gem->fd, DRM_IOCTL_I915_GETPARAM, &gp);
3352                 if (ret) {
3353                         fprintf(stderr, "get fences failed: %d [%d]\n", ret,
3354                                 errno);
3355                         fprintf(stderr, "param: %d, val: %d\n", gp.param,
3356                                 *gp.value);
3357                         bufmgr_gem->available_fences = 0;
3358                 } else {
3359                         /* XXX The kernel reports the total number of fences,
3360                          * including any that may be pinned.
3361                          *
3362                          * We presume that there will be at least one pinned
3363                          * fence for the scanout buffer, but there may be more
3364                          * than one scanout and the user may be manually
3365                          * pinning buffers. Let's move to execbuffer2 and
3366                          * thereby forget the insanity of using fences...
3367                          */
3368                         bufmgr_gem->available_fences -= 2;
3369                         if (bufmgr_gem->available_fences < 0)
3370                                 bufmgr_gem->available_fences = 0;
3371                 }
3372         }
3373
3374         /* Let's go with one relocation per every 2 dwords (but round down a bit
3375          * since a power of two will mean an extra page allocation for the reloc
3376          * buffer).
3377          *
3378          * Every 4 was too few for the blender benchmark.
3379          */
3380         bufmgr_gem->max_relocs = batch_size / sizeof(uint32_t) / 2 - 2;
3381
3382         bufmgr_gem->bufmgr.bo_alloc = drm_intel_gem_bo_alloc;
3383         bufmgr_gem->bufmgr.bo_alloc_for_render =
3384             drm_intel_gem_bo_alloc_for_render;
3385         bufmgr_gem->bufmgr.bo_alloc_tiled = drm_intel_gem_bo_alloc_tiled;
3386         bufmgr_gem->bufmgr.bo_reference = drm_intel_gem_bo_reference;
3387         bufmgr_gem->bufmgr.bo_unreference = drm_intel_gem_bo_unreference;
3388         bufmgr_gem->bufmgr.bo_map = drm_intel_gem_bo_map;
3389         bufmgr_gem->bufmgr.bo_unmap = drm_intel_gem_bo_unmap;
3390         bufmgr_gem->bufmgr.bo_subdata = drm_intel_gem_bo_subdata;
3391         bufmgr_gem->bufmgr.bo_get_subdata = drm_intel_gem_bo_get_subdata;
3392         bufmgr_gem->bufmgr.bo_wait_rendering = drm_intel_gem_bo_wait_rendering;
3393         bufmgr_gem->bufmgr.bo_emit_reloc = drm_intel_gem_bo_emit_reloc;
3394         bufmgr_gem->bufmgr.bo_emit_reloc_fence = drm_intel_gem_bo_emit_reloc_fence;
3395         bufmgr_gem->bufmgr.bo_pin = drm_intel_gem_bo_pin;
3396         bufmgr_gem->bufmgr.bo_unpin = drm_intel_gem_bo_unpin;
3397         bufmgr_gem->bufmgr.bo_get_tiling = drm_intel_gem_bo_get_tiling;
3398         bufmgr_gem->bufmgr.bo_set_tiling = drm_intel_gem_bo_set_tiling;
3399         bufmgr_gem->bufmgr.bo_flink = drm_intel_gem_bo_flink;
3400         /* Use the new one if available */
3401         if (exec2) {
3402                 bufmgr_gem->bufmgr.bo_exec = drm_intel_gem_bo_exec2;
3403                 bufmgr_gem->bufmgr.bo_mrb_exec = drm_intel_gem_bo_mrb_exec2;
3404         } else
3405                 bufmgr_gem->bufmgr.bo_exec = drm_intel_gem_bo_exec;
3406         bufmgr_gem->bufmgr.bo_busy = drm_intel_gem_bo_busy;
3407         bufmgr_gem->bufmgr.bo_madvise = drm_intel_gem_bo_madvise;
3408         bufmgr_gem->bufmgr.destroy = drm_intel_bufmgr_gem_unref;
3409         bufmgr_gem->bufmgr.debug = 0;
3410         bufmgr_gem->bufmgr.check_aperture_space =
3411             drm_intel_gem_check_aperture_space;
3412         bufmgr_gem->bufmgr.bo_disable_reuse = drm_intel_gem_bo_disable_reuse;
3413         bufmgr_gem->bufmgr.bo_is_reusable = drm_intel_gem_bo_is_reusable;
3414         bufmgr_gem->bufmgr.get_pipe_from_crtc_id =
3415             drm_intel_gem_get_pipe_from_crtc_id;
3416         bufmgr_gem->bufmgr.bo_references = drm_intel_gem_bo_references;
3417
3418         DRMINITLISTHEAD(&bufmgr_gem->named);
3419         init_cache_buckets(bufmgr_gem);
3420
3421         DRMINITLISTHEAD(&bufmgr_gem->vma_cache);
3422         bufmgr_gem->vma_max = -1; /* unlimited by default */
3423
3424         DRMLISTADD(&bufmgr_gem->managers, &bufmgr_list);
3425
3426 exit:
3427         pthread_mutex_unlock(&bufmgr_list_mutex);
3428
3429         return bufmgr_gem != NULL ? &bufmgr_gem->bufmgr : NULL;
3430 }