sys/dev/drm/drm_gem.c

   1 /*-
   2  * Copyright (c) 2011 The FreeBSD Foundation
   3  * All rights reserved.
   4  *
   5  * This software was developed by Konstantin Belousov under sponsorship from
   6  * the FreeBSD Foundation.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * $FreeBSD: head/sys/dev/drm2/drm_gem.c 247835 2013-03-05 09:49:34Z kib $"
  30  */
  31
  32 #include "opt_vm.h"
  33
  34 #include <sys/param.h>
  35 #include <sys/systm.h>
  36 #include <sys/limits.h>
  37 #include <sys/lock.h>
  38 #include <sys/mutex.h>
  39 #include <sys/conf.h>
  40
  41 #include <vm/vm.h>
  42 #include <vm/vm_page.h>
  43
  44 #include <dev/drm/drmP.h>
  45 #include <dev/drm/drm.h>
  46 #include <dev/drm/drm_sarea.h>
  47
  48 /*
  49  * We make up offsets for buffer objects so we can recognize them at
  50  * mmap time.
  51  */
  52
  53 /* pgoff in mmap is an unsigned long, so we need to make sure that
  54  * the faked up offset will fit
  55  */
  56
  57 #if ULONG_MAX == UINT64_MAX
  58 #define DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFFUL >> PAGE_SHIFT) + 1)
  59 #define DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFFUL >> PAGE_SHIFT) * 16)
  60 #else
  61 #define DRM_FILE_PAGE_OFFSET_START ((0xFFFFFFFUL >> PAGE_SHIFT) + 1)
  62 #define DRM_FILE_PAGE_OFFSET_SIZE ((0xFFFFFFFUL >> PAGE_SHIFT) * 16)
  63 #endif
  64
  65 int
  66 drm_gem_init(struct drm_device *dev)
  67 {
  68         struct drm_gem_mm *mm;
  69
  70         drm_gem_names_init(&dev->object_names);
  71         mm = kmalloc(sizeof(*mm), DRM_MEM_DRIVER, M_WAITOK);
  72         dev->mm_private = mm;
  73         if (drm_ht_create(&mm->offset_hash, 19) != 0) {
  74                 drm_free(mm, DRM_MEM_DRIVER);
  75                 return (ENOMEM);
  76         }
  77         mm->idxunr = new_unrhdr(0, DRM_GEM_MAX_IDX, NULL);
  78         return (0);
  79 }
  80
  81 void
  82 drm_gem_destroy(struct drm_device *dev)
  83 {
  84         struct drm_gem_mm *mm;
  85
  86         mm = dev->mm_private;
  87         dev->mm_private = NULL;
  88         drm_ht_remove(&mm->offset_hash);
  89         delete_unrhdr(mm->idxunr);
  90         drm_free(mm, DRM_MEM_DRIVER);
  91         drm_gem_names_fini(&dev->object_names);
  92 }
  93
  94 int
  95 drm_gem_object_init(struct drm_device *dev, struct drm_gem_object *obj,
  96     size_t size)
  97 {
  98
  99         KASSERT((size & (PAGE_SIZE - 1)) == 0,
 100             ("Bad size %ju", (uintmax_t)size));
 101
 102         obj->dev = dev;
 103         obj->vm_obj = default_pager_alloc(NULL, size,
 104             VM_PROT_READ | VM_PROT_WRITE, 0);
 105
 106         obj->refcount = 1;
 107         obj->handle_count = 0;
 108         obj->size = size;
 109
 110         return (0);
 111 }
 112
 113 int
 114 drm_gem_private_object_init(struct drm_device *dev, struct drm_gem_object *obj,
 115     size_t size)
 116 {
 117
 118         KASSERT((size & (PAGE_SIZE - 1)) == 0,
 119             ("Bad size %ju", (uintmax_t)size));
 120
 121         obj->dev = dev;
 122         obj->vm_obj = NULL;
 123
 124         obj->refcount = 1;
 125         atomic_set(&obj->handle_count, 0);
 126         obj->size = size;
 127
 128         return (0);
 129 }
 130
 131
 132 struct drm_gem_object *
 133 drm_gem_object_alloc(struct drm_device *dev, size_t size)
 134 {
 135         struct drm_gem_object *obj;
 136
 137         obj = kmalloc(sizeof(*obj), DRM_MEM_DRIVER, M_WAITOK | M_ZERO);
 138         if (drm_gem_object_init(dev, obj, size) != 0)
 139                 goto free;
 140
 141         if (dev->driver->gem_init_object != NULL &&
 142             dev->driver->gem_init_object(obj) != 0)
 143                 goto dealloc;
 144         return (obj);
 145 dealloc:
 146         vm_object_deallocate(obj->vm_obj);
 147 free:
 148         drm_free(obj, DRM_MEM_DRIVER);
 149         return (NULL);
 150 }
 151
 152 void
 153 drm_gem_object_free(struct drm_gem_object *obj)
 154 {
 155         struct drm_device *dev;
 156
 157         dev = obj->dev;
 158         DRM_LOCK_ASSERT(dev);
 159         if (dev->driver->gem_free_object != NULL)
 160                 dev->driver->gem_free_object(obj);
 161 }
 162
 163 void
 164 drm_gem_object_reference(struct drm_gem_object *obj)
 165 {
 166
 167         KASSERT(obj->refcount > 0, ("Dandling obj %p", obj));
 168         refcount_acquire(&obj->refcount);
 169 }
 170
 171 void
 172 drm_gem_object_unreference(struct drm_gem_object *obj)
 173 {
 174
 175         if (obj == NULL)
 176                 return;
 177         if (refcount_release(&obj->refcount))
 178                 drm_gem_object_free(obj);
 179 }
 180
 181 void
 182 drm_gem_object_unreference_unlocked(struct drm_gem_object *obj)
 183 {
 184         struct drm_device *dev;
 185
 186         if (obj == NULL)
 187                 return;
 188         dev = obj->dev;
 189         DRM_LOCK(dev);
 190         drm_gem_object_unreference(obj);
 191         DRM_UNLOCK(dev);
 192 }
 193
 194 void
 195 drm_gem_object_handle_reference(struct drm_gem_object *obj)
 196 {
 197
 198         drm_gem_object_reference(obj);
 199         atomic_add_rel_int(&obj->handle_count, 1);
 200 }
 201
 202 void
 203 drm_gem_object_handle_free(struct drm_gem_object *obj)
 204 {
 205         struct drm_device *dev;
 206         struct drm_gem_object *obj1;
 207
 208         dev = obj->dev;
 209         if (obj->name != 0) {
 210                 obj1 = drm_gem_names_remove(&dev->object_names, obj->name);
 211                 obj->name = 0;
 212                 drm_gem_object_unreference(obj1);
 213         }
 214 }
 215
 216 void
 217 drm_gem_object_handle_unreference(struct drm_gem_object *obj)
 218 {
 219
 220         if (obj == NULL ||
 221             atomic_load_acq_int(&obj->handle_count) == 0)
 222                 return;
 223
 224         if (atomic_fetchadd_int(&obj->handle_count, -1) == 1)
 225                 drm_gem_object_handle_free(obj);
 226         drm_gem_object_unreference(obj);
 227 }
 228
 229 void
 230 drm_gem_object_handle_unreference_unlocked(struct drm_gem_object *obj)
 231 {
 232
 233         if (obj == NULL ||
 234             atomic_load_acq_int(&obj->handle_count) == 0)
 235                 return;
 236
 237         if (atomic_fetchadd_int(&obj->handle_count, -1) == 1)
 238                 drm_gem_object_handle_free(obj);
 239         drm_gem_object_unreference_unlocked(obj);
 240 }
 241
 242 int
 243 drm_gem_handle_create(struct drm_file *file_priv, struct drm_gem_object *obj,
 244     uint32_t *handle)
 245 {
 246         int error;
 247
 248         error = drm_gem_name_create(&file_priv->object_names, obj, handle);
 249         if (error != 0)
 250                 return (error);
 251         drm_gem_object_handle_reference(obj);
 252         return (0);
 253 }
 254
 255 int
 256 drm_gem_handle_delete(struct drm_file *file_priv, uint32_t handle)
 257 {
 258         struct drm_gem_object *obj;
 259
 260         obj = drm_gem_names_remove(&file_priv->object_names, handle);
 261         if (obj == NULL)
 262                 return (EINVAL);
 263         drm_gem_object_handle_unreference_unlocked(obj);
 264         return (0);
 265 }
 266
 267 void
 268 drm_gem_object_release(struct drm_gem_object *obj)
 269 {
 270
 271         /*
 272          * obj->vm_obj can be NULL for private gem objects.
 273          */
 274         vm_object_deallocate(obj->vm_obj);
 275 }
 276
 277 int
 278 drm_gem_open_ioctl(struct drm_device *dev, void *data,
 279     struct drm_file *file_priv)
 280 {
 281         struct drm_gem_open *args;
 282         struct drm_gem_object *obj;
 283         int ret;
 284         uint32_t handle;
 285
 286         if (!drm_core_check_feature(dev, DRIVER_GEM))
 287                 return (ENODEV);
 288         args = data;
 289
 290         obj = drm_gem_name_ref(&dev->object_names, args->name,
 291             (void (*)(void *))drm_gem_object_reference);
 292         if (obj == NULL)
 293                 return (ENOENT);
 294         handle = 0;
 295         ret = drm_gem_handle_create(file_priv, obj, &handle);
 296         drm_gem_object_unreference_unlocked(obj);
 297         if (ret != 0)
 298                 return (ret);
 299
 300         args->handle = handle;
 301         args->size = obj->size;
 302
 303         return (0);
 304 }
 305
 306 void
 307 drm_gem_open(struct drm_device *dev, struct drm_file *file_priv)
 308 {
 309
 310         drm_gem_names_init(&file_priv->object_names);
 311 }
 312
 313 static int
 314 drm_gem_object_release_handle(uint32_t name, void *ptr, void *arg)
 315 {
 316         struct drm_gem_object *obj;
 317
 318         obj = ptr;
 319         drm_gem_object_handle_unreference(obj);
 320         return (0);
 321 }
 322
 323 void
 324 drm_gem_release(struct drm_device *dev, struct drm_file *file_priv)
 325 {
 326
 327         drm_gem_names_foreach(&file_priv->object_names,
 328             drm_gem_object_release_handle, NULL);
 329         drm_gem_names_fini(&file_priv->object_names);
 330 }
 331
 332 int
 333 drm_gem_close_ioctl(struct drm_device *dev, void *data,
 334     struct drm_file *file_priv)
 335 {
 336         struct drm_gem_close *args;
 337
 338         if (!drm_core_check_feature(dev, DRIVER_GEM))
 339                 return (ENODEV);
 340         args = data;
 341
 342         return (drm_gem_handle_delete(file_priv, args->handle));
 343 }
 344
 345 int
 346 drm_gem_flink_ioctl(struct drm_device *dev, void *data,
 347     struct drm_file *file_priv)
 348 {
 349         struct drm_gem_flink *args;
 350         struct drm_gem_object *obj;
 351         int error;
 352
 353         if (!drm_core_check_feature(dev, DRIVER_GEM))
 354                 return (ENODEV);
 355         args = data;
 356
 357         obj = drm_gem_name_ref(&file_priv->object_names, args->handle,
 358             (void (*)(void *))drm_gem_object_reference);
 359         if (obj == NULL)
 360                 return (ENOENT);
 361         error = drm_gem_name_create(&dev->object_names, obj, &obj->name);
 362         if (error != 0) {
 363                 if (error == EALREADY)
 364                         error = 0;
 365                 drm_gem_object_unreference_unlocked(obj);
 366         }
 367         if (error == 0)
 368                 args->name = obj->name;
 369         return (error);
 370 }
 371
 372 struct drm_gem_object *
 373 drm_gem_object_lookup(struct drm_device *dev, struct drm_file *file_priv,
 374     uint32_t handle)
 375 {
 376         struct drm_gem_object *obj;
 377
 378         obj = drm_gem_name_ref(&file_priv->object_names, handle,
 379             (void (*)(void *))drm_gem_object_reference);
 380         return (obj);
 381 }
 382
 383 static struct drm_gem_object *
 384 drm_gem_object_from_offset(struct drm_device *dev, vm_ooffset_t offset)
 385 {
 386         struct drm_gem_object *obj;
 387         struct drm_gem_mm *mm;
 388         struct drm_hash_item *map_list;
 389
 390         if ((offset & DRM_GEM_MAPPING_MASK) != DRM_GEM_MAPPING_KEY)
 391                 return (NULL);
 392         offset &= ~DRM_GEM_MAPPING_KEY;
 393         mm = dev->mm_private;
 394         if (drm_ht_find_item(&mm->offset_hash, DRM_GEM_MAPPING_IDX(offset),
 395             &map_list) != 0) {
 396         DRM_DEBUG("drm_gem_object_from_offset: offset 0x%jx obj not found\n",
 397                     (uintmax_t)offset);
 398                 return (NULL);
 399         }
 400         obj = container_of(map_list, struct drm_gem_object, map_list);
 401         return (obj);
 402 }
 403
 404 int
 405 drm_gem_create_mmap_offset(struct drm_gem_object *obj)
 406 {
 407         struct drm_device *dev;
 408         struct drm_gem_mm *mm;
 409         int ret;
 410
 411         if (obj->on_map)
 412                 return (0);
 413         dev = obj->dev;
 414         mm = dev->mm_private;
 415         ret = 0;
 416
 417         obj->map_list.key = alloc_unr(mm->idxunr);
 418         ret = drm_ht_insert_item(&mm->offset_hash, &obj->map_list);
 419         if (ret != 0) {
 420                 DRM_ERROR("failed to add to map hash\n");
 421                 free_unr(mm->idxunr, obj->map_list.key);
 422                 return (ret);
 423         }
 424         obj->on_map = true;
 425         return (0);
 426 }
 427
 428 void
 429 drm_gem_free_mmap_offset(struct drm_gem_object *obj)
 430 {
 431         struct drm_hash_item *list;
 432         struct drm_gem_mm *mm;
 433
 434         if (!obj->on_map)
 435                 return;
 436         mm = obj->dev->mm_private;
 437         list = &obj->map_list;
 438
 439         drm_ht_remove_item(&mm->offset_hash, list);
 440         free_unr(mm->idxunr, list->key);
 441         obj->on_map = false;
 442 }
 443
 444 int
 445 drm_gem_mmap_single(struct drm_device *dev, vm_ooffset_t *offset, vm_size_t size,
 446     struct vm_object **obj_res, int nprot)
 447 {
 448         struct drm_gem_object *gem_obj;
 449         struct vm_object *vm_obj;
 450
 451         DRM_LOCK(dev);
 452         gem_obj = drm_gem_object_from_offset(dev, *offset);
 453         if (gem_obj == NULL) {
 454                 DRM_UNLOCK(dev);
 455                 return (ENODEV);
 456         }
 457         drm_gem_object_reference(gem_obj);
 458         DRM_UNLOCK(dev);
 459         vm_obj = cdev_pager_allocate(gem_obj, OBJT_MGTDEVICE,
 460             dev->driver->gem_pager_ops, size, nprot,
 461             DRM_GEM_MAPPING_MAPOFF(*offset), curthread->td_ucred);
 462         if (vm_obj == NULL) {
 463                 drm_gem_object_unreference_unlocked(gem_obj);
 464                 return (EINVAL);
 465         }
 466         *offset = DRM_GEM_MAPPING_MAPOFF(*offset);
 467         *obj_res = vm_obj;
 468         return (0);
 469 }
 470
 471 void
 472 drm_gem_pager_dtr(void *handle)
 473 {
 474         struct drm_gem_object *obj;
 475         struct drm_device *dev;
 476
 477         obj = handle;
 478         dev = obj->dev;
 479
 480         DRM_LOCK(dev);
 481         drm_gem_free_mmap_offset(obj);
 482         drm_gem_object_unreference(obj);
 483         DRM_UNLOCK(dev);
 484 }