src/mesa/drivers/dri/common/dri_bufmgr.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2006 Tungsten Graphics, Inc., Bismarck, ND., USA
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  17  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  18  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  19  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  20  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  21  *
  22  * The above copyright notice and this permission notice (including the
  23  * next paragraph) shall be included in all copies or substantial portions
  24  * of the Software.
  25  *
  26  *
  27  **************************************************************************/
  28 /*
  29  * Authors: Thomas Hellström <thomas-at-tungstengraphics-dot-com>
  30  *          Keith Whitwell <keithw-at-tungstengraphics-dot-com>
  31  */
  32
  33 #include <xf86drm.h>
  34 #include <stdlib.h>
  35 #include "glthread.h"
  36 #include "errno.h"
  37 #include "dri_bufmgr.h"
  38 #include "string.h"
  39 #include "imports.h"
  40 #include "dri_bufpool.h"
  41
  42 _glthread_DECLARE_STATIC_MUTEX(bmMutex);
  43
  44 /*
  45  * TODO: Introduce fence pools in the same way as
  46  * buffer object pools.
  47  */
  48
  49
  50
  51 typedef struct _DriFenceObject
  52 {
  53    int fd;
  54    _glthread_Mutex mutex;
  55    int refCount;
  56    const char *name;
  57    drmFence fence;
  58 } DriFenceObject;
  59
  60 typedef struct _DriBufferObject
  61 {
  62    DriBufferPool *pool;
  63    _glthread_Mutex mutex;
  64    int refCount;
  65    const char *name;
  66    unsigned flags;
  67    unsigned hint;
  68    unsigned alignment;
  69    void *private;
  70 } DriBufferObject;
  71
  72
  73 void
  74 bmError(int val, const char *file, const char *function, int line)
  75 {
  76    _mesa_printf("Fatal video memory manager error \"%s\".\n"
  77                 "Check kernel logs or set the LIBGL_DEBUG\n"
  78                 "environment variable to \"verbose\" for more info.\n"
  79                 "Detected in file %s, line %d, function %s.\n",
  80                 strerror(-val), file, line, function);
  81 #ifndef NDEBUG
  82    abort();
  83 #else
  84    abort();
  85 #endif
  86 }
  87
  88 DriFenceObject *
  89 driFenceBuffers(int fd, char *name, unsigned flags)
  90 {
  91    DriFenceObject *fence = (DriFenceObject *) malloc(sizeof(*fence));
  92    int ret;
  93
  94    if (!fence)
  95       BM_CKFATAL(-EINVAL);
  96
  97    _glthread_LOCK_MUTEX(bmMutex);
  98    fence->refCount = 1;
  99    fence->name = name;
 100    fence->fd = fd;
 101    _glthread_INIT_MUTEX(fence->mutex);
 102    ret = drmFenceBuffers(fd, flags, &fence->fence);
 103    _glthread_UNLOCK_MUTEX(bmMutex);
 104    if (ret) {
 105       free(fence);
 106       BM_CKFATAL(ret);
 107    }
 108    return fence;
 109 }
 110
 111
 112 unsigned
 113 driFenceType(DriFenceObject * fence)
 114 {
 115     unsigned ret;
 116
 117     _glthread_LOCK_MUTEX(bmMutex);
 118     ret = fence->fence.flags;
 119     _glthread_UNLOCK_MUTEX(bmMutex);
 120
 121     return ret;
 122 }
 123
 124
 125 DriFenceObject *
 126 driFenceReference(DriFenceObject * fence)
 127 {
 128    _glthread_LOCK_MUTEX(bmMutex);
 129    ++fence->refCount;
 130    _glthread_UNLOCK_MUTEX(bmMutex);
 131    return fence;
 132 }
 133
 134 void
 135 driFenceUnReference(DriFenceObject * fence)
 136 {
 137    if (!fence)
 138       return;
 139
 140    _glthread_LOCK_MUTEX(bmMutex);
 141    if (--fence->refCount == 0) {
 142       drmFenceDestroy(fence->fd, &fence->fence);
 143       free(fence);
 144    }
 145    _glthread_UNLOCK_MUTEX(bmMutex);
 146 }
 147
 148 void
 149 driFenceFinish(DriFenceObject * fence, unsigned type, int lazy)
 150 {
 151    int ret;
 152    unsigned flags = (lazy) ? DRM_FENCE_FLAG_WAIT_LAZY : 0;
 153
 154    _glthread_LOCK_MUTEX(fence->mutex);
 155    ret = drmFenceWait(fence->fd, flags, &fence->fence, type);
 156    _glthread_UNLOCK_MUTEX(fence->mutex);
 157    BM_CKFATAL(ret);
 158 }
 159
 160 int
 161 driFenceSignaled(DriFenceObject * fence, unsigned type)
 162 {
 163    int signaled;
 164    int ret;
 165
 166    if (fence == NULL)
 167       return GL_TRUE;
 168
 169    _glthread_LOCK_MUTEX(fence->mutex);
 170    ret = drmFenceSignaled(fence->fd, &fence->fence, type, &signaled);
 171    _glthread_UNLOCK_MUTEX(fence->mutex);
 172    BM_CKFATAL(ret);
 173    return signaled;
 174 }
 175
 176
 177 extern drmBO *
 178 driBOKernel(struct _DriBufferObject *buf)
 179 {
 180    drmBO *ret;
 181
 182    assert(buf->private != NULL);
 183    ret = buf->pool->kernel(buf->pool, buf->private);
 184    if (!ret)
 185       BM_CKFATAL(-EINVAL);
 186
 187    return ret;
 188 }
 189
 190 void
 191 driBOWaitIdle(struct _DriBufferObject *buf, int lazy)
 192 {
 193    assert(buf->private != NULL);
 194
 195    _glthread_LOCK_MUTEX(buf->mutex);
 196    BM_CKFATAL(buf->pool->waitIdle(buf->pool, buf->private, lazy));
 197    _glthread_UNLOCK_MUTEX(buf->mutex);
 198 }
 199
 200 void *
 201 driBOMap(struct _DriBufferObject *buf, unsigned flags, unsigned hint)
 202 {
 203    void *virtual;
 204
 205    assert(buf->private != NULL);
 206
 207    _glthread_LOCK_MUTEX(buf->mutex);
 208    BM_CKFATAL(buf->pool->map(buf->pool, buf->private, flags, hint, &virtual));
 209    _glthread_UNLOCK_MUTEX(buf->mutex);
 210    return virtual;
 211 }
 212
 213 void
 214 driBOUnmap(struct _DriBufferObject *buf)
 215 {
 216    assert(buf->private != NULL);
 217
 218    buf->pool->unmap(buf->pool, buf->private);
 219 }
 220
 221 unsigned long
 222 driBOOffset(struct _DriBufferObject *buf)
 223 {
 224    unsigned long ret;
 225
 226    assert(buf->private != NULL);
 227
 228    _glthread_LOCK_MUTEX(buf->mutex);
 229    ret = buf->pool->offset(buf->pool, buf->private);
 230    _glthread_UNLOCK_MUTEX(buf->mutex);
 231    return ret;
 232 }
 233
 234 unsigned
 235 driBOFlags(struct _DriBufferObject *buf)
 236 {
 237    unsigned ret;
 238
 239    assert(buf->private != NULL);
 240
 241    _glthread_LOCK_MUTEX(buf->mutex);
 242    ret = buf->pool->flags(buf->pool, buf->private);
 243    _glthread_UNLOCK_MUTEX(buf->mutex);
 244    return ret;
 245 }
 246
 247 struct _DriBufferObject *
 248 driBOReference(struct _DriBufferObject *buf)
 249 {
 250    _glthread_LOCK_MUTEX(bmMutex);
 251    if (++buf->refCount == 1) {
 252       BM_CKFATAL(-EINVAL);
 253    }
 254    _glthread_UNLOCK_MUTEX(bmMutex);
 255    return buf;
 256 }
 257
 258 void
 259 driBOUnReference(struct _DriBufferObject *buf)
 260 {
 261    int tmp;
 262
 263    if (!buf)
 264       return;
 265
 266    _glthread_LOCK_MUTEX(bmMutex);
 267    tmp = --buf->refCount;
 268    _glthread_UNLOCK_MUTEX(bmMutex);
 269    if (!tmp) {
 270       buf->pool->destroy(buf->pool, buf->private);
 271       free(buf);
 272    }
 273 }
 274
 275 void
 276 driBOData(struct _DriBufferObject *buf,
 277           unsigned size, const void *data, unsigned flags)
 278 {
 279    void *virtual;
 280    int newBuffer;
 281    struct _DriBufferPool *pool;
 282
 283    _glthread_LOCK_MUTEX(buf->mutex);
 284    pool = buf->pool;
 285    if (!pool->create) {
 286       _mesa_error(NULL, GL_INVALID_OPERATION,
 287                   "driBOData called on invalid buffer\n");
 288       BM_CKFATAL(-EINVAL);
 289    }
 290    newBuffer = !buf->private || (pool->size(pool, buf->private) < size) ||
 291       pool->map(pool, buf->private, DRM_BO_FLAG_WRITE,
 292                 DRM_BO_HINT_DONT_BLOCK, &virtual);
 293
 294    if (newBuffer) {
 295       if (buf->private)
 296          pool->destroy(pool, buf->private);
 297       if (!flags)
 298          flags = buf->flags;
 299       buf->private = pool->create(pool, size, flags, 0, buf->alignment);
 300       if (!buf->private)
 301          BM_CKFATAL(-ENOMEM);
 302       BM_CKFATAL(pool->map(pool, buf->private,
 303                            DRM_BO_FLAG_WRITE,
 304                            DRM_BO_HINT_DONT_BLOCK, &virtual));
 305    }
 306
 307    if (data != NULL)
 308       memcpy(virtual, data, size);
 309
 310    BM_CKFATAL(pool->unmap(pool, buf->private));
 311    _glthread_UNLOCK_MUTEX(buf->mutex);
 312 }
 313
 314 void
 315 driBOSubData(struct _DriBufferObject *buf,
 316              unsigned long offset, unsigned long size, const void *data)
 317 {
 318    void *virtual;
 319
 320    _glthread_LOCK_MUTEX(buf->mutex);
 321    if (size && data) {
 322       BM_CKFATAL(buf->pool->map(buf->pool, buf->private,
 323                                 DRM_BO_FLAG_WRITE, 0, &virtual));
 324       memcpy((unsigned char *) virtual + offset, data, size);
 325       BM_CKFATAL(buf->pool->unmap(buf->pool, buf->private));
 326    }
 327    _glthread_UNLOCK_MUTEX(buf->mutex);
 328 }
 329
 330 void
 331 driBOGetSubData(struct _DriBufferObject *buf,
 332                 unsigned long offset, unsigned long size, void *data)
 333 {
 334    void *virtual;
 335
 336    _glthread_LOCK_MUTEX(buf->mutex);
 337    if (size && data) {
 338       BM_CKFATAL(buf->pool->map(buf->pool, buf->private,
 339                                 DRM_BO_FLAG_READ, 0, &virtual));
 340       memcpy(data, (unsigned char *) virtual + offset, size);
 341       BM_CKFATAL(buf->pool->unmap(buf->pool, buf->private));
 342    }
 343    _glthread_UNLOCK_MUTEX(buf->mutex);
 344 }
 345
 346 void
 347 driBOSetStatic(struct _DriBufferObject *buf,
 348                unsigned long offset,
 349                unsigned long size, void *virtual, unsigned flags)
 350 {
 351    _glthread_LOCK_MUTEX(buf->mutex);
 352    if (buf->private != NULL) {
 353       _mesa_error(NULL, GL_INVALID_OPERATION,
 354                   "Invalid buffer for setStatic\n");
 355       BM_CKFATAL(-EINVAL);
 356    }
 357    if (buf->pool->setstatic == NULL) {
 358       _mesa_error(NULL, GL_INVALID_OPERATION,
 359                   "Invalid buffer pool for setStatic\n");
 360       BM_CKFATAL(-EINVAL);
 361    }
 362
 363    if (!flags)
 364       flags = buf->flags;
 365
 366    buf->private = buf->pool->setstatic(buf->pool, offset, size,
 367                                        virtual, flags);
 368    if (!buf->private) {
 369       _mesa_error(NULL, GL_OUT_OF_MEMORY,
 370                   "Invalid buffer pool for setStatic\n");
 371       BM_CKFATAL(-ENOMEM);
 372    }
 373    _glthread_UNLOCK_MUTEX(buf->mutex);
 374 }
 375
 376
 377
 378 void
 379 driGenBuffers(struct _DriBufferPool *pool,
 380               const char *name,
 381               unsigned n,
 382               struct _DriBufferObject *buffers[],
 383               unsigned alignment, unsigned flags, unsigned hint)
 384 {
 385    struct _DriBufferObject *buf;
 386    int i;
 387
 388    flags = (flags) ? flags : DRM_BO_FLAG_MEM_TT | DRM_BO_FLAG_MEM_VRAM |
 389       DRM_BO_FLAG_MEM_LOCAL | DRM_BO_FLAG_READ | DRM_BO_FLAG_WRITE;
 390
 391
 392    for (i = 0; i < n; ++i) {
 393       buf = (struct _DriBufferObject *) calloc(1, sizeof(*buf));
 394       if (!buf)
 395          BM_CKFATAL(-ENOMEM);
 396
 397       _glthread_INIT_MUTEX(buf->mutex);
 398       _glthread_LOCK_MUTEX(buf->mutex);
 399       _glthread_LOCK_MUTEX(bmMutex);
 400       buf->refCount = 1;
 401       _glthread_UNLOCK_MUTEX(bmMutex);
 402       buf->flags = flags;
 403       buf->hint = hint;
 404       buf->name = name;
 405       buf->alignment = alignment;
 406       buf->pool = pool;
 407       _glthread_UNLOCK_MUTEX(buf->mutex);
 408       buffers[i] = buf;
 409    }
 410 }
 411
 412 void
 413 driDeleteBuffers(unsigned n, struct _DriBufferObject *buffers[])
 414 {
 415    int i;
 416
 417    for (i = 0; i < n; ++i) {
 418       driBOUnReference(buffers[i]);
 419    }
 420 }
 421
 422
 423 void
 424 driInitBufMgr(int fd)
 425 {
 426    ;
 427 }
 428
 429
 430 void
 431 driBOCreateList(int target, drmBOList * list)
 432 {
 433    _glthread_LOCK_MUTEX(bmMutex);
 434    BM_CKFATAL(drmBOCreateList(20, list));
 435    _glthread_UNLOCK_MUTEX(bmMutex);
 436 }
 437
 438 void
 439 driBOResetList(drmBOList * list)
 440 {
 441    _glthread_LOCK_MUTEX(bmMutex);
 442    BM_CKFATAL(drmBOResetList(list));
 443    _glthread_UNLOCK_MUTEX(bmMutex);
 444 }
 445
 446 void
 447 driBOAddListItem(drmBOList * list, struct _DriBufferObject *buf,
 448                  unsigned flags, unsigned mask)
 449 {
 450    int newItem;
 451
 452    _glthread_LOCK_MUTEX(buf->mutex);
 453    _glthread_LOCK_MUTEX(bmMutex);
 454    BM_CKFATAL(drmAddValidateItem(list, driBOKernel(buf),
 455                                  flags, mask, &newItem));
 456    _glthread_UNLOCK_MUTEX(bmMutex);
 457
 458    /*
 459     * Tell userspace pools to validate the buffer. This should be a
 460     * noop if the pool is already validated.
 461     * FIXME: We should have a list for this as well.
 462     */
 463
 464    if (buf->pool->validate) {
 465       BM_CKFATAL(buf->pool->validate(buf->pool, buf->private));
 466    }
 467
 468    _glthread_UNLOCK_MUTEX(buf->mutex);
 469 }
 470
 471 void
 472 driBOFence(struct _DriBufferObject *buf, struct _DriFenceObject *fence)
 473 {
 474    _glthread_LOCK_MUTEX(buf->mutex);
 475    BM_CKFATAL(buf->pool->fence(buf->pool, buf->private, fence));
 476    _glthread_UNLOCK_MUTEX(buf->mutex);
 477
 478 }
 479
 480 void
 481 driBOValidateList(int fd, drmBOList * list)
 482 {
 483    _glthread_LOCK_MUTEX(bmMutex);
 484    BM_CKFATAL(drmBOValidateList(fd, list));
 485    _glthread_UNLOCK_MUTEX(bmMutex);
 486 }
 487
 488 void
 489 driPoolTakeDown(struct _DriBufferPool *pool)
 490 {
 491    pool->takeDown(pool);
 492
 493 }