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