drivers/gpu/drm/drm_buddy.c

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * Copyright © 2021 Intel Corporation
   4  */
   5
   6 #include <linux/kmemleak.h>
   7 #include <linux/module.h>
   8 #include <linux/sizes.h>
   9
  10 #include <drm/drm_buddy.h>
  11
  12 static struct kmem_cache *slab_blocks;
  13
  14 static struct drm_buddy_block *drm_block_alloc(struct drm_buddy *mm,
  15                                                struct drm_buddy_block *parent,
  16                                                unsigned int order,
  17                                                u64 offset)
  18 {
  19         struct drm_buddy_block *block;
  20
  21         BUG_ON(order > DRM_BUDDY_MAX_ORDER);
  22
  23         block = kmem_cache_zalloc(slab_blocks, GFP_KERNEL);
  24         if (!block)
  25                 return NULL;
  26
  27         block->header = offset;
  28         block->header |= order;
  29         block->parent = parent;
  30
  31         BUG_ON(block->header & DRM_BUDDY_HEADER_UNUSED);
  32         return block;
  33 }
  34
  35 static void drm_block_free(struct drm_buddy *mm,
  36                            struct drm_buddy_block *block)
  37 {
  38         kmem_cache_free(slab_blocks, block);
  39 }
  40
  41 static void mark_allocated(struct drm_buddy_block *block)
  42 {
  43         block->header &= ~DRM_BUDDY_HEADER_STATE;
  44         block->header |= DRM_BUDDY_ALLOCATED;
  45
  46         list_del(&block->link);
  47 }
  48
  49 static void mark_free(struct drm_buddy *mm,
  50                       struct drm_buddy_block *block)
  51 {
  52         block->header &= ~DRM_BUDDY_HEADER_STATE;
  53         block->header |= DRM_BUDDY_FREE;
  54
  55         list_add(&block->link,
  56                  &mm->free_list[drm_buddy_block_order(block)]);
  57 }
  58
  59 static void mark_split(struct drm_buddy_block *block)
  60 {
  61         block->header &= ~DRM_BUDDY_HEADER_STATE;
  62         block->header |= DRM_BUDDY_SPLIT;
  63
  64         list_del(&block->link);
  65 }
  66
  67 /**
  68  * drm_buddy_init - init memory manager
  69  *
  70  * @mm: DRM buddy manager to initialize
  71  * @size: size in bytes to manage
  72  * @chunk_size: minimum page size in bytes for our allocations
  73  *
  74  * Initializes the memory manager and its resources.
  75  *
  76  * Returns:
  77  * 0 on success, error code on failure.
  78  */
  79 int drm_buddy_init(struct drm_buddy *mm, u64 size, u64 chunk_size)
  80 {
  81         unsigned int i;
  82         u64 offset;
  83
  84         if (size < chunk_size)
  85                 return -EINVAL;
  86
  87         if (chunk_size < PAGE_SIZE)
  88                 return -EINVAL;
  89
  90         if (!is_power_of_2(chunk_size))
  91                 return -EINVAL;
  92
  93         size = round_down(size, chunk_size);
  94
  95         mm->size = size;
  96         mm->avail = size;
  97         mm->chunk_size = chunk_size;
  98         mm->max_order = ilog2(size) - ilog2(chunk_size);
  99
 100         BUG_ON(mm->max_order > DRM_BUDDY_MAX_ORDER);
 101
 102         mm->free_list = kmalloc_array(mm->max_order + 1,
 103                                       sizeof(struct list_head),
 104                                       GFP_KERNEL);
 105         if (!mm->free_list)
 106                 return -ENOMEM;
 107
 108         for (i = 0; i <= mm->max_order; ++i)
 109                 INIT_LIST_HEAD(&mm->free_list[i]);
 110
 111         mm->n_roots = hweight64(size);
 112
 113         mm->roots = kmalloc_array(mm->n_roots,
 114                                   sizeof(struct drm_buddy_block *),
 115                                   GFP_KERNEL);
 116         if (!mm->roots)
 117                 goto out_free_list;
 118
 119         offset = 0;
 120         i = 0;
 121
 122         /*
 123          * Split into power-of-two blocks, in case we are given a size that is
 124          * not itself a power-of-two.
 125          */
 126         do {
 127                 struct drm_buddy_block *root;
 128                 unsigned int order;
 129                 u64 root_size;
 130
 131                 root_size = rounddown_pow_of_two(size);
 132                 order = ilog2(root_size) - ilog2(chunk_size);
 133
 134                 root = drm_block_alloc(mm, NULL, order, offset);
 135                 if (!root)
 136                         goto out_free_roots;
 137
 138                 mark_free(mm, root);
 139
 140                 BUG_ON(i > mm->max_order);
 141                 BUG_ON(drm_buddy_block_size(mm, root) < chunk_size);
 142
 143                 mm->roots[i] = root;
 144
 145                 offset += root_size;
 146                 size -= root_size;
 147                 i++;
 148         } while (size);
 149
 150         return 0;
 151
 152 out_free_roots:
 153         while (i--)
 154                 drm_block_free(mm, mm->roots[i]);
 155         kfree(mm->roots);
 156 out_free_list:
 157         kfree(mm->free_list);
 158         return -ENOMEM;
 159 }
 160 EXPORT_SYMBOL(drm_buddy_init);
 161
 162 /**
 163  * drm_buddy_fini - tear down the memory manager
 164  *
 165  * @mm: DRM buddy manager to free
 166  *
 167  * Cleanup memory manager resources and the freelist
 168  */
 169 void drm_buddy_fini(struct drm_buddy *mm)
 170 {
 171         int i;
 172
 173         for (i = 0; i < mm->n_roots; ++i) {
 174                 WARN_ON(!drm_buddy_block_is_free(mm->roots[i]));
 175                 drm_block_free(mm, mm->roots[i]);
 176         }
 177
 178         WARN_ON(mm->avail != mm->size);
 179
 180         kfree(mm->roots);
 181         kfree(mm->free_list);
 182 }
 183 EXPORT_SYMBOL(drm_buddy_fini);
 184
 185 static int split_block(struct drm_buddy *mm,
 186                        struct drm_buddy_block *block)
 187 {
 188         unsigned int block_order = drm_buddy_block_order(block) - 1;
 189         u64 offset = drm_buddy_block_offset(block);
 190
 191         BUG_ON(!drm_buddy_block_is_free(block));
 192         BUG_ON(!drm_buddy_block_order(block));
 193
 194         block->left = drm_block_alloc(mm, block, block_order, offset);
 195         if (!block->left)
 196                 return -ENOMEM;
 197
 198         block->right = drm_block_alloc(mm, block, block_order,
 199                                        offset + (mm->chunk_size << block_order));
 200         if (!block->right) {
 201                 drm_block_free(mm, block->left);
 202                 return -ENOMEM;
 203         }
 204
 205         mark_free(mm, block->left);
 206         mark_free(mm, block->right);
 207
 208         mark_split(block);
 209
 210         return 0;
 211 }
 212
 213 static struct drm_buddy_block *
 214 __get_buddy(struct drm_buddy_block *block)
 215 {
 216         struct drm_buddy_block *parent;
 217
 218         parent = block->parent;
 219         if (!parent)
 220                 return NULL;
 221
 222         if (parent->left == block)
 223                 return parent->right;
 224
 225         return parent->left;
 226 }
 227
 228 /**
 229  * drm_get_buddy - get buddy address
 230  *
 231  * @block: DRM buddy block
 232  *
 233  * Returns the corresponding buddy block for @block, or NULL
 234  * if this is a root block and can't be merged further.
 235  * Requires some kind of locking to protect against
 236  * any concurrent allocate and free operations.
 237  */
 238 struct drm_buddy_block *
 239 drm_get_buddy(struct drm_buddy_block *block)
 240 {
 241         return __get_buddy(block);
 242 }
 243 EXPORT_SYMBOL(drm_get_buddy);
 244
 245 static void __drm_buddy_free(struct drm_buddy *mm,
 246                              struct drm_buddy_block *block)
 247 {
 248         struct drm_buddy_block *parent;
 249
 250         while ((parent = block->parent)) {
 251                 struct drm_buddy_block *buddy;
 252
 253                 buddy = __get_buddy(block);
 254
 255                 if (!drm_buddy_block_is_free(buddy))
 256                         break;
 257
 258                 list_del(&buddy->link);
 259
 260                 drm_block_free(mm, block);
 261                 drm_block_free(mm, buddy);
 262
 263                 block = parent;
 264         }
 265
 266         mark_free(mm, block);
 267 }
 268
 269 /**
 270  * drm_buddy_free_block - free a block
 271  *
 272  * @mm: DRM buddy manager
 273  * @block: block to be freed
 274  */
 275 void drm_buddy_free_block(struct drm_buddy *mm,
 276                           struct drm_buddy_block *block)
 277 {
 278         BUG_ON(!drm_buddy_block_is_allocated(block));
 279         mm->avail += drm_buddy_block_size(mm, block);
 280         __drm_buddy_free(mm, block);
 281 }
 282 EXPORT_SYMBOL(drm_buddy_free_block);
 283
 284 /**
 285  * drm_buddy_free_list - free blocks
 286  *
 287  * @mm: DRM buddy manager
 288  * @objects: input list head to free blocks
 289  */
 290 void drm_buddy_free_list(struct drm_buddy *mm, struct list_head *objects)
 291 {
 292         struct drm_buddy_block *block, *on;
 293
 294         list_for_each_entry_safe(block, on, objects, link) {
 295                 drm_buddy_free_block(mm, block);
 296                 cond_resched();
 297         }
 298         INIT_LIST_HEAD(objects);
 299 }
 300 EXPORT_SYMBOL(drm_buddy_free_list);
 301
 302 static inline bool overlaps(u64 s1, u64 e1, u64 s2, u64 e2)
 303 {
 304         return s1 <= e2 && e1 >= s2;
 305 }
 306
 307 static inline bool contains(u64 s1, u64 e1, u64 s2, u64 e2)
 308 {
 309         return s1 <= s2 && e1 >= e2;
 310 }
 311
 312 static struct drm_buddy_block *
 313 alloc_range_bias(struct drm_buddy *mm,
 314                  u64 start, u64 end,
 315                  unsigned int order)
 316 {
 317         struct drm_buddy_block *block;
 318         struct drm_buddy_block *buddy;
 319         LIST_HEAD(dfs);
 320         int err;
 321         int i;
 322
 323         end = end - 1;
 324
 325         for (i = 0; i < mm->n_roots; ++i)
 326                 list_add_tail(&mm->roots[i]->tmp_link, &dfs);
 327
 328         do {
 329                 u64 block_start;
 330                 u64 block_end;
 331
 332                 block = list_first_entry_or_null(&dfs,
 333                                                  struct drm_buddy_block,
 334                                                  tmp_link);
 335                 if (!block)
 336                         break;
 337
 338                 list_del(&block->tmp_link);
 339
 340                 if (drm_buddy_block_order(block) < order)
 341                         continue;
 342
 343                 block_start = drm_buddy_block_offset(block);
 344                 block_end = block_start + drm_buddy_block_size(mm, block) - 1;
 345
 346                 if (!overlaps(start, end, block_start, block_end))
 347                         continue;
 348
 349                 if (drm_buddy_block_is_allocated(block))
 350                         continue;
 351
 352                 if (contains(start, end, block_start, block_end) &&
 353                     order == drm_buddy_block_order(block)) {
 354                         /*
 355                          * Find the free block within the range.
 356                          */
 357                         if (drm_buddy_block_is_free(block))
 358                                 return block;
 359
 360                         continue;
 361                 }
 362
 363                 if (!drm_buddy_block_is_split(block)) {
 364                         err = split_block(mm, block);
 365                         if (unlikely(err))
 366                                 goto err_undo;
 367                 }
 368
 369                 list_add(&block->right->tmp_link, &dfs);
 370                 list_add(&block->left->tmp_link, &dfs);
 371         } while (1);
 372
 373         return ERR_PTR(-ENOSPC);
 374
 375 err_undo:
 376         /*
 377          * We really don't want to leave around a bunch of split blocks, since
 378          * bigger is better, so make sure we merge everything back before we
 379          * free the allocated blocks.
 380          */
 381         buddy = __get_buddy(block);
 382         if (buddy &&
 383             (drm_buddy_block_is_free(block) &&
 384              drm_buddy_block_is_free(buddy)))
 385                 __drm_buddy_free(mm, block);
 386         return ERR_PTR(err);
 387 }
 388
 389 static struct drm_buddy_block *
 390 get_maxblock(struct list_head *head)
 391 {
 392         struct drm_buddy_block *max_block = NULL, *node;
 393
 394         max_block = list_first_entry_or_null(head,
 395                                              struct drm_buddy_block,
 396                                              link);
 397         if (!max_block)
 398                 return NULL;
 399
 400         list_for_each_entry(node, head, link) {
 401                 if (drm_buddy_block_offset(node) >
 402                     drm_buddy_block_offset(max_block))
 403                         max_block = node;
 404         }
 405
 406         return max_block;
 407 }
 408
 409 static struct drm_buddy_block *
 410 alloc_from_freelist(struct drm_buddy *mm,
 411                     unsigned int order,
 412                     unsigned long flags)
 413 {
 414         struct drm_buddy_block *block = NULL;
 415         unsigned int i;
 416         int err;
 417
 418         for (i = order; i <= mm->max_order; ++i) {
 419                 if (flags & DRM_BUDDY_TOPDOWN_ALLOCATION) {
 420                         block = get_maxblock(&mm->free_list[i]);
 421                         if (block)
 422                                 break;
 423                 } else {
 424                         block = list_first_entry_or_null(&mm->free_list[i],
 425                                                          struct drm_buddy_block,
 426                                                          link);
 427                         if (block)
 428                                 break;
 429                 }
 430         }
 431
 432         if (!block)
 433                 return ERR_PTR(-ENOSPC);
 434
 435         BUG_ON(!drm_buddy_block_is_free(block));
 436
 437         while (i != order) {
 438                 err = split_block(mm, block);
 439                 if (unlikely(err))
 440                         goto err_undo;
 441
 442                 block = block->right;
 443                 i--;
 444         }
 445         return block;
 446
 447 err_undo:
 448         if (i != order)
 449                 __drm_buddy_free(mm, block);
 450         return ERR_PTR(err);
 451 }
 452
 453 static int __alloc_range(struct drm_buddy *mm,
 454                          struct list_head *dfs,
 455                          u64 start, u64 size,
 456                          struct list_head *blocks)
 457 {
 458         struct drm_buddy_block *block;
 459         struct drm_buddy_block *buddy;
 460         LIST_HEAD(allocated);
 461         u64 end;
 462         int err;
 463
 464         end = start + size - 1;
 465
 466         do {
 467                 u64 block_start;
 468                 u64 block_end;
 469
 470                 block = list_first_entry_or_null(dfs,
 471                                                  struct drm_buddy_block,
 472                                                  tmp_link);
 473                 if (!block)
 474                         break;
 475
 476                 list_del(&block->tmp_link);
 477
 478                 block_start = drm_buddy_block_offset(block);
 479                 block_end = block_start + drm_buddy_block_size(mm, block) - 1;
 480
 481                 if (!overlaps(start, end, block_start, block_end))
 482                         continue;
 483
 484                 if (drm_buddy_block_is_allocated(block)) {
 485                         err = -ENOSPC;
 486                         goto err_free;
 487                 }
 488
 489                 if (contains(start, end, block_start, block_end)) {
 490                         if (!drm_buddy_block_is_free(block)) {
 491                                 err = -ENOSPC;
 492                                 goto err_free;
 493                         }
 494
 495                         mark_allocated(block);
 496                         mm->avail -= drm_buddy_block_size(mm, block);
 497                         list_add_tail(&block->link, &allocated);
 498                         continue;
 499                 }
 500
 501                 if (!drm_buddy_block_is_split(block)) {
 502                         err = split_block(mm, block);
 503                         if (unlikely(err))
 504                                 goto err_undo;
 505                 }
 506
 507                 list_add(&block->right->tmp_link, dfs);
 508                 list_add(&block->left->tmp_link, dfs);
 509         } while (1);
 510
 511         list_splice_tail(&allocated, blocks);
 512         return 0;
 513
 514 err_undo:
 515         /*
 516          * We really don't want to leave around a bunch of split blocks, since
 517          * bigger is better, so make sure we merge everything back before we
 518          * free the allocated blocks.
 519          */
 520         buddy = __get_buddy(block);
 521         if (buddy &&
 522             (drm_buddy_block_is_free(block) &&
 523              drm_buddy_block_is_free(buddy)))
 524                 __drm_buddy_free(mm, block);
 525
 526 err_free:
 527         drm_buddy_free_list(mm, &allocated);
 528         return err;
 529 }
 530
 531 static int __drm_buddy_alloc_range(struct drm_buddy *mm,
 532                                    u64 start,
 533                                    u64 size,
 534                                    struct list_head *blocks)
 535 {
 536         LIST_HEAD(dfs);
 537         int i;
 538
 539         for (i = 0; i < mm->n_roots; ++i)
 540                 list_add_tail(&mm->roots[i]->tmp_link, &dfs);
 541
 542         return __alloc_range(mm, &dfs, start, size, blocks);
 543 }
 544
 545 /**
 546  * drm_buddy_block_trim - free unused pages
 547  *
 548  * @mm: DRM buddy manager
 549  * @new_size: original size requested
 550  * @blocks: Input and output list of allocated blocks.
 551  * MUST contain single block as input to be trimmed.
 552  * On success will contain the newly allocated blocks
 553  * making up the @new_size. Blocks always appear in
 554  * ascending order
 555  *
 556  * For contiguous allocation, we round up the size to the nearest
 557  * power of two value, drivers consume *actual* size, so remaining
 558  * portions are unused and can be optionally freed with this function
 559  *
 560  * Returns:
 561  * 0 on success, error code on failure.
 562  */
 563 int drm_buddy_block_trim(struct drm_buddy *mm,
 564                          u64 new_size,
 565                          struct list_head *blocks)
 566 {
 567         struct drm_buddy_block *parent;
 568         struct drm_buddy_block *block;
 569         LIST_HEAD(dfs);
 570         u64 new_start;
 571         int err;
 572
 573         if (!list_is_singular(blocks))
 574                 return -EINVAL;
 575
 576         block = list_first_entry(blocks,
 577                                  struct drm_buddy_block,
 578                                  link);
 579
 580         if (WARN_ON(!drm_buddy_block_is_allocated(block)))
 581                 return -EINVAL;
 582
 583         if (new_size > drm_buddy_block_size(mm, block))
 584                 return -EINVAL;
 585
 586         if (!new_size || !IS_ALIGNED(new_size, mm->chunk_size))
 587                 return -EINVAL;
 588
 589         if (new_size == drm_buddy_block_size(mm, block))
 590                 return 0;
 591
 592         list_del(&block->link);
 593         mark_free(mm, block);
 594         mm->avail += drm_buddy_block_size(mm, block);
 595
 596         /* Prevent recursively freeing this node */
 597         parent = block->parent;
 598         block->parent = NULL;
 599
 600         new_start = drm_buddy_block_offset(block);
 601         list_add(&block->tmp_link, &dfs);
 602         err =  __alloc_range(mm, &dfs, new_start, new_size, blocks);
 603         if (err) {
 604                 mark_allocated(block);
 605                 mm->avail -= drm_buddy_block_size(mm, block);
 606                 list_add(&block->link, blocks);
 607         }
 608
 609         block->parent = parent;
 610         return err;
 611 }
 612 EXPORT_SYMBOL(drm_buddy_block_trim);
 613
 614 /**
 615  * drm_buddy_alloc_blocks - allocate power-of-two blocks
 616  *
 617  * @mm: DRM buddy manager to allocate from
 618  * @start: start of the allowed range for this block
 619  * @end: end of the allowed range for this block
 620  * @size: size of the allocation
 621  * @min_page_size: alignment of the allocation
 622  * @blocks: output list head to add allocated blocks
 623  * @flags: DRM_BUDDY_*_ALLOCATION flags
 624  *
 625  * alloc_range_bias() called on range limitations, which traverses
 626  * the tree and returns the desired block.
 627  *
 628  * alloc_from_freelist() called when *no* range restrictions
 629  * are enforced, which picks the block from the freelist.
 630  *
 631  * Returns:
 632  * 0 on success, error code on failure.
 633  */
 634 int drm_buddy_alloc_blocks(struct drm_buddy *mm,
 635                            u64 start, u64 end, u64 size,
 636                            u64 min_page_size,
 637                            struct list_head *blocks,
 638                            unsigned long flags)
 639 {
 640         struct drm_buddy_block *block = NULL;
 641         unsigned int min_order, order;
 642         unsigned long pages;
 643         LIST_HEAD(allocated);
 644         int err;
 645
 646         if (size < mm->chunk_size)
 647                 return -EINVAL;
 648
 649         if (min_page_size < mm->chunk_size)
 650                 return -EINVAL;
 651
 652         if (!is_power_of_2(min_page_size))
 653                 return -EINVAL;
 654
 655         if (!IS_ALIGNED(start | end | size, mm->chunk_size))
 656                 return -EINVAL;
 657
 658         if (end > mm->size)
 659                 return -EINVAL;
 660
 661         if (range_overflows(start, size, mm->size))
 662                 return -EINVAL;
 663
 664         /* Actual range allocation */
 665         if (start + size == end)
 666                 return __drm_buddy_alloc_range(mm, start, size, blocks);
 667
 668         if (!IS_ALIGNED(size, min_page_size))
 669                 return -EINVAL;
 670
 671         pages = size >> ilog2(mm->chunk_size);
 672         order = fls(pages) - 1;
 673         min_order = ilog2(min_page_size) - ilog2(mm->chunk_size);
 674
 675         do {
 676                 order = min(order, (unsigned int)fls(pages) - 1);
 677                 BUG_ON(order > mm->max_order);
 678                 BUG_ON(order < min_order);
 679
 680                 do {
 681                         if (flags & DRM_BUDDY_RANGE_ALLOCATION)
 682                                 /* Allocate traversing within the range */
 683                                 block = alloc_range_bias(mm, start, end, order);
 684                         else
 685                                 /* Allocate from freelist */
 686                                 block = alloc_from_freelist(mm, order, flags);
 687
 688                         if (!IS_ERR(block))
 689                                 break;
 690
 691                         if (order-- == min_order) {
 692                                 err = -ENOSPC;
 693                                 goto err_free;
 694                         }
 695                 } while (1);
 696
 697                 mark_allocated(block);
 698                 mm->avail -= drm_buddy_block_size(mm, block);
 699                 kmemleak_update_trace(block);
 700                 list_add_tail(&block->link, &allocated);
 701
 702                 pages -= BIT(order);
 703
 704                 if (!pages)
 705                         break;
 706         } while (1);
 707
 708         list_splice_tail(&allocated, blocks);
 709         return 0;
 710
 711 err_free:
 712         drm_buddy_free_list(mm, &allocated);
 713         return err;
 714 }
 715 EXPORT_SYMBOL(drm_buddy_alloc_blocks);
 716
 717 /**
 718  * drm_buddy_block_print - print block information
 719  *
 720  * @mm: DRM buddy manager
 721  * @block: DRM buddy block
 722  * @p: DRM printer to use
 723  */
 724 void drm_buddy_block_print(struct drm_buddy *mm,
 725                            struct drm_buddy_block *block,
 726                            struct drm_printer *p)
 727 {
 728         u64 start = drm_buddy_block_offset(block);
 729         u64 size = drm_buddy_block_size(mm, block);
 730
 731         drm_printf(p, "%#018llx-%#018llx: %llu\n", start, start + size, size);
 732 }
 733 EXPORT_SYMBOL(drm_buddy_block_print);
 734
 735 /**
 736  * drm_buddy_print - print allocator state
 737  *
 738  * @mm: DRM buddy manager
 739  * @p: DRM printer to use
 740  */
 741 void drm_buddy_print(struct drm_buddy *mm, struct drm_printer *p)
 742 {
 743         int order;
 744
 745         drm_printf(p, "chunk_size: %lluKiB, total: %lluMiB, free: %lluMiB\n",
 746                    mm->chunk_size >> 10, mm->size >> 20, mm->avail >> 20);
 747
 748         for (order = mm->max_order; order >= 0; order--) {
 749                 struct drm_buddy_block *block;
 750                 u64 count = 0, free;
 751
 752                 list_for_each_entry(block, &mm->free_list[order], link) {
 753                         BUG_ON(!drm_buddy_block_is_free(block));
 754                         count++;
 755                 }
 756
 757                 drm_printf(p, "order-%d ", order);
 758
 759                 free = count * (mm->chunk_size << order);
 760                 if (free < SZ_1M)
 761                         drm_printf(p, "free: %lluKiB", free >> 10);
 762                 else
 763                         drm_printf(p, "free: %lluMiB", free >> 20);
 764
 765                 drm_printf(p, ", pages: %llu\n", count);
 766         }
 767 }
 768 EXPORT_SYMBOL(drm_buddy_print);
 769
 770 static void drm_buddy_module_exit(void)
 771 {
 772         kmem_cache_destroy(slab_blocks);
 773 }
 774
 775 static int __init drm_buddy_module_init(void)
 776 {
 777         slab_blocks = KMEM_CACHE(drm_buddy_block, 0);
 778         if (!slab_blocks)
 779                 return -ENOMEM;
 780
 781         return 0;
 782 }
 783
 784 module_init(drm_buddy_module_init);
 785 module_exit(drm_buddy_module_exit);
 786
 787 MODULE_DESCRIPTION("DRM Buddy Allocator");
 788 MODULE_LICENSE("Dual MIT/GPL");