libdrm/intel/intel_bufmgr_gem.c

   1 /**************************************************************************
   2  *
   3  * Copyright © 2007 Red Hat Inc.
   4  * Copyright © 2007 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 <fcntl.h>
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <string.h>
  46 #include <unistd.h>
  47 #include <assert.h>
  48 #include <pthread.h>
  49 #include <sys/ioctl.h>
  50 #include <sys/mman.h>
  51 #include <sys/stat.h>
  52 #include <sys/types.h>
  53
  54 #include "errno.h"
  55 #include "intel_bufmgr.h"
  56 #include "intel_bufmgr_priv.h"
  57 #include "string.h"
  58
  59 #include "i915_drm.h"
  60
  61 #define DBG(...) do {                                   \
  62    if (bufmgr_gem->bufmgr.debug)                        \
  63       fprintf(stderr, __VA_ARGS__);                     \
  64 } while (0)
  65
  66 typedef struct _drm_intel_bo_gem drm_intel_bo_gem;
  67
  68 struct drm_intel_gem_bo_bucket {
  69    drm_intel_bo_gem *head, **tail;
  70    /**
  71     * Limit on the number of entries in this bucket.
  72     *
  73     * 0 means that this caching at this bucket size is disabled.
  74     * -1 means that there is no limit to caching at this size.
  75     */
  76    int max_entries;
  77    int num_entries;
  78 };
  79
  80 /* Arbitrarily chosen, 16 means that the maximum size we'll cache for reuse
  81  * is 1 << 16 pages, or 256MB.
  82  */
  83 #define DRM_INTEL_GEM_BO_BUCKETS        16
  84 typedef struct _drm_intel_bufmgr_gem {
  85     drm_intel_bufmgr bufmgr;
  86
  87     int fd;
  88
  89     int max_relocs;
  90
  91     pthread_mutex_t lock;
  92
  93     struct drm_i915_gem_exec_object *exec_objects;
  94     drm_intel_bo **exec_bos;
  95     int exec_size;
  96     int exec_count;
  97
  98     /** Array of lists of cached gem objects of power-of-two sizes */
  99     struct drm_intel_gem_bo_bucket cache_bucket[DRM_INTEL_GEM_BO_BUCKETS];
 100
 101     uint64_t gtt_size;
 102 } drm_intel_bufmgr_gem;
 103
 104 struct _drm_intel_bo_gem {
 105     drm_intel_bo bo;
 106
 107     int refcount;
 108     /** Boolean whether the mmap ioctl has been called for this buffer yet. */
 109     int mapped;
 110     uint32_t gem_handle;
 111     const char *name;
 112
 113     /**
 114      * Kenel-assigned global name for this object
 115      */
 116     unsigned int global_name;
 117
 118     /**
 119      * Index of the buffer within the validation list while preparing a
 120      * batchbuffer execution.
 121      */
 122     int validate_index;
 123
 124     /**
 125      * Boolean whether we've started swrast
 126      * Set when the buffer has been mapped
 127      * Cleared when the buffer is unmapped
 128      */
 129     int swrast;
 130
 131     /** Array passed to the DRM containing relocation information. */
 132     struct drm_i915_gem_relocation_entry *relocs;
 133     /** Array of bos corresponding to relocs[i].target_handle */
 134     drm_intel_bo **reloc_target_bo;
 135     /** Number of entries in relocs */
 136     int reloc_count;
 137     /** Mapped address for the buffer */
 138     void *virtual;
 139
 140     /** free list */
 141     drm_intel_bo_gem *next;
 142
 143     /**
 144      * Boolean of whether this BO and its children have been included in
 145      * the current drm_intel_bufmgr_check_aperture_space() total.
 146      */
 147     char included_in_check_aperture;
 148
 149     /**
 150      * Boolean of whether this buffer has been used as a relocation
 151      * target and had its size accounted for, and thus can't have any
 152      * further relocations added to it.
 153      */
 154      char used_as_reloc_target;
 155
 156     /**
 157      * Size in bytes of this buffer and its relocation descendents.
 158      *
 159      * Used to avoid costly tree walking in drm_intel_bufmgr_check_aperture in
 160      * the common case.
 161      */
 162     int reloc_tree_size;
 163 };
 164
 165 static void drm_intel_gem_bo_reference_locked(drm_intel_bo *bo);
 166
 167 static int
 168 logbase2(int n)
 169 {
 170    int i = 1;
 171    int log2 = 0;
 172
 173    while (n > i) {
 174       i *= 2;
 175       log2++;
 176    }
 177
 178    return log2;
 179 }
 180
 181 static struct drm_intel_gem_bo_bucket *
 182 drm_intel_gem_bo_bucket_for_size(drm_intel_bufmgr_gem *bufmgr_gem,
 183                                  unsigned long size)
 184 {
 185     int i;
 186
 187     /* We only do buckets in power of two increments */
 188     if ((size & (size - 1)) != 0)
 189         return NULL;
 190
 191     /* We should only see sizes rounded to pages. */
 192     assert((size % 4096) == 0);
 193
 194     /* We always allocate in units of pages */
 195     i = ffs(size / 4096) - 1;
 196     if (i >= DRM_INTEL_GEM_BO_BUCKETS)
 197         return NULL;
 198
 199     return &bufmgr_gem->cache_bucket[i];
 200 }
 201
 202
 203 static void drm_intel_gem_dump_validation_list(drm_intel_bufmgr_gem *bufmgr_gem)
 204 {
 205     int i, j;
 206
 207     for (i = 0; i < bufmgr_gem->exec_count; i++) {
 208         drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
 209         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 210
 211         if (bo_gem->relocs == NULL) {
 212             DBG("%2d: %d (%s)\n", i, bo_gem->gem_handle, bo_gem->name);
 213             continue;
 214         }
 215
 216         for (j = 0; j < bo_gem->reloc_count; j++) {
 217             drm_intel_bo *target_bo = bo_gem->reloc_target_bo[j];
 218             drm_intel_bo_gem *target_gem = (drm_intel_bo_gem *)target_bo;
 219
 220             DBG("%2d: %d (%s)@0x%08llx -> %d (%s)@0x%08lx + 0x%08x\n",
 221                 i,
 222                 bo_gem->gem_handle, bo_gem->name,
 223                 (unsigned long long)bo_gem->relocs[j].offset,
 224                 target_gem->gem_handle, target_gem->name, target_bo->offset,
 225                 bo_gem->relocs[j].delta);
 226         }
 227     }
 228 }
 229
 230 /**
 231  * Adds the given buffer to the list of buffers to be validated (moved into the
 232  * appropriate memory type) with the next batch submission.
 233  *
 234  * If a buffer is validated multiple times in a batch submission, it ends up
 235  * with the intersection of the memory type flags and the union of the
 236  * access flags.
 237  */
 238 static void
 239 drm_intel_add_validate_buffer(drm_intel_bo *bo)
 240 {
 241     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 242     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 243     int index;
 244
 245     if (bo_gem->validate_index != -1)
 246         return;
 247
 248     /* Extend the array of validation entries as necessary. */
 249     if (bufmgr_gem->exec_count == bufmgr_gem->exec_size) {
 250         int new_size = bufmgr_gem->exec_size * 2;
 251
 252         if (new_size == 0)
 253             new_size = 5;
 254
 255         bufmgr_gem->exec_objects =
 256             realloc(bufmgr_gem->exec_objects,
 257                     sizeof(*bufmgr_gem->exec_objects) * new_size);
 258         bufmgr_gem->exec_bos =
 259             realloc(bufmgr_gem->exec_bos,
 260                     sizeof(*bufmgr_gem->exec_bos) * new_size);
 261         bufmgr_gem->exec_size = new_size;
 262     }
 263
 264     index = bufmgr_gem->exec_count;
 265     bo_gem->validate_index = index;
 266     /* Fill in array entry */
 267     bufmgr_gem->exec_objects[index].handle = bo_gem->gem_handle;
 268     bufmgr_gem->exec_objects[index].relocation_count = bo_gem->reloc_count;
 269     bufmgr_gem->exec_objects[index].relocs_ptr = (uintptr_t)bo_gem->relocs;
 270     bufmgr_gem->exec_objects[index].alignment = 0;
 271     bufmgr_gem->exec_objects[index].offset = 0;
 272     bufmgr_gem->exec_bos[index] = bo;
 273     drm_intel_gem_bo_reference_locked(bo);
 274     bufmgr_gem->exec_count++;
 275 }
 276
 277
 278 #define RELOC_BUF_SIZE(x) ((I915_RELOC_HEADER + x * I915_RELOC0_STRIDE) * \
 279         sizeof(uint32_t))
 280
 281 static int
 282 drm_intel_setup_reloc_list(drm_intel_bo *bo)
 283 {
 284     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 285     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 286
 287     bo_gem->relocs = malloc(bufmgr_gem->max_relocs *
 288                             sizeof(struct drm_i915_gem_relocation_entry));
 289     bo_gem->reloc_target_bo = malloc(bufmgr_gem->max_relocs *
 290                                      sizeof(drm_intel_bo *));
 291
 292     return 0;
 293 }
 294
 295 static drm_intel_bo *
 296 drm_intel_gem_bo_alloc(drm_intel_bufmgr *bufmgr, const char *name,
 297                    unsigned long size, unsigned int alignment)
 298 {
 299     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
 300     drm_intel_bo_gem *bo_gem;
 301     unsigned int page_size = getpagesize();
 302     int ret;
 303     struct drm_intel_gem_bo_bucket *bucket;
 304     int alloc_from_cache = 0;
 305     unsigned long bo_size;
 306
 307     /* Round the allocated size up to a power of two number of pages. */
 308     bo_size = 1 << logbase2(size);
 309     if (bo_size < page_size)
 310         bo_size = page_size;
 311     bucket = drm_intel_gem_bo_bucket_for_size(bufmgr_gem, bo_size);
 312
 313     /* If we don't have caching at this size, don't actually round the
 314      * allocation up.
 315      */
 316     if (bucket == NULL || bucket->max_entries == 0) {
 317         bo_size = size;
 318         if (bo_size < page_size)
 319             bo_size = page_size;
 320     }
 321
 322     pthread_mutex_lock(&bufmgr_gem->lock);
 323     /* Get a buffer out of the cache if available */
 324     if (bucket != NULL && bucket->num_entries > 0) {
 325         struct drm_i915_gem_busy busy;
 326
 327         bo_gem = bucket->head;
 328         busy.handle = bo_gem->gem_handle;
 329
 330         ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_BUSY, &busy);
 331         alloc_from_cache = (ret == 0 && busy.busy == 0);
 332
 333         if (alloc_from_cache) {
 334             bucket->head = bo_gem->next;
 335             if (bo_gem->next == NULL)
 336                 bucket->tail = &bucket->head;
 337             bucket->num_entries--;
 338         }
 339     }
 340     pthread_mutex_unlock(&bufmgr_gem->lock);
 341
 342     if (!alloc_from_cache) {
 343         struct drm_i915_gem_create create;
 344
 345         bo_gem = calloc(1, sizeof(*bo_gem));
 346         if (!bo_gem)
 347             return NULL;
 348
 349         bo_gem->bo.size = bo_size;
 350         memset(&create, 0, sizeof(create));
 351         create.size = bo_size;
 352
 353         ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_CREATE, &create);
 354         bo_gem->gem_handle = create.handle;
 355         bo_gem->bo.handle = bo_gem->gem_handle;
 356         if (ret != 0) {
 357             free(bo_gem);
 358             return NULL;
 359         }
 360         bo_gem->bo.bufmgr = bufmgr;
 361     }
 362
 363     bo_gem->name = name;
 364     bo_gem->refcount = 1;
 365     bo_gem->validate_index = -1;
 366     bo_gem->reloc_tree_size = bo_gem->bo.size;
 367     bo_gem->used_as_reloc_target = 0;
 368
 369     DBG("bo_create: buf %d (%s) %ldb\n",
 370         bo_gem->gem_handle, bo_gem->name, size);
 371
 372     return &bo_gem->bo;
 373 }
 374
 375 /**
 376  * Returns a drm_intel_bo wrapping the given buffer object handle.
 377  *
 378  * This can be used when one application needs to pass a buffer object
 379  * to another.
 380  */
 381 drm_intel_bo *
 382 drm_intel_bo_gem_create_from_name(drm_intel_bufmgr *bufmgr, const char *name,
 383                                   unsigned int handle)
 384 {
 385     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
 386     drm_intel_bo_gem *bo_gem;
 387     int ret;
 388     struct drm_gem_open open_arg;
 389
 390     bo_gem = calloc(1, sizeof(*bo_gem));
 391     if (!bo_gem)
 392         return NULL;
 393
 394     memset(&open_arg, 0, sizeof(open_arg));
 395     open_arg.name = handle;
 396     ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_GEM_OPEN, &open_arg);
 397     if (ret != 0) {
 398         fprintf(stderr, "Couldn't reference %s handle 0x%08x: %s\n",
 399                name, handle, strerror(errno));
 400         free(bo_gem);
 401         return NULL;
 402     }
 403     bo_gem->bo.size = open_arg.size;
 404     bo_gem->bo.offset = 0;
 405     bo_gem->bo.virtual = NULL;
 406     bo_gem->bo.bufmgr = bufmgr;
 407     bo_gem->name = name;
 408     bo_gem->refcount = 1;
 409     bo_gem->validate_index = -1;
 410     bo_gem->gem_handle = open_arg.handle;
 411     bo_gem->global_name = handle;
 412
 413     DBG("bo_create_from_handle: %d (%s)\n", handle, bo_gem->name);
 414
 415     return &bo_gem->bo;
 416 }
 417
 418 static void
 419 drm_intel_gem_bo_reference(drm_intel_bo *bo)
 420 {
 421     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 422     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 423
 424     pthread_mutex_lock(&bufmgr_gem->lock);
 425     bo_gem->refcount++;
 426     pthread_mutex_unlock(&bufmgr_gem->lock);
 427 }
 428
 429 static void
 430 dri_gem_bo_reference_locked(dri_bo *bo)
 431 {
 432     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 433
 434     bo_gem->refcount++;
 435 }
 436
 437 static void
 438 drm_intel_gem_bo_reference_locked(drm_intel_bo *bo)
 439 {
 440     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 441
 442     bo_gem->refcount++;
 443 }
 444
 445 static void
 446 drm_intel_gem_bo_free(drm_intel_bo *bo)
 447 {
 448     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 449     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 450     struct drm_gem_close close;
 451     int ret;
 452
 453     if (bo_gem->mapped)
 454         munmap (bo_gem->virtual, bo_gem->bo.size);
 455
 456     /* Close this object */
 457     close.handle = bo_gem->gem_handle;
 458     ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_GEM_CLOSE, &close);
 459     if (ret != 0) {
 460         fprintf(stderr,
 461                 "DRM_IOCTL_GEM_CLOSE %d failed (%s): %s\n",
 462                 bo_gem->gem_handle, bo_gem->name, strerror(errno));
 463     }
 464     free(bo);
 465 }
 466
 467 static void
 468 drm_intel_gem_bo_unreference_locked(drm_intel_bo *bo)
 469 {
 470     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 471     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 472
 473     if (--bo_gem->refcount == 0) {
 474         struct drm_intel_gem_bo_bucket *bucket;
 475
 476         if (bo_gem->relocs != NULL) {
 477             int i;
 478
 479             /* Unreference all the target buffers */
 480             for (i = 0; i < bo_gem->reloc_count; i++)
 481                  drm_intel_gem_bo_unreference_locked(bo_gem->reloc_target_bo[i]);
 482             free(bo_gem->reloc_target_bo);
 483             free(bo_gem->relocs);
 484         }
 485
 486         DBG("bo_unreference final: %d (%s)\n",
 487             bo_gem->gem_handle, bo_gem->name);
 488
 489         bucket = drm_intel_gem_bo_bucket_for_size(bufmgr_gem, bo->size);
 490         /* Put the buffer into our internal cache for reuse if we can. */
 491         if (bucket != NULL &&
 492             (bucket->max_entries == -1 ||
 493              (bucket->max_entries > 0 &&
 494               bucket->num_entries < bucket->max_entries)))
 495         {
 496             bo_gem->name = 0;
 497             bo_gem->validate_index = -1;
 498             bo_gem->relocs = NULL;
 499             bo_gem->reloc_target_bo = NULL;
 500             bo_gem->reloc_count = 0;
 501
 502             bo_gem->next = NULL;
 503             *bucket->tail = bo_gem;
 504             bucket->tail = &bo_gem->next;
 505             bucket->num_entries++;
 506         } else {
 507             drm_intel_gem_bo_free(bo);
 508         }
 509     }
 510 }
 511
 512 static void
 513 drm_intel_gem_bo_unreference(drm_intel_bo *bo)
 514 {
 515     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 516
 517     pthread_mutex_lock(&bufmgr_gem->lock);
 518     drm_intel_gem_bo_unreference_locked(bo);
 519     pthread_mutex_unlock(&bufmgr_gem->lock);
 520 }
 521
 522 static int
 523 drm_intel_gem_bo_map(drm_intel_bo *bo, int write_enable)
 524 {
 525     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 526     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 527     struct drm_i915_gem_set_domain set_domain;
 528     int ret;
 529
 530     pthread_mutex_lock(&bufmgr_gem->lock);
 531
 532     /* Allow recursive mapping. Mesa may recursively map buffers with
 533      * nested display loops.
 534      */
 535     if (!bo_gem->mapped) {
 536
 537         assert(bo->virtual == NULL);
 538
 539         DBG("bo_map: %d (%s)\n", bo_gem->gem_handle, bo_gem->name);
 540
 541         if (bo_gem->virtual == NULL) {
 542             struct drm_i915_gem_mmap mmap_arg;
 543
 544             memset(&mmap_arg, 0, sizeof(mmap_arg));
 545             mmap_arg.handle = bo_gem->gem_handle;
 546             mmap_arg.offset = 0;
 547             mmap_arg.size = bo->size;
 548             ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_MMAP, &mmap_arg);
 549             if (ret != 0) {
 550                 fprintf(stderr, "%s:%d: Error mapping buffer %d (%s): %s .\n",
 551                         __FILE__, __LINE__,
 552                         bo_gem->gem_handle, bo_gem->name, strerror(errno));
 553             }
 554             bo_gem->virtual = (void *)(uintptr_t)mmap_arg.addr_ptr;
 555         }
 556         bo->virtual = bo_gem->virtual;
 557         bo_gem->swrast = 0;
 558         bo_gem->mapped = 1;
 559         DBG("bo_map: %d (%s) -> %p\n", bo_gem->gem_handle, bo_gem->name, bo_gem->virtual);
 560     }
 561
 562     if (!bo_gem->swrast) {
 563         set_domain.handle = bo_gem->gem_handle;
 564         set_domain.read_domains = I915_GEM_DOMAIN_CPU;
 565         if (write_enable)
 566             set_domain.write_domain = I915_GEM_DOMAIN_CPU;
 567         else
 568             set_domain.write_domain = 0;
 569         do {
 570             ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_SET_DOMAIN,
 571                         &set_domain);
 572         } while (ret == -1 && errno == EINTR);
 573         if (ret != 0) {
 574             fprintf (stderr, "%s:%d: Error setting swrast %d: %s\n",
 575                      __FILE__, __LINE__, bo_gem->gem_handle, strerror (errno));
 576         }
 577         bo_gem->swrast = 1;
 578     }
 579
 580     pthread_mutex_unlock(&bufmgr_gem->lock);
 581
 582     return 0;
 583 }
 584
 585 int
 586 drm_intel_gem_bo_map_gtt(drm_intel_bo *bo)
 587 {
 588     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 589     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 590     struct drm_i915_gem_set_domain set_domain;
 591     int ret;
 592
 593     pthread_mutex_lock(&bufmgr_gem->lock);
 594
 595     /* Allow recursive mapping. Mesa may recursively map buffers with
 596      * nested display loops.
 597      */
 598     if (!bo_gem->mapped) {
 599
 600         assert(bo->virtual == NULL);
 601
 602         DBG("bo_map_gtt: %d (%s)\n", bo_gem->gem_handle, bo_gem->name);
 603
 604         if (bo_gem->virtual == NULL) {
 605                 struct drm_i915_gem_mmap_gtt mmap_arg;
 606
 607                 memset(&mmap_arg, 0, sizeof(mmap_arg));
 608                 mmap_arg.handle = bo_gem->gem_handle;
 609
 610                 /* Get the fake offset back... */
 611                 ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_MMAP_GTT,
 612                             &mmap_arg);
 613                 if (ret != 0) {
 614                         fprintf(stderr,
 615                                 "%s:%d: Error preparing buffer map %d (%s): %s .\n",
 616                                 __FILE__, __LINE__,
 617                                 bo_gem->gem_handle, bo_gem->name,
 618                                 strerror(errno));
 619                         pthread_mutex_unlock(&bufmgr_gem->lock);
 620                         return ret;
 621                 }
 622
 623                 /* and mmap it */
 624                 bo_gem->virtual = mmap(0, bo->size, PROT_READ | PROT_WRITE,
 625                                        MAP_SHARED, bufmgr_gem->fd,
 626                                        mmap_arg.offset);
 627                 if (bo_gem->virtual == MAP_FAILED) {
 628                         fprintf(stderr,
 629                                 "%s:%d: Error mapping buffer %d (%s): %s .\n",
 630                                 __FILE__, __LINE__,
 631                                 bo_gem->gem_handle, bo_gem->name,
 632                                 strerror(errno));
 633                         pthread_mutex_unlock(&bufmgr_gem->lock);
 634                         return errno;
 635                 }
 636         }
 637
 638         bo->virtual = bo_gem->virtual;
 639         bo_gem->mapped = 1;
 640         DBG("bo_map: %d (%s) -> %p\n", bo_gem->gem_handle, bo_gem->name,
 641             bo_gem->virtual);
 642     }
 643
 644     /* Now move it to the GTT domain so that the CPU caches are flushed */
 645     set_domain.handle = bo_gem->gem_handle;
 646     set_domain.read_domains = I915_GEM_DOMAIN_GTT;
 647     set_domain.write_domain = I915_GEM_DOMAIN_GTT;
 648     do {
 649             ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_SET_DOMAIN,
 650                         &set_domain);
 651     } while (ret == -1 && errno == EINTR);
 652
 653     if (ret != 0) {
 654             fprintf (stderr, "%s:%d: Error setting swrast %d: %s\n",
 655                      __FILE__, __LINE__, bo_gem->gem_handle, strerror (errno));
 656     }
 657
 658     pthread_mutex_unlock(&bufmgr_gem->lock);
 659
 660     return 0;
 661 }
 662
 663 static int
 664 drm_intel_gem_bo_unmap(drm_intel_bo *bo)
 665 {
 666     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 667     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 668     struct drm_i915_gem_sw_finish sw_finish;
 669     int ret;
 670
 671     if (bo == NULL)
 672         return 0;
 673
 674     assert(bo_gem->mapped);
 675
 676     pthread_mutex_lock(&bufmgr_gem->lock);
 677     if (bo_gem->swrast) {
 678         sw_finish.handle = bo_gem->gem_handle;
 679         do {
 680             ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_SW_FINISH,
 681                         &sw_finish);
 682         } while (ret == -1 && errno == EINTR);
 683         bo_gem->swrast = 0;
 684     }
 685     pthread_mutex_unlock(&bufmgr_gem->lock);
 686     return 0;
 687 }
 688
 689 static int
 690 drm_intel_gem_bo_subdata (drm_intel_bo *bo, unsigned long offset,
 691                           unsigned long size, const void *data)
 692 {
 693     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 694     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 695     struct drm_i915_gem_pwrite pwrite;
 696     int ret;
 697
 698     memset (&pwrite, 0, sizeof (pwrite));
 699     pwrite.handle = bo_gem->gem_handle;
 700     pwrite.offset = offset;
 701     pwrite.size = size;
 702     pwrite.data_ptr = (uint64_t) (uintptr_t) data;
 703     do {
 704         ret = ioctl (bufmgr_gem->fd, DRM_IOCTL_I915_GEM_PWRITE, &pwrite);
 705     } while (ret == -1 && errno == EINTR);
 706     if (ret != 0) {
 707         fprintf (stderr, "%s:%d: Error writing data to buffer %d: (%d %d) %s .\n",
 708                  __FILE__, __LINE__,
 709                  bo_gem->gem_handle, (int) offset, (int) size,
 710                  strerror (errno));
 711     }
 712     return 0;
 713 }
 714
 715 static int
 716 drm_intel_gem_bo_get_subdata (drm_intel_bo *bo, unsigned long offset,
 717                               unsigned long size, void *data)
 718 {
 719     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 720     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 721     struct drm_i915_gem_pread pread;
 722     int ret;
 723
 724     memset (&pread, 0, sizeof (pread));
 725     pread.handle = bo_gem->gem_handle;
 726     pread.offset = offset;
 727     pread.size = size;
 728     pread.data_ptr = (uint64_t) (uintptr_t) data;
 729     do {
 730         ret = ioctl (bufmgr_gem->fd, DRM_IOCTL_I915_GEM_PREAD, &pread);
 731     } while (ret == -1 && errno == EINTR);
 732     if (ret != 0) {
 733         fprintf (stderr, "%s:%d: Error reading data from buffer %d: (%d %d) %s .\n",
 734                  __FILE__, __LINE__,
 735                  bo_gem->gem_handle, (int) offset, (int) size,
 736                  strerror (errno));
 737     }
 738     return 0;
 739 }
 740
 741 /** Waits for all GPU rendering to the object to have completed. */
 742 static void
 743 drm_intel_gem_bo_wait_rendering(drm_intel_bo *bo)
 744 {
 745     return drm_intel_gem_bo_start_gtt_access(bo, 0);
 746 }
 747
 748 /**
 749  * Sets the object to the GTT read and possibly write domain, used by the X
 750  * 2D driver in the absence of kernel support to do drm_intel_gem_bo_map_gtt().
 751  *
 752  * In combination with drm_intel_gem_bo_pin() and manual fence management, we
 753  * can do tiled pixmaps this way.
 754  */
 755 void
 756 drm_intel_gem_bo_start_gtt_access(drm_intel_bo *bo, int write_enable)
 757 {
 758     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 759     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 760     struct drm_i915_gem_set_domain set_domain;
 761     int ret;
 762
 763     set_domain.handle = bo_gem->gem_handle;
 764     set_domain.read_domains = I915_GEM_DOMAIN_GTT;
 765     set_domain.write_domain = write_enable ? I915_GEM_DOMAIN_GTT : 0;
 766     do {
 767         ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_SET_DOMAIN, &set_domain);
 768     } while (ret == -1 && errno == EINTR);
 769     if (ret != 0) {
 770         fprintf (stderr, "%s:%d: Error setting memory domains %d (%08x %08x): %s .\n",
 771                  __FILE__, __LINE__,
 772                  bo_gem->gem_handle, set_domain.read_domains, set_domain.write_domain,
 773                  strerror (errno));
 774     }
 775 }
 776
 777 static void
 778 drm_intel_bufmgr_gem_destroy(drm_intel_bufmgr *bufmgr)
 779 {
 780     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
 781     int i;
 782
 783     free(bufmgr_gem->exec_objects);
 784     free(bufmgr_gem->exec_bos);
 785
 786     pthread_mutex_destroy(&bufmgr_gem->lock);
 787
 788     /* Free any cached buffer objects we were going to reuse */
 789     for (i = 0; i < DRM_INTEL_GEM_BO_BUCKETS; i++) {
 790         struct drm_intel_gem_bo_bucket *bucket = &bufmgr_gem->cache_bucket[i];
 791         drm_intel_bo_gem *bo_gem;
 792
 793         while ((bo_gem = bucket->head) != NULL) {
 794             bucket->head = bo_gem->next;
 795             if (bo_gem->next == NULL)
 796                 bucket->tail = &bucket->head;
 797             bucket->num_entries--;
 798
 799             drm_intel_gem_bo_free(&bo_gem->bo);
 800         }
 801     }
 802
 803     free(bufmgr);
 804 }
 805
 806 /**
 807  * Adds the target buffer to the validation list and adds the relocation
 808  * to the reloc_buffer's relocation list.
 809  *
 810  * The relocation entry at the given offset must already contain the
 811  * precomputed relocation value, because the kernel will optimize out
 812  * the relocation entry write when the buffer hasn't moved from the
 813  * last known offset in target_bo.
 814  */
 815 static int
 816 drm_intel_gem_bo_emit_reloc(drm_intel_bo *bo, uint32_t offset,
 817                             drm_intel_bo *target_bo, uint32_t target_offset,
 818                             uint32_t read_domains, uint32_t write_domain)
 819 {
 820     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 821     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 822     drm_intel_bo_gem *target_bo_gem = (drm_intel_bo_gem *)target_bo;
 823
 824     pthread_mutex_lock(&bufmgr_gem->lock);
 825
 826     /* Create a new relocation list if needed */
 827     if (bo_gem->relocs == NULL)
 828         drm_intel_setup_reloc_list(bo);
 829
 830     /* Check overflow */
 831     assert(bo_gem->reloc_count < bufmgr_gem->max_relocs);
 832
 833     /* Check args */
 834     assert (offset <= bo->size - 4);
 835     assert ((write_domain & (write_domain-1)) == 0);
 836
 837     /* Make sure that we're not adding a reloc to something whose size has
 838      * already been accounted for.
 839      */
 840     assert(!bo_gem->used_as_reloc_target);
 841     bo_gem->reloc_tree_size += target_bo_gem->reloc_tree_size;
 842
 843     /* Flag the target to disallow further relocations in it. */
 844     target_bo_gem->used_as_reloc_target = 1;
 845
 846     bo_gem->relocs[bo_gem->reloc_count].offset = offset;
 847     bo_gem->relocs[bo_gem->reloc_count].delta = target_offset;
 848     bo_gem->relocs[bo_gem->reloc_count].target_handle =
 849         target_bo_gem->gem_handle;
 850     bo_gem->relocs[bo_gem->reloc_count].read_domains = read_domains;
 851     bo_gem->relocs[bo_gem->reloc_count].write_domain = write_domain;
 852     bo_gem->relocs[bo_gem->reloc_count].presumed_offset = target_bo->offset;
 853
 854     bo_gem->reloc_target_bo[bo_gem->reloc_count] = target_bo;
 855     drm_intel_gem_bo_reference_locked(target_bo);
 856
 857     bo_gem->reloc_count++;
 858
 859     pthread_mutex_unlock(&bufmgr_gem->lock);
 860
 861     return 0;
 862 }
 863
 864 /**
 865  * Walk the tree of relocations rooted at BO and accumulate the list of
 866  * validations to be performed and update the relocation buffers with
 867  * index values into the validation list.
 868  */
 869 static void
 870 drm_intel_gem_bo_process_reloc(drm_intel_bo *bo)
 871 {
 872     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 873     int i;
 874
 875     if (bo_gem->relocs == NULL)
 876         return;
 877
 878     for (i = 0; i < bo_gem->reloc_count; i++) {
 879         drm_intel_bo *target_bo = bo_gem->reloc_target_bo[i];
 880
 881         /* Continue walking the tree depth-first. */
 882         drm_intel_gem_bo_process_reloc(target_bo);
 883
 884         /* Add the target to the validate list */
 885         drm_intel_add_validate_buffer(target_bo);
 886     }
 887 }
 888
 889 static void
 890 drm_intel_update_buffer_offsets (drm_intel_bufmgr_gem *bufmgr_gem)
 891 {
 892     int i;
 893
 894     for (i = 0; i < bufmgr_gem->exec_count; i++) {
 895         drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
 896         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 897
 898         /* Update the buffer offset */
 899         if (bufmgr_gem->exec_objects[i].offset != bo->offset) {
 900             DBG("BO %d (%s) migrated: 0x%08lx -> 0x%08llx\n",
 901                 bo_gem->gem_handle, bo_gem->name, bo->offset,
 902                 (unsigned long long)bufmgr_gem->exec_objects[i].offset);
 903             bo->offset = bufmgr_gem->exec_objects[i].offset;
 904         }
 905     }
 906 }
 907
 908 static int
 909 drm_intel_gem_bo_exec(drm_intel_bo *bo, int used,
 910                       drm_clip_rect_t *cliprects, int num_cliprects,
 911                       int DR4)
 912 {
 913     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 914     struct drm_i915_gem_execbuffer execbuf;
 915     int ret, i;
 916
 917     pthread_mutex_lock(&bufmgr_gem->lock);
 918     /* Update indices and set up the validate list. */
 919     drm_intel_gem_bo_process_reloc(bo);
 920
 921     /* Add the batch buffer to the validation list.  There are no relocations
 922      * pointing to it.
 923      */
 924     drm_intel_add_validate_buffer(bo);
 925
 926     execbuf.buffers_ptr = (uintptr_t)bufmgr_gem->exec_objects;
 927     execbuf.buffer_count = bufmgr_gem->exec_count;
 928     execbuf.batch_start_offset = 0;
 929     execbuf.batch_len = used;
 930     execbuf.cliprects_ptr = (uintptr_t)cliprects;
 931     execbuf.num_cliprects = num_cliprects;
 932     execbuf.DR1 = 0;
 933     execbuf.DR4 = DR4;
 934
 935     do {
 936         ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_EXECBUFFER, &execbuf);
 937     } while (ret != 0 && errno == EAGAIN);
 938
 939     drm_intel_update_buffer_offsets (bufmgr_gem);
 940
 941     if (bufmgr_gem->bufmgr.debug)
 942         drm_intel_gem_dump_validation_list(bufmgr_gem);
 943
 944     for (i = 0; i < bufmgr_gem->exec_count; i++) {
 945         drm_intel_bo *bo = bufmgr_gem->exec_bos[i];
 946         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 947
 948         /* Need to call swrast on next bo_map */
 949         bo_gem->swrast = 0;
 950
 951         /* Disconnect the buffer from the validate list */
 952         bo_gem->validate_index = -1;
 953         drm_intel_gem_bo_unreference_locked(bo);
 954         bufmgr_gem->exec_bos[i] = NULL;
 955     }
 956     bufmgr_gem->exec_count = 0;
 957     pthread_mutex_unlock(&bufmgr_gem->lock);
 958
 959     return 0;
 960 }
 961
 962 static int
 963 drm_intel_gem_bo_pin(drm_intel_bo *bo, uint32_t alignment)
 964 {
 965     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 966     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 967     struct drm_i915_gem_pin pin;
 968     int ret;
 969
 970     pin.handle = bo_gem->gem_handle;
 971     pin.alignment = alignment;
 972
 973     ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_PIN, &pin);
 974     if (ret != 0)
 975         return -errno;
 976
 977     bo->offset = pin.offset;
 978     return 0;
 979 }
 980
 981 static int
 982 drm_intel_gem_bo_unpin(drm_intel_bo *bo)
 983 {
 984     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
 985     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
 986     struct drm_i915_gem_unpin unpin;
 987     int ret;
 988
 989     unpin.handle = bo_gem->gem_handle;
 990
 991     ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_UNPIN, &unpin);
 992     if (ret != 0)
 993         return -errno;
 994
 995     return 0;
 996 }
 997
 998 static int
 999 drm_intel_gem_bo_set_tiling(drm_intel_bo *bo, uint32_t *tiling_mode,
1000                             uint32_t stride)
1001 {
1002     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
1003     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
1004     struct drm_i915_gem_set_tiling set_tiling;
1005     int ret;
1006
1007     set_tiling.handle = bo_gem->gem_handle;
1008     set_tiling.tiling_mode = *tiling_mode;
1009     set_tiling.stride = stride;
1010
1011     ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_SET_TILING, &set_tiling);
1012     if (ret != 0) {
1013         *tiling_mode = I915_TILING_NONE;
1014         return -errno;
1015     }
1016
1017     *tiling_mode = set_tiling.tiling_mode;
1018     return 0;
1019 }
1020
1021 static int
1022 drm_intel_gem_bo_get_tiling(drm_intel_bo *bo, uint32_t *tiling_mode,
1023                             uint32_t *swizzle_mode)
1024 {
1025     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
1026     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
1027     struct drm_i915_gem_get_tiling get_tiling;
1028     int ret;
1029
1030     get_tiling.handle = bo_gem->gem_handle;
1031
1032     ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_GET_TILING, &get_tiling);
1033     if (ret != 0) {
1034         *tiling_mode = I915_TILING_NONE;
1035         *swizzle_mode = I915_BIT_6_SWIZZLE_NONE;
1036         return -errno;
1037     }
1038
1039     *tiling_mode = get_tiling.tiling_mode;
1040     *swizzle_mode = get_tiling.swizzle_mode;
1041     return 0;
1042 }
1043
1044 static int
1045 drm_intel_gem_bo_flink(drm_intel_bo *bo, uint32_t *name)
1046 {
1047     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo->bufmgr;
1048     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
1049     struct drm_gem_flink flink;
1050     int ret;
1051
1052     if (!bo_gem->global_name) {
1053         flink.handle = bo_gem->gem_handle;
1054
1055         ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_GEM_FLINK, &flink);
1056         if (ret != 0)
1057             return -errno;
1058         bo_gem->global_name = flink.name;
1059     }
1060
1061     *name = bo_gem->global_name;
1062     return 0;
1063 }
1064
1065 /**
1066  * Enables unlimited caching of buffer objects for reuse.
1067  *
1068  * This is potentially very memory expensive, as the cache at each bucket
1069  * size is only bounded by how many buffers of that size we've managed to have
1070  * in flight at once.
1071  */
1072 void
1073 drm_intel_bufmgr_gem_enable_reuse(drm_intel_bufmgr *bufmgr)
1074 {
1075     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bufmgr;
1076     int i;
1077
1078     for (i = 0; i < DRM_INTEL_GEM_BO_BUCKETS; i++) {
1079         bufmgr_gem->cache_bucket[i].max_entries = -1;
1080     }
1081 }
1082
1083 /**
1084  * Return the additional aperture space required by the tree of buffer objects
1085  * rooted at bo.
1086  */
1087 static int
1088 drm_intel_gem_bo_get_aperture_space(drm_intel_bo *bo)
1089 {
1090     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
1091     int i;
1092     int total = 0;
1093
1094     if (bo == NULL || bo_gem->included_in_check_aperture)
1095         return 0;
1096
1097     total += bo->size;
1098     bo_gem->included_in_check_aperture = 1;
1099
1100     for (i = 0; i < bo_gem->reloc_count; i++)
1101         total += drm_intel_gem_bo_get_aperture_space(bo_gem->reloc_target_bo[i]);
1102
1103     return total;
1104 }
1105
1106 /**
1107  * Clear the flag set by drm_intel_gem_bo_get_aperture_space() so we're ready
1108  * for the next drm_intel_bufmgr_check_aperture_space() call.
1109  */
1110 static void
1111 drm_intel_gem_bo_clear_aperture_space_flag(drm_intel_bo *bo)
1112 {
1113     drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo;
1114     int i;
1115
1116     if (bo == NULL || !bo_gem->included_in_check_aperture)
1117         return;
1118
1119     bo_gem->included_in_check_aperture = 0;
1120
1121     for (i = 0; i < bo_gem->reloc_count; i++)
1122         drm_intel_gem_bo_clear_aperture_space_flag(bo_gem->reloc_target_bo[i]);
1123 }
1124
1125 /**
1126  * Return -1 if the batchbuffer should be flushed before attempting to
1127  * emit rendering referencing the buffers pointed to by bo_array.
1128  *
1129  * This is required because if we try to emit a batchbuffer with relocations
1130  * to a tree of buffers that won't simultaneously fit in the aperture,
1131  * the rendering will return an error at a point where the software is not
1132  * prepared to recover from it.
1133  *
1134  * However, we also want to emit the batchbuffer significantly before we reach
1135  * the limit, as a series of batchbuffers each of which references buffers
1136  * covering almost all of the aperture means that at each emit we end up
1137  * waiting to evict a buffer from the last rendering, and we get synchronous
1138  * performance.  By emitting smaller batchbuffers, we eat some CPU overhead to
1139  * get better parallelism.
1140  */
1141 static int
1142 drm_intel_gem_check_aperture_space(drm_intel_bo **bo_array, int count)
1143 {
1144     drm_intel_bufmgr_gem *bufmgr_gem = (drm_intel_bufmgr_gem *)bo_array[0]->bufmgr;
1145     unsigned int total = 0;
1146     unsigned int threshold = bufmgr_gem->gtt_size * 3 / 4;
1147     int i;
1148
1149     for (i = 0; i < count; i++) {
1150         drm_intel_bo_gem *bo_gem = (drm_intel_bo_gem *)bo_array[i];
1151         if (bo_gem != NULL)
1152                 total += bo_gem->reloc_tree_size;
1153     }
1154
1155     if (total > threshold) {
1156         total = 0;
1157         for (i = 0; i < count; i++)
1158             total += drm_intel_gem_bo_get_aperture_space(bo_array[i]);
1159
1160         for (i = 0; i < count; i++)
1161             drm_intel_gem_bo_clear_aperture_space_flag(bo_array[i]);
1162     }
1163
1164     if (total > bufmgr_gem->gtt_size * 3 / 4) {
1165         DBG("check_space: overflowed available aperture, %dkb vs %dkb\n",
1166             total / 1024, (int)bufmgr_gem->gtt_size / 1024);
1167         return -1;
1168     } else {
1169         DBG("drm_check_space: total %dkb vs bufgr %dkb\n", total / 1024 ,
1170             (int)bufmgr_gem->gtt_size / 1024);
1171         return 0;
1172     }
1173 }
1174
1175 /**
1176  * Initializes the GEM buffer manager, which uses the kernel to allocate, map,
1177  * and manage map buffer objections.
1178  *
1179  * \param fd File descriptor of the opened DRM device.
1180  */
1181 drm_intel_bufmgr *
1182 drm_intel_bufmgr_gem_init(int fd, int batch_size)
1183 {
1184     drm_intel_bufmgr_gem *bufmgr_gem;
1185     struct drm_i915_gem_get_aperture aperture;
1186     int ret, i;
1187
1188     bufmgr_gem = calloc(1, sizeof(*bufmgr_gem));
1189     bufmgr_gem->fd = fd;
1190
1191     if (pthread_mutex_init(&bufmgr_gem->lock, NULL) != 0) {
1192       free(bufmgr_gem);
1193       return NULL;
1194    }
1195
1196     ret = ioctl(bufmgr_gem->fd, DRM_IOCTL_I915_GEM_GET_APERTURE, &aperture);
1197
1198     if (ret == 0)
1199         bufmgr_gem->gtt_size = aperture.aper_available_size;
1200     else {
1201         fprintf(stderr, "DRM_IOCTL_I915_GEM_APERTURE failed: %s\n",
1202                 strerror(errno));
1203         bufmgr_gem->gtt_size = 128 * 1024 * 1024;
1204         fprintf(stderr, "Assuming %dkB available aperture size.\n"
1205                 "May lead to reduced performance or incorrect rendering.\n",
1206                 (int)bufmgr_gem->gtt_size / 1024);
1207     }
1208
1209     /* Let's go with one relocation per every 2 dwords (but round down a bit
1210      * since a power of two will mean an extra page allocation for the reloc
1211      * buffer).
1212      *
1213      * Every 4 was too few for the blender benchmark.
1214      */
1215     bufmgr_gem->max_relocs = batch_size / sizeof(uint32_t) / 2 - 2;
1216
1217     bufmgr_gem->bufmgr.bo_alloc = drm_intel_gem_bo_alloc;
1218     bufmgr_gem->bufmgr.bo_reference = drm_intel_gem_bo_reference;
1219     bufmgr_gem->bufmgr.bo_unreference = drm_intel_gem_bo_unreference;
1220     bufmgr_gem->bufmgr.bo_map = drm_intel_gem_bo_map;
1221     bufmgr_gem->bufmgr.bo_unmap = drm_intel_gem_bo_unmap;
1222     bufmgr_gem->bufmgr.bo_subdata = drm_intel_gem_bo_subdata;
1223     bufmgr_gem->bufmgr.bo_get_subdata = drm_intel_gem_bo_get_subdata;
1224     bufmgr_gem->bufmgr.bo_wait_rendering = drm_intel_gem_bo_wait_rendering;
1225     bufmgr_gem->bufmgr.bo_emit_reloc = drm_intel_gem_bo_emit_reloc;
1226     bufmgr_gem->bufmgr.bo_pin = drm_intel_gem_bo_pin;
1227     bufmgr_gem->bufmgr.bo_unpin = drm_intel_gem_bo_unpin;
1228     bufmgr_gem->bufmgr.bo_get_tiling = drm_intel_gem_bo_get_tiling;
1229     bufmgr_gem->bufmgr.bo_set_tiling = drm_intel_gem_bo_set_tiling;
1230     bufmgr_gem->bufmgr.bo_flink = drm_intel_gem_bo_flink;
1231     bufmgr_gem->bufmgr.bo_exec = drm_intel_gem_bo_exec;
1232     bufmgr_gem->bufmgr.destroy = drm_intel_bufmgr_gem_destroy;
1233     bufmgr_gem->bufmgr.debug = 0;
1234     bufmgr_gem->bufmgr.check_aperture_space = drm_intel_gem_check_aperture_space;
1235     /* Initialize the linked lists for BO reuse cache. */
1236     for (i = 0; i < DRM_INTEL_GEM_BO_BUCKETS; i++)
1237         bufmgr_gem->cache_bucket[i].tail = &bufmgr_gem->cache_bucket[i].head;
1238
1239     return &bufmgr_gem->bufmgr;
1240 }
1241