drivers/gpu/drm/vc4/vc4_bo.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  Copyright © 2015 Broadcom
   4  */
   5
   6 /**
   7  * DOC: VC4 GEM BO management support
   8  *
   9  * The VC4 GPU architecture (both scanout and rendering) has direct
  10  * access to system memory with no MMU in between.  To support it, we
  11  * use the GEM CMA helper functions to allocate contiguous ranges of
  12  * physical memory for our BOs.
  13  *
  14  * Since the CMA allocator is very slow, we keep a cache of recently
  15  * freed BOs around so that the kernel's allocation of objects for 3D
  16  * rendering can return quickly.
  17  */
  18
  19 #include <linux/dma-buf.h>
  20
  21 #include "vc4_drv.h"
  22 #include "uapi/drm/vc4_drm.h"
  23
  24 static const char * const bo_type_names[] = {
  25         "kernel",
  26         "V3D",
  27         "V3D shader",
  28         "dumb",
  29         "binner",
  30         "RCL",
  31         "BCL",
  32         "kernel BO cache",
  33 };
  34
  35 static bool is_user_label(int label)
  36 {
  37         return label >= VC4_BO_TYPE_COUNT;
  38 }
  39
  40 static void vc4_bo_stats_print(struct drm_printer *p, struct vc4_dev *vc4)
  41 {
  42         int i;
  43
  44         for (i = 0; i < vc4->num_labels; i++) {
  45                 if (!vc4->bo_labels[i].num_allocated)
  46                         continue;
  47
  48                 drm_printf(p, "%30s: %6dkb BOs (%d)\n",
  49                            vc4->bo_labels[i].name,
  50                            vc4->bo_labels[i].size_allocated / 1024,
  51                            vc4->bo_labels[i].num_allocated);
  52         }
  53
  54         mutex_lock(&vc4->purgeable.lock);
  55         if (vc4->purgeable.num)
  56                 drm_printf(p, "%30s: %6zdkb BOs (%d)\n", "userspace BO cache",
  57                            vc4->purgeable.size / 1024, vc4->purgeable.num);
  58
  59         if (vc4->purgeable.purged_num)
  60                 drm_printf(p, "%30s: %6zdkb BOs (%d)\n", "total purged BO",
  61                            vc4->purgeable.purged_size / 1024,
  62                            vc4->purgeable.purged_num);
  63         mutex_unlock(&vc4->purgeable.lock);
  64 }
  65
  66 static int vc4_bo_stats_debugfs(struct seq_file *m, void *unused)
  67 {
  68         struct drm_info_node *node = (struct drm_info_node *)m->private;
  69         struct drm_device *dev = node->minor->dev;
  70         struct vc4_dev *vc4 = to_vc4_dev(dev);
  71         struct drm_printer p = drm_seq_file_printer(m);
  72
  73         vc4_bo_stats_print(&p, vc4);
  74
  75         return 0;
  76 }
  77
  78 /* Takes ownership of *name and returns the appropriate slot for it in
  79  * the bo_labels[] array, extending it as necessary.
  80  *
  81  * This is inefficient and could use a hash table instead of walking
  82  * an array and strcmp()ing.  However, the assumption is that user
  83  * labeling will be infrequent (scanout buffers and other long-lived
  84  * objects, or debug driver builds), so we can live with it for now.
  85  */
  86 static int vc4_get_user_label(struct vc4_dev *vc4, const char *name)
  87 {
  88         int i;
  89         int free_slot = -1;
  90
  91         for (i = 0; i < vc4->num_labels; i++) {
  92                 if (!vc4->bo_labels[i].name) {
  93                         free_slot = i;
  94                 } else if (strcmp(vc4->bo_labels[i].name, name) == 0) {
  95                         kfree(name);
  96                         return i;
  97                 }
  98         }
  99
 100         if (free_slot != -1) {
 101                 WARN_ON(vc4->bo_labels[free_slot].num_allocated != 0);
 102                 vc4->bo_labels[free_slot].name = name;
 103                 return free_slot;
 104         } else {
 105                 u32 new_label_count = vc4->num_labels + 1;
 106                 struct vc4_label *new_labels =
 107                         krealloc(vc4->bo_labels,
 108                                  new_label_count * sizeof(*new_labels),
 109                                  GFP_KERNEL);
 110
 111                 if (!new_labels) {
 112                         kfree(name);
 113                         return -1;
 114                 }
 115
 116                 free_slot = vc4->num_labels;
 117                 vc4->bo_labels = new_labels;
 118                 vc4->num_labels = new_label_count;
 119
 120                 vc4->bo_labels[free_slot].name = name;
 121                 vc4->bo_labels[free_slot].num_allocated = 0;
 122                 vc4->bo_labels[free_slot].size_allocated = 0;
 123
 124                 return free_slot;
 125         }
 126 }
 127
 128 static void vc4_bo_set_label(struct drm_gem_object *gem_obj, int label)
 129 {
 130         struct vc4_bo *bo = to_vc4_bo(gem_obj);
 131         struct vc4_dev *vc4 = to_vc4_dev(gem_obj->dev);
 132
 133         lockdep_assert_held(&vc4->bo_lock);
 134
 135         if (label != -1) {
 136                 vc4->bo_labels[label].num_allocated++;
 137                 vc4->bo_labels[label].size_allocated += gem_obj->size;
 138         }
 139
 140         vc4->bo_labels[bo->label].num_allocated--;
 141         vc4->bo_labels[bo->label].size_allocated -= gem_obj->size;
 142
 143         if (vc4->bo_labels[bo->label].num_allocated == 0 &&
 144             is_user_label(bo->label)) {
 145                 /* Free user BO label slots on last unreference.
 146                  * Slots are just where we track the stats for a given
 147                  * name, and once a name is unused we can reuse that
 148                  * slot.
 149                  */
 150                 kfree(vc4->bo_labels[bo->label].name);
 151                 vc4->bo_labels[bo->label].name = NULL;
 152         }
 153
 154         bo->label = label;
 155 }
 156
 157 static uint32_t bo_page_index(size_t size)
 158 {
 159         return (size / PAGE_SIZE) - 1;
 160 }
 161
 162 static void vc4_bo_destroy(struct vc4_bo *bo)
 163 {
 164         struct drm_gem_object *obj = &bo->base.base;
 165         struct vc4_dev *vc4 = to_vc4_dev(obj->dev);
 166
 167         lockdep_assert_held(&vc4->bo_lock);
 168
 169         vc4_bo_set_label(obj, -1);
 170
 171         if (bo->validated_shader) {
 172                 kfree(bo->validated_shader->uniform_addr_offsets);
 173                 kfree(bo->validated_shader->texture_samples);
 174                 kfree(bo->validated_shader);
 175                 bo->validated_shader = NULL;
 176         }
 177
 178         drm_gem_cma_free_object(obj);
 179 }
 180
 181 static void vc4_bo_remove_from_cache(struct vc4_bo *bo)
 182 {
 183         struct vc4_dev *vc4 = to_vc4_dev(bo->base.base.dev);
 184
 185         lockdep_assert_held(&vc4->bo_lock);
 186         list_del(&bo->unref_head);
 187         list_del(&bo->size_head);
 188 }
 189
 190 static struct list_head *vc4_get_cache_list_for_size(struct drm_device *dev,
 191                                                      size_t size)
 192 {
 193         struct vc4_dev *vc4 = to_vc4_dev(dev);
 194         uint32_t page_index = bo_page_index(size);
 195
 196         if (vc4->bo_cache.size_list_size <= page_index) {
 197                 uint32_t new_size = max(vc4->bo_cache.size_list_size * 2,
 198                                         page_index + 1);
 199                 struct list_head *new_list;
 200                 uint32_t i;
 201
 202                 new_list = kmalloc_array(new_size, sizeof(struct list_head),
 203                                          GFP_KERNEL);
 204                 if (!new_list)
 205                         return NULL;
 206
 207                 /* Rebase the old cached BO lists to their new list
 208                  * head locations.
 209                  */
 210                 for (i = 0; i < vc4->bo_cache.size_list_size; i++) {
 211                         struct list_head *old_list =
 212                                 &vc4->bo_cache.size_list[i];
 213
 214                         if (list_empty(old_list))
 215                                 INIT_LIST_HEAD(&new_list[i]);
 216                         else
 217                                 list_replace(old_list, &new_list[i]);
 218                 }
 219                 /* And initialize the brand new BO list heads. */
 220                 for (i = vc4->bo_cache.size_list_size; i < new_size; i++)
 221                         INIT_LIST_HEAD(&new_list[i]);
 222
 223                 kfree(vc4->bo_cache.size_list);
 224                 vc4->bo_cache.size_list = new_list;
 225                 vc4->bo_cache.size_list_size = new_size;
 226         }
 227
 228         return &vc4->bo_cache.size_list[page_index];
 229 }
 230
 231 static void vc4_bo_cache_purge(struct drm_device *dev)
 232 {
 233         struct vc4_dev *vc4 = to_vc4_dev(dev);
 234
 235         mutex_lock(&vc4->bo_lock);
 236         while (!list_empty(&vc4->bo_cache.time_list)) {
 237                 struct vc4_bo *bo = list_last_entry(&vc4->bo_cache.time_list,
 238                                                     struct vc4_bo, unref_head);
 239                 vc4_bo_remove_from_cache(bo);
 240                 vc4_bo_destroy(bo);
 241         }
 242         mutex_unlock(&vc4->bo_lock);
 243 }
 244
 245 void vc4_bo_add_to_purgeable_pool(struct vc4_bo *bo)
 246 {
 247         struct vc4_dev *vc4 = to_vc4_dev(bo->base.base.dev);
 248
 249         mutex_lock(&vc4->purgeable.lock);
 250         list_add_tail(&bo->size_head, &vc4->purgeable.list);
 251         vc4->purgeable.num++;
 252         vc4->purgeable.size += bo->base.base.size;
 253         mutex_unlock(&vc4->purgeable.lock);
 254 }
 255
 256 static void vc4_bo_remove_from_purgeable_pool_locked(struct vc4_bo *bo)
 257 {
 258         struct vc4_dev *vc4 = to_vc4_dev(bo->base.base.dev);
 259
 260         /* list_del_init() is used here because the caller might release
 261          * the purgeable lock in order to acquire the madv one and update the
 262          * madv status.
 263          * During this short period of time a user might decide to mark
 264          * the BO as unpurgeable, and if bo->madv is set to
 265          * VC4_MADV_DONTNEED it will try to remove the BO from the
 266          * purgeable list which will fail if the ->next/prev fields
 267          * are set to LIST_POISON1/LIST_POISON2 (which is what
 268          * list_del() does).
 269          * Re-initializing the list element guarantees that list_del()
 270          * will work correctly even if it's a NOP.
 271          */
 272         list_del_init(&bo->size_head);
 273         vc4->purgeable.num--;
 274         vc4->purgeable.size -= bo->base.base.size;
 275 }
 276
 277 void vc4_bo_remove_from_purgeable_pool(struct vc4_bo *bo)
 278 {
 279         struct vc4_dev *vc4 = to_vc4_dev(bo->base.base.dev);
 280
 281         mutex_lock(&vc4->purgeable.lock);
 282         vc4_bo_remove_from_purgeable_pool_locked(bo);
 283         mutex_unlock(&vc4->purgeable.lock);
 284 }
 285
 286 static void vc4_bo_purge(struct drm_gem_object *obj)
 287 {
 288         struct vc4_bo *bo = to_vc4_bo(obj);
 289         struct drm_device *dev = obj->dev;
 290
 291         WARN_ON(!mutex_is_locked(&bo->madv_lock));
 292         WARN_ON(bo->madv != VC4_MADV_DONTNEED);
 293
 294         drm_vma_node_unmap(&obj->vma_node, dev->anon_inode->i_mapping);
 295
 296         dma_free_wc(dev->dev, obj->size, bo->base.vaddr, bo->base.paddr);
 297         bo->base.vaddr = NULL;
 298         bo->madv = __VC4_MADV_PURGED;
 299 }
 300
 301 static void vc4_bo_userspace_cache_purge(struct drm_device *dev)
 302 {
 303         struct vc4_dev *vc4 = to_vc4_dev(dev);
 304
 305         mutex_lock(&vc4->purgeable.lock);
 306         while (!list_empty(&vc4->purgeable.list)) {
 307                 struct vc4_bo *bo = list_first_entry(&vc4->purgeable.list,
 308                                                      struct vc4_bo, size_head);
 309                 struct drm_gem_object *obj = &bo->base.base;
 310                 size_t purged_size = 0;
 311
 312                 vc4_bo_remove_from_purgeable_pool_locked(bo);
 313
 314                 /* Release the purgeable lock while we're purging the BO so
 315                  * that other people can continue inserting things in the
 316                  * purgeable pool without having to wait for all BOs to be
 317                  * purged.
 318                  */
 319                 mutex_unlock(&vc4->purgeable.lock);
 320                 mutex_lock(&bo->madv_lock);
 321
 322                 /* Since we released the purgeable pool lock before acquiring
 323                  * the BO madv one, the user may have marked the BO as WILLNEED
 324                  * and re-used it in the meantime.
 325                  * Before purging the BO we need to make sure
 326                  * - it is still marked as DONTNEED
 327                  * - it has not been re-inserted in the purgeable list
 328                  * - it is not used by HW blocks
 329                  * If one of these conditions is not met, just skip the entry.
 330                  */
 331                 if (bo->madv == VC4_MADV_DONTNEED &&
 332                     list_empty(&bo->size_head) &&
 333                     !refcount_read(&bo->usecnt)) {
 334                         purged_size = bo->base.base.size;
 335                         vc4_bo_purge(obj);
 336                 }
 337                 mutex_unlock(&bo->madv_lock);
 338                 mutex_lock(&vc4->purgeable.lock);
 339
 340                 if (purged_size) {
 341                         vc4->purgeable.purged_size += purged_size;
 342                         vc4->purgeable.purged_num++;
 343                 }
 344         }
 345         mutex_unlock(&vc4->purgeable.lock);
 346 }
 347
 348 static struct vc4_bo *vc4_bo_get_from_cache(struct drm_device *dev,
 349                                             uint32_t size,
 350                                             enum vc4_kernel_bo_type type)
 351 {
 352         struct vc4_dev *vc4 = to_vc4_dev(dev);
 353         uint32_t page_index = bo_page_index(size);
 354         struct vc4_bo *bo = NULL;
 355
 356         size = roundup(size, PAGE_SIZE);
 357
 358         mutex_lock(&vc4->bo_lock);
 359         if (page_index >= vc4->bo_cache.size_list_size)
 360                 goto out;
 361
 362         if (list_empty(&vc4->bo_cache.size_list[page_index]))
 363                 goto out;
 364
 365         bo = list_first_entry(&vc4->bo_cache.size_list[page_index],
 366                               struct vc4_bo, size_head);
 367         vc4_bo_remove_from_cache(bo);
 368         kref_init(&bo->base.base.refcount);
 369
 370 out:
 371         if (bo)
 372                 vc4_bo_set_label(&bo->base.base, type);
 373         mutex_unlock(&vc4->bo_lock);
 374         return bo;
 375 }
 376
 377 /**
 378  * vc4_gem_create_object - Implementation of driver->gem_create_object.
 379  * @dev: DRM device
 380  * @size: Size in bytes of the memory the object will reference
 381  *
 382  * This lets the CMA helpers allocate object structs for us, and keep
 383  * our BO stats correct.
 384  */
 385 struct drm_gem_object *vc4_create_object(struct drm_device *dev, size_t size)
 386 {
 387         struct vc4_dev *vc4 = to_vc4_dev(dev);
 388         struct vc4_bo *bo;
 389
 390         bo = kzalloc(sizeof(*bo), GFP_KERNEL);
 391         if (!bo)
 392                 return ERR_PTR(-ENOMEM);
 393
 394         bo->madv = VC4_MADV_WILLNEED;
 395         refcount_set(&bo->usecnt, 0);
 396         mutex_init(&bo->madv_lock);
 397         mutex_lock(&vc4->bo_lock);
 398         bo->label = VC4_BO_TYPE_KERNEL;
 399         vc4->bo_labels[VC4_BO_TYPE_KERNEL].num_allocated++;
 400         vc4->bo_labels[VC4_BO_TYPE_KERNEL].size_allocated += size;
 401         mutex_unlock(&vc4->bo_lock);
 402
 403         return &bo->base.base;
 404 }
 405
 406 struct vc4_bo *vc4_bo_create(struct drm_device *dev, size_t unaligned_size,
 407                              bool allow_unzeroed, enum vc4_kernel_bo_type type)
 408 {
 409         size_t size = roundup(unaligned_size, PAGE_SIZE);
 410         struct vc4_dev *vc4 = to_vc4_dev(dev);
 411         struct drm_gem_cma_object *cma_obj;
 412         struct vc4_bo *bo;
 413
 414         if (size == 0)
 415                 return ERR_PTR(-EINVAL);
 416
 417         /* First, try to get a vc4_bo from the kernel BO cache. */
 418         bo = vc4_bo_get_from_cache(dev, size, type);
 419         if (bo) {
 420                 if (!allow_unzeroed)
 421                         memset(bo->base.vaddr, 0, bo->base.base.size);
 422                 return bo;
 423         }
 424
 425         cma_obj = drm_gem_cma_create(dev, size);
 426         if (IS_ERR(cma_obj)) {
 427                 /*
 428                  * If we've run out of CMA memory, kill the cache of
 429                  * CMA allocations we've got laying around and try again.
 430                  */
 431                 vc4_bo_cache_purge(dev);
 432                 cma_obj = drm_gem_cma_create(dev, size);
 433         }
 434
 435         if (IS_ERR(cma_obj)) {
 436                 /*
 437                  * Still not enough CMA memory, purge the userspace BO
 438                  * cache and retry.
 439                  * This is sub-optimal since we purge the whole userspace
 440                  * BO cache which forces user that want to re-use the BO to
 441                  * restore its initial content.
 442                  * Ideally, we should purge entries one by one and retry
 443                  * after each to see if CMA allocation succeeds. Or even
 444                  * better, try to find an entry with at least the same
 445                  * size.
 446                  */
 447                 vc4_bo_userspace_cache_purge(dev);
 448                 cma_obj = drm_gem_cma_create(dev, size);
 449         }
 450
 451         if (IS_ERR(cma_obj)) {
 452                 struct drm_printer p = drm_info_printer(vc4->dev->dev);
 453                 DRM_ERROR("Failed to allocate from CMA:\n");
 454                 vc4_bo_stats_print(&p, vc4);
 455                 return ERR_PTR(-ENOMEM);
 456         }
 457         bo = to_vc4_bo(&cma_obj->base);
 458
 459         /* By default, BOs do not support the MADV ioctl. This will be enabled
 460          * only on BOs that are exposed to userspace (V3D, V3D_SHADER and DUMB
 461          * BOs).
 462          */
 463         bo->madv = __VC4_MADV_NOTSUPP;
 464
 465         mutex_lock(&vc4->bo_lock);
 466         vc4_bo_set_label(&cma_obj->base, type);
 467         mutex_unlock(&vc4->bo_lock);
 468
 469         return bo;
 470 }
 471
 472 int vc4_dumb_create(struct drm_file *file_priv,
 473                     struct drm_device *dev,
 474                     struct drm_mode_create_dumb *args)
 475 {
 476         int min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
 477         struct vc4_bo *bo = NULL;
 478         int ret;
 479
 480         if (args->pitch < min_pitch)
 481                 args->pitch = min_pitch;
 482
 483         if (args->size < args->pitch * args->height)
 484                 args->size = args->pitch * args->height;
 485
 486         bo = vc4_bo_create(dev, args->size, false, VC4_BO_TYPE_DUMB);
 487         if (IS_ERR(bo))
 488                 return PTR_ERR(bo);
 489
 490         bo->madv = VC4_MADV_WILLNEED;
 491
 492         ret = drm_gem_handle_create(file_priv, &bo->base.base, &args->handle);
 493         drm_gem_object_put_unlocked(&bo->base.base);
 494
 495         return ret;
 496 }
 497
 498 static void vc4_bo_cache_free_old(struct drm_device *dev)
 499 {
 500         struct vc4_dev *vc4 = to_vc4_dev(dev);
 501         unsigned long expire_time = jiffies - msecs_to_jiffies(1000);
 502
 503         lockdep_assert_held(&vc4->bo_lock);
 504
 505         while (!list_empty(&vc4->bo_cache.time_list)) {
 506                 struct vc4_bo *bo = list_last_entry(&vc4->bo_cache.time_list,
 507                                                     struct vc4_bo, unref_head);
 508                 if (time_before(expire_time, bo->free_time)) {
 509                         mod_timer(&vc4->bo_cache.time_timer,
 510                                   round_jiffies_up(jiffies +
 511                                                    msecs_to_jiffies(1000)));
 512                         return;
 513                 }
 514
 515                 vc4_bo_remove_from_cache(bo);
 516                 vc4_bo_destroy(bo);
 517         }
 518 }
 519
 520 /* Called on the last userspace/kernel unreference of the BO.  Returns
 521  * it to the BO cache if possible, otherwise frees it.
 522  */
 523 void vc4_free_object(struct drm_gem_object *gem_bo)
 524 {
 525         struct drm_device *dev = gem_bo->dev;
 526         struct vc4_dev *vc4 = to_vc4_dev(dev);
 527         struct vc4_bo *bo = to_vc4_bo(gem_bo);
 528         struct list_head *cache_list;
 529
 530         /* Remove the BO from the purgeable list. */
 531         mutex_lock(&bo->madv_lock);
 532         if (bo->madv == VC4_MADV_DONTNEED && !refcount_read(&bo->usecnt))
 533                 vc4_bo_remove_from_purgeable_pool(bo);
 534         mutex_unlock(&bo->madv_lock);
 535
 536         mutex_lock(&vc4->bo_lock);
 537         /* If the object references someone else's memory, we can't cache it.
 538          */
 539         if (gem_bo->import_attach) {
 540                 vc4_bo_destroy(bo);
 541                 goto out;
 542         }
 543
 544         /* Don't cache if it was publicly named. */
 545         if (gem_bo->name) {
 546                 vc4_bo_destroy(bo);
 547                 goto out;
 548         }
 549
 550         /* If this object was partially constructed but CMA allocation
 551          * had failed, just free it. Can also happen when the BO has been
 552          * purged.
 553          */
 554         if (!bo->base.vaddr) {
 555                 vc4_bo_destroy(bo);
 556                 goto out;
 557         }
 558
 559         cache_list = vc4_get_cache_list_for_size(dev, gem_bo->size);
 560         if (!cache_list) {
 561                 vc4_bo_destroy(bo);
 562                 goto out;
 563         }
 564
 565         if (bo->validated_shader) {
 566                 kfree(bo->validated_shader->uniform_addr_offsets);
 567                 kfree(bo->validated_shader->texture_samples);
 568                 kfree(bo->validated_shader);
 569                 bo->validated_shader = NULL;
 570         }
 571
 572         /* Reset madv and usecnt before adding the BO to the cache. */
 573         bo->madv = __VC4_MADV_NOTSUPP;
 574         refcount_set(&bo->usecnt, 0);
 575
 576         bo->t_format = false;
 577         bo->free_time = jiffies;
 578         list_add(&bo->size_head, cache_list);
 579         list_add(&bo->unref_head, &vc4->bo_cache.time_list);
 580
 581         vc4_bo_set_label(&bo->base.base, VC4_BO_TYPE_KERNEL_CACHE);
 582
 583         vc4_bo_cache_free_old(dev);
 584
 585 out:
 586         mutex_unlock(&vc4->bo_lock);
 587 }
 588
 589 static void vc4_bo_cache_time_work(struct work_struct *work)
 590 {
 591         struct vc4_dev *vc4 =
 592                 container_of(work, struct vc4_dev, bo_cache.time_work);
 593         struct drm_device *dev = vc4->dev;
 594
 595         mutex_lock(&vc4->bo_lock);
 596         vc4_bo_cache_free_old(dev);
 597         mutex_unlock(&vc4->bo_lock);
 598 }
 599
 600 int vc4_bo_inc_usecnt(struct vc4_bo *bo)
 601 {
 602         int ret;
 603
 604         /* Fast path: if the BO is already retained by someone, no need to
 605          * check the madv status.
 606          */
 607         if (refcount_inc_not_zero(&bo->usecnt))
 608                 return 0;
 609
 610         mutex_lock(&bo->madv_lock);
 611         switch (bo->madv) {
 612         case VC4_MADV_WILLNEED:
 613                 if (!refcount_inc_not_zero(&bo->usecnt))
 614                         refcount_set(&bo->usecnt, 1);
 615                 ret = 0;
 616                 break;
 617         case VC4_MADV_DONTNEED:
 618                 /* We shouldn't use a BO marked as purgeable if at least
 619                  * someone else retained its content by incrementing usecnt.
 620                  * Luckily the BO hasn't been purged yet, but something wrong
 621                  * is happening here. Just throw an error instead of
 622                  * authorizing this use case.
 623                  */
 624         case __VC4_MADV_PURGED:
 625                 /* We can't use a purged BO. */
 626         default:
 627                 /* Invalid madv value. */
 628                 ret = -EINVAL;
 629                 break;
 630         }
 631         mutex_unlock(&bo->madv_lock);
 632
 633         return ret;
 634 }
 635
 636 void vc4_bo_dec_usecnt(struct vc4_bo *bo)
 637 {
 638         /* Fast path: if the BO is still retained by someone, no need to test
 639          * the madv value.
 640          */
 641         if (refcount_dec_not_one(&bo->usecnt))
 642                 return;
 643
 644         mutex_lock(&bo->madv_lock);
 645         if (refcount_dec_and_test(&bo->usecnt) &&
 646             bo->madv == VC4_MADV_DONTNEED)
 647                 vc4_bo_add_to_purgeable_pool(bo);
 648         mutex_unlock(&bo->madv_lock);
 649 }
 650
 651 static void vc4_bo_cache_time_timer(struct timer_list *t)
 652 {
 653         struct vc4_dev *vc4 = from_timer(vc4, t, bo_cache.time_timer);
 654
 655         schedule_work(&vc4->bo_cache.time_work);
 656 }
 657
 658 struct dma_buf *
 659 vc4_prime_export(struct drm_device *dev, struct drm_gem_object *obj, int flags)
 660 {
 661         struct vc4_bo *bo = to_vc4_bo(obj);
 662         struct dma_buf *dmabuf;
 663         int ret;
 664
 665         if (bo->validated_shader) {
 666                 DRM_DEBUG("Attempting to export shader BO\n");
 667                 return ERR_PTR(-EINVAL);
 668         }
 669
 670         /* Note: as soon as the BO is exported it becomes unpurgeable, because
 671          * noone ever decrements the usecnt even if the reference held by the
 672          * exported BO is released. This shouldn't be a problem since we don't
 673          * expect exported BOs to be marked as purgeable.
 674          */
 675         ret = vc4_bo_inc_usecnt(bo);
 676         if (ret) {
 677                 DRM_ERROR("Failed to increment BO usecnt\n");
 678                 return ERR_PTR(ret);
 679         }
 680
 681         dmabuf = drm_gem_prime_export(dev, obj, flags);
 682         if (IS_ERR(dmabuf))
 683                 vc4_bo_dec_usecnt(bo);
 684
 685         return dmabuf;
 686 }
 687
 688 vm_fault_t vc4_fault(struct vm_fault *vmf)
 689 {
 690         struct vm_area_struct *vma = vmf->vma;
 691         struct drm_gem_object *obj = vma->vm_private_data;
 692         struct vc4_bo *bo = to_vc4_bo(obj);
 693
 694         /* The only reason we would end up here is when user-space accesses
 695          * BO's memory after it's been purged.
 696          */
 697         mutex_lock(&bo->madv_lock);
 698         WARN_ON(bo->madv != __VC4_MADV_PURGED);
 699         mutex_unlock(&bo->madv_lock);
 700
 701         return VM_FAULT_SIGBUS;
 702 }
 703
 704 int vc4_mmap(struct file *filp, struct vm_area_struct *vma)
 705 {
 706         struct drm_gem_object *gem_obj;
 707         unsigned long vm_pgoff;
 708         struct vc4_bo *bo;
 709         int ret;
 710
 711         ret = drm_gem_mmap(filp, vma);
 712         if (ret)
 713                 return ret;
 714
 715         gem_obj = vma->vm_private_data;
 716         bo = to_vc4_bo(gem_obj);
 717
 718         if (bo->validated_shader && (vma->vm_flags & VM_WRITE)) {
 719                 DRM_DEBUG("mmaping of shader BOs for writing not allowed.\n");
 720                 return -EINVAL;
 721         }
 722
 723         if (bo->madv != VC4_MADV_WILLNEED) {
 724                 DRM_DEBUG("mmaping of %s BO not allowed\n",
 725                           bo->madv == VC4_MADV_DONTNEED ?
 726                           "purgeable" : "purged");
 727                 return -EINVAL;
 728         }
 729
 730         /*
 731          * Clear the VM_PFNMAP flag that was set by drm_gem_mmap(), and set the
 732          * vm_pgoff (used as a fake buffer offset by DRM) to 0 as we want to map
 733          * the whole buffer.
 734          */
 735         vma->vm_flags &= ~VM_PFNMAP;
 736
 737         /* This ->vm_pgoff dance is needed to make all parties happy:
 738          * - dma_mmap_wc() uses ->vm_pgoff as an offset within the allocated
 739          *   mem-region, hence the need to set it to zero (the value set by
 740          *   the DRM core is a virtual offset encoding the GEM object-id)
 741          * - the mmap() core logic needs ->vm_pgoff to be restored to its
 742          *   initial value before returning from this function because it
 743          *   encodes the  offset of this GEM in the dev->anon_inode pseudo-file
 744          *   and this information will be used when we invalidate userspace
 745          *   mappings  with drm_vma_node_unmap() (called from vc4_gem_purge()).
 746          */
 747         vm_pgoff = vma->vm_pgoff;
 748         vma->vm_pgoff = 0;
 749         ret = dma_mmap_wc(bo->base.base.dev->dev, vma, bo->base.vaddr,
 750                           bo->base.paddr, vma->vm_end - vma->vm_start);
 751         vma->vm_pgoff = vm_pgoff;
 752
 753         if (ret)
 754                 drm_gem_vm_close(vma);
 755
 756         return ret;
 757 }
 758
 759 int vc4_prime_mmap(struct drm_gem_object *obj, struct vm_area_struct *vma)
 760 {
 761         struct vc4_bo *bo = to_vc4_bo(obj);
 762
 763         if (bo->validated_shader && (vma->vm_flags & VM_WRITE)) {
 764                 DRM_DEBUG("mmaping of shader BOs for writing not allowed.\n");
 765                 return -EINVAL;
 766         }
 767
 768         return drm_gem_cma_prime_mmap(obj, vma);
 769 }
 770
 771 void *vc4_prime_vmap(struct drm_gem_object *obj)
 772 {
 773         struct vc4_bo *bo = to_vc4_bo(obj);
 774
 775         if (bo->validated_shader) {
 776                 DRM_DEBUG("mmaping of shader BOs not allowed.\n");
 777                 return ERR_PTR(-EINVAL);
 778         }
 779
 780         return drm_gem_cma_prime_vmap(obj);
 781 }
 782
 783 struct drm_gem_object *
 784 vc4_prime_import_sg_table(struct drm_device *dev,
 785                           struct dma_buf_attachment *attach,
 786                           struct sg_table *sgt)
 787 {
 788         struct drm_gem_object *obj;
 789
 790         obj = drm_gem_cma_prime_import_sg_table(dev, attach, sgt);
 791         if (IS_ERR(obj))
 792                 return obj;
 793
 794         obj->resv = attach->dmabuf->resv;
 795
 796         return obj;
 797 }
 798
 799 static int vc4_grab_bin_bo(struct vc4_dev *vc4, struct vc4_file *vc4file)
 800 {
 801         int ret;
 802
 803         if (!vc4->v3d)
 804                 return -ENODEV;
 805
 806         if (vc4file->bin_bo_used)
 807                 return 0;
 808
 809         ret = vc4_v3d_bin_bo_get(vc4, &vc4file->bin_bo_used);
 810         if (ret)
 811                 return ret;
 812
 813         return 0;
 814 }
 815
 816 int vc4_create_bo_ioctl(struct drm_device *dev, void *data,
 817                         struct drm_file *file_priv)
 818 {
 819         struct drm_vc4_create_bo *args = data;
 820         struct vc4_file *vc4file = file_priv->driver_priv;
 821         struct vc4_dev *vc4 = to_vc4_dev(dev);
 822         struct vc4_bo *bo = NULL;
 823         int ret;
 824
 825         ret = vc4_grab_bin_bo(vc4, vc4file);
 826         if (ret)
 827                 return ret;
 828
 829         /*
 830          * We can't allocate from the BO cache, because the BOs don't
 831          * get zeroed, and that might leak data between users.
 832          */
 833         bo = vc4_bo_create(dev, args->size, false, VC4_BO_TYPE_V3D);
 834         if (IS_ERR(bo))
 835                 return PTR_ERR(bo);
 836
 837         bo->madv = VC4_MADV_WILLNEED;
 838
 839         ret = drm_gem_handle_create(file_priv, &bo->base.base, &args->handle);
 840         drm_gem_object_put_unlocked(&bo->base.base);
 841
 842         return ret;
 843 }
 844
 845 int vc4_mmap_bo_ioctl(struct drm_device *dev, void *data,
 846                       struct drm_file *file_priv)
 847 {
 848         struct drm_vc4_mmap_bo *args = data;
 849         struct drm_gem_object *gem_obj;
 850
 851         gem_obj = drm_gem_object_lookup(file_priv, args->handle);
 852         if (!gem_obj) {
 853                 DRM_DEBUG("Failed to look up GEM BO %d\n", args->handle);
 854                 return -EINVAL;
 855         }
 856
 857         /* The mmap offset was set up at BO allocation time. */
 858         args->offset = drm_vma_node_offset_addr(&gem_obj->vma_node);
 859
 860         drm_gem_object_put_unlocked(gem_obj);
 861         return 0;
 862 }
 863
 864 int
 865 vc4_create_shader_bo_ioctl(struct drm_device *dev, void *data,
 866                            struct drm_file *file_priv)
 867 {
 868         struct drm_vc4_create_shader_bo *args = data;
 869         struct vc4_file *vc4file = file_priv->driver_priv;
 870         struct vc4_dev *vc4 = to_vc4_dev(dev);
 871         struct vc4_bo *bo = NULL;
 872         int ret;
 873
 874         if (args->size == 0)
 875                 return -EINVAL;
 876
 877         if (args->size % sizeof(u64) != 0)
 878                 return -EINVAL;
 879
 880         if (args->flags != 0) {
 881                 DRM_INFO("Unknown flags set: 0x%08x\n", args->flags);
 882                 return -EINVAL;
 883         }
 884
 885         if (args->pad != 0) {
 886                 DRM_INFO("Pad set: 0x%08x\n", args->pad);
 887                 return -EINVAL;
 888         }
 889
 890         ret = vc4_grab_bin_bo(vc4, vc4file);
 891         if (ret)
 892                 return ret;
 893
 894         bo = vc4_bo_create(dev, args->size, true, VC4_BO_TYPE_V3D_SHADER);
 895         if (IS_ERR(bo))
 896                 return PTR_ERR(bo);
 897
 898         bo->madv = VC4_MADV_WILLNEED;
 899
 900         if (copy_from_user(bo->base.vaddr,
 901                              (void __user *)(uintptr_t)args->data,
 902                              args->size)) {
 903                 ret = -EFAULT;
 904                 goto fail;
 905         }
 906         /* Clear the rest of the memory from allocating from the BO
 907          * cache.
 908          */
 909         memset(bo->base.vaddr + args->size, 0,
 910                bo->base.base.size - args->size);
 911
 912         bo->validated_shader = vc4_validate_shader(&bo->base);
 913         if (!bo->validated_shader) {
 914                 ret = -EINVAL;
 915                 goto fail;
 916         }
 917
 918         /* We have to create the handle after validation, to avoid
 919          * races for users to do doing things like mmap the shader BO.
 920          */
 921         ret = drm_gem_handle_create(file_priv, &bo->base.base, &args->handle);
 922
 923 fail:
 924         drm_gem_object_put_unlocked(&bo->base.base);
 925
 926         return ret;
 927 }
 928
 929 /**
 930  * vc4_set_tiling_ioctl() - Sets the tiling modifier for a BO.
 931  * @dev: DRM device
 932  * @data: ioctl argument
 933  * @file_priv: DRM file for this fd
 934  *
 935  * The tiling state of the BO decides the default modifier of an fb if
 936  * no specific modifier was set by userspace, and the return value of
 937  * vc4_get_tiling_ioctl() (so that userspace can treat a BO it
 938  * received from dmabuf as the same tiling format as the producer
 939  * used).
 940  */
 941 int vc4_set_tiling_ioctl(struct drm_device *dev, void *data,
 942                          struct drm_file *file_priv)
 943 {
 944         struct drm_vc4_set_tiling *args = data;
 945         struct drm_gem_object *gem_obj;
 946         struct vc4_bo *bo;
 947         bool t_format;
 948
 949         if (args->flags != 0)
 950                 return -EINVAL;
 951
 952         switch (args->modifier) {
 953         case DRM_FORMAT_MOD_NONE:
 954                 t_format = false;
 955                 break;
 956         case DRM_FORMAT_MOD_BROADCOM_VC4_T_TILED:
 957                 t_format = true;
 958                 break;
 959         default:
 960                 return -EINVAL;
 961         }
 962
 963         gem_obj = drm_gem_object_lookup(file_priv, args->handle);
 964         if (!gem_obj) {
 965                 DRM_DEBUG("Failed to look up GEM BO %d\n", args->handle);
 966                 return -ENOENT;
 967         }
 968         bo = to_vc4_bo(gem_obj);
 969         bo->t_format = t_format;
 970
 971         drm_gem_object_put_unlocked(gem_obj);
 972
 973         return 0;
 974 }
 975
 976 /**
 977  * vc4_get_tiling_ioctl() - Gets the tiling modifier for a BO.
 978  * @dev: DRM device
 979  * @data: ioctl argument
 980  * @file_priv: DRM file for this fd
 981  *
 982  * Returns the tiling modifier for a BO as set by vc4_set_tiling_ioctl().
 983  */
 984 int vc4_get_tiling_ioctl(struct drm_device *dev, void *data,
 985                          struct drm_file *file_priv)
 986 {
 987         struct drm_vc4_get_tiling *args = data;
 988         struct drm_gem_object *gem_obj;
 989         struct vc4_bo *bo;
 990
 991         if (args->flags != 0 || args->modifier != 0)
 992                 return -EINVAL;
 993
 994         gem_obj = drm_gem_object_lookup(file_priv, args->handle);
 995         if (!gem_obj) {
 996                 DRM_DEBUG("Failed to look up GEM BO %d\n", args->handle);
 997                 return -ENOENT;
 998         }
 999         bo = to_vc4_bo(gem_obj);
1000
1001         if (bo->t_format)
1002                 args->modifier = DRM_FORMAT_MOD_BROADCOM_VC4_T_TILED;
1003         else
1004                 args->modifier = DRM_FORMAT_MOD_NONE;
1005
1006         drm_gem_object_put_unlocked(gem_obj);
1007
1008         return 0;
1009 }
1010
1011 int vc4_bo_cache_init(struct drm_device *dev)
1012 {
1013         struct vc4_dev *vc4 = to_vc4_dev(dev);
1014         int i;
1015
1016         /* Create the initial set of BO labels that the kernel will
1017          * use.  This lets us avoid a bunch of string reallocation in
1018          * the kernel's draw and BO allocation paths.
1019          */
1020         vc4->bo_labels = kcalloc(VC4_BO_TYPE_COUNT, sizeof(*vc4->bo_labels),
1021                                  GFP_KERNEL);
1022         if (!vc4->bo_labels)
1023                 return -ENOMEM;
1024         vc4->num_labels = VC4_BO_TYPE_COUNT;
1025
1026         BUILD_BUG_ON(ARRAY_SIZE(bo_type_names) != VC4_BO_TYPE_COUNT);
1027         for (i = 0; i < VC4_BO_TYPE_COUNT; i++)
1028                 vc4->bo_labels[i].name = bo_type_names[i];
1029
1030         mutex_init(&vc4->bo_lock);
1031
1032         vc4_debugfs_add_file(dev, "bo_stats", vc4_bo_stats_debugfs, NULL);
1033
1034         INIT_LIST_HEAD(&vc4->bo_cache.time_list);
1035
1036         INIT_WORK(&vc4->bo_cache.time_work, vc4_bo_cache_time_work);
1037         timer_setup(&vc4->bo_cache.time_timer, vc4_bo_cache_time_timer, 0);
1038
1039         return 0;
1040 }
1041
1042 void vc4_bo_cache_destroy(struct drm_device *dev)
1043 {
1044         struct vc4_dev *vc4 = to_vc4_dev(dev);
1045         int i;
1046
1047         del_timer(&vc4->bo_cache.time_timer);
1048         cancel_work_sync(&vc4->bo_cache.time_work);
1049
1050         vc4_bo_cache_purge(dev);
1051
1052         for (i = 0; i < vc4->num_labels; i++) {
1053                 if (vc4->bo_labels[i].num_allocated) {
1054                         DRM_ERROR("Destroying BO cache with %d %s "
1055                                   "BOs still allocated\n",
1056                                   vc4->bo_labels[i].num_allocated,
1057                                   vc4->bo_labels[i].name);
1058                 }
1059
1060                 if (is_user_label(i))
1061                         kfree(vc4->bo_labels[i].name);
1062         }
1063         kfree(vc4->bo_labels);
1064 }
1065
1066 int vc4_label_bo_ioctl(struct drm_device *dev, void *data,
1067                        struct drm_file *file_priv)
1068 {
1069         struct vc4_dev *vc4 = to_vc4_dev(dev);
1070         struct drm_vc4_label_bo *args = data;
1071         char *name;
1072         struct drm_gem_object *gem_obj;
1073         int ret = 0, label;
1074
1075         if (!args->len)
1076                 return -EINVAL;
1077
1078         name = strndup_user(u64_to_user_ptr(args->name), args->len + 1);
1079         if (IS_ERR(name))
1080                 return PTR_ERR(name);
1081
1082         gem_obj = drm_gem_object_lookup(file_priv, args->handle);
1083         if (!gem_obj) {
1084                 DRM_ERROR("Failed to look up GEM BO %d\n", args->handle);
1085                 kfree(name);
1086                 return -ENOENT;
1087         }
1088
1089         mutex_lock(&vc4->bo_lock);
1090         label = vc4_get_user_label(vc4, name);
1091         if (label != -1)
1092                 vc4_bo_set_label(gem_obj, label);
1093         else
1094                 ret = -ENOMEM;
1095         mutex_unlock(&vc4->bo_lock);
1096
1097         drm_gem_object_put_unlocked(gem_obj);
1098
1099         return ret;
1100 }