mm/slob.c

   1 /*
   2  * SLOB Allocator: Simple List Of Blocks
   3  *
   4  * Matt Mackall <mpm@selenic.com> 12/30/03
   5  *
   6  * NUMA support by Paul Mundt, 2007.
   7  *
   8  * How SLOB works:
   9  *
  10  * The core of SLOB is a traditional K&R style heap allocator, with
  11  * support for returning aligned objects. The granularity of this
  12  * allocator is as little as 2 bytes, however typically most architectures
  13  * will require 4 bytes on 32-bit and 8 bytes on 64-bit.
  14  *
  15  * The slob heap is a set of linked list of pages from alloc_pages(),
  16  * and within each page, there is a singly-linked list of free blocks
  17  * (slob_t). The heap is grown on demand. To reduce fragmentation,
  18  * heap pages are segregated into three lists, with objects less than
  19  * 256 bytes, objects less than 1024 bytes, and all other objects.
  20  *
  21  * Allocation from heap involves first searching for a page with
  22  * sufficient free blocks (using a next-fit-like approach) followed by
  23  * a first-fit scan of the page. Deallocation inserts objects back
  24  * into the free list in address order, so this is effectively an
  25  * address-ordered first fit.
  26  *
  27  * Above this is an implementation of kmalloc/kfree. Blocks returned
  28  * from kmalloc are prepended with a 4-byte header with the kmalloc size.
  29  * If kmalloc is asked for objects of PAGE_SIZE or larger, it calls
  30  * alloc_pages() directly, allocating compound pages so the page order
  31  * does not have to be separately tracked.
  32  * These objects are detected in kfree() because PageSlab()
  33  * is false for them.
  34  *
  35  * SLAB is emulated on top of SLOB by simply calling constructors and
  36  * destructors for every SLAB allocation. Objects are returned with the
  37  * 4-byte alignment unless the SLAB_HWCACHE_ALIGN flag is set, in which
  38  * case the low-level allocator will fragment blocks to create the proper
  39  * alignment. Again, objects of page-size or greater are allocated by
  40  * calling alloc_pages(). As SLAB objects know their size, no separate
  41  * size bookkeeping is necessary and there is essentially no allocation
  42  * space overhead, and compound pages aren't needed for multi-page
  43  * allocations.
  44  *
  45  * NUMA support in SLOB is fairly simplistic, pushing most of the real
  46  * logic down to the page allocator, and simply doing the node accounting
  47  * on the upper levels. In the event that a node id is explicitly
  48  * provided, alloc_pages_exact_node() with the specified node id is used
  49  * instead. The common case (or when the node id isn't explicitly provided)
  50  * will default to the current node, as per numa_node_id().
  51  *
  52  * Node aware pages are still inserted in to the global freelist, and
  53  * these are scanned for by matching against the node id encoded in the
  54  * page flags. As a result, block allocations that can be satisfied from
  55  * the freelist will only be done so on pages residing on the same node,
  56  * in order to prevent random node placement.
  57  */
  58
  59 #include <linux/kernel.h>
  60 #include <linux/slab.h>
  61
  62 #include <linux/mm.h>
  63 #include <linux/swap.h> /* struct reclaim_state */
  64 #include <linux/cache.h>
  65 #include <linux/init.h>
  66 #include <linux/export.h>
  67 #include <linux/rcupdate.h>
  68 #include <linux/list.h>
  69 #include <linux/kmemleak.h>
  70
  71 #include <trace/events/kmem.h>
  72
  73 #include <linux/atomic.h>
  74
  75 #include "slab.h"
  76 /*
  77  * slob_block has a field 'units', which indicates size of block if +ve,
  78  * or offset of next block if -ve (in SLOB_UNITs).
  79  *
  80  * Free blocks of size 1 unit simply contain the offset of the next block.
  81  * Those with larger size contain their size in the first SLOB_UNIT of
  82  * memory, and the offset of the next free block in the second SLOB_UNIT.
  83  */
  84 #if PAGE_SIZE <= (32767 * 2)
  85 typedef s16 slobidx_t;
  86 #else
  87 typedef s32 slobidx_t;
  88 #endif
  89
  90 struct slob_block {
  91         slobidx_t units;
  92 };
  93 typedef struct slob_block slob_t;
  94
  95 /*
  96  * All partially free slob pages go on these lists.
  97  */
  98 #define SLOB_BREAK1 256
  99 #define SLOB_BREAK2 1024
 100 static LIST_HEAD(free_slob_small);
 101 static LIST_HEAD(free_slob_medium);
 102 static LIST_HEAD(free_slob_large);
 103
 104 /*
 105  * slob_page_free: true for pages on free_slob_pages list.
 106  */
 107 static inline int slob_page_free(struct page *sp)
 108 {
 109         return PageSlobFree(sp);
 110 }
 111
 112 static void set_slob_page_free(struct page *sp, struct list_head *list)
 113 {
 114         list_add(&sp->list, list);
 115         __SetPageSlobFree(sp);
 116 }
 117
 118 static inline void clear_slob_page_free(struct page *sp)
 119 {
 120         list_del(&sp->list);
 121         __ClearPageSlobFree(sp);
 122 }
 123
 124 #define SLOB_UNIT sizeof(slob_t)
 125 #define SLOB_UNITS(size) (((size) + SLOB_UNIT - 1)/SLOB_UNIT)
 126 #define SLOB_ALIGN L1_CACHE_BYTES
 127
 128 /*
 129  * struct slob_rcu is inserted at the tail of allocated slob blocks, which
 130  * were created with a SLAB_DESTROY_BY_RCU slab. slob_rcu is used to free
 131  * the block using call_rcu.
 132  */
 133 struct slob_rcu {
 134         struct rcu_head head;
 135         int size;
 136 };
 137
 138 /*
 139  * slob_lock protects all slob allocator structures.
 140  */
 141 static DEFINE_SPINLOCK(slob_lock);
 142
 143 /*
 144  * Encode the given size and next info into a free slob block s.
 145  */
 146 static void set_slob(slob_t *s, slobidx_t size, slob_t *next)
 147 {
 148         slob_t *base = (slob_t *)((unsigned long)s & PAGE_MASK);
 149         slobidx_t offset = next - base;
 150
 151         if (size > 1) {
 152                 s[0].units = size;
 153                 s[1].units = offset;
 154         } else
 155                 s[0].units = -offset;
 156 }
 157
 158 /*
 159  * Return the size of a slob block.
 160  */
 161 static slobidx_t slob_units(slob_t *s)
 162 {
 163         if (s->units > 0)
 164                 return s->units;
 165         return 1;
 166 }
 167
 168 /*
 169  * Return the next free slob block pointer after this one.
 170  */
 171 static slob_t *slob_next(slob_t *s)
 172 {
 173         slob_t *base = (slob_t *)((unsigned long)s & PAGE_MASK);
 174         slobidx_t next;
 175
 176         if (s[0].units < 0)
 177                 next = -s[0].units;
 178         else
 179                 next = s[1].units;
 180         return base+next;
 181 }
 182
 183 /*
 184  * Returns true if s is the last free block in its page.
 185  */
 186 static int slob_last(slob_t *s)
 187 {
 188         return !((unsigned long)slob_next(s) & ~PAGE_MASK);
 189 }
 190
 191 static void *slob_new_pages(gfp_t gfp, int order, int node)
 192 {
 193         void *page;
 194
 195 #ifdef CONFIG_NUMA
 196         if (node != NUMA_NO_NODE)
 197                 page = alloc_pages_exact_node(node, gfp, order);
 198         else
 199 #endif
 200                 page = alloc_pages(gfp, order);
 201
 202         if (!page)
 203                 return NULL;
 204
 205         return page_address(page);
 206 }
 207
 208 static void slob_free_pages(void *b, int order)
 209 {
 210         if (current->reclaim_state)
 211                 current->reclaim_state->reclaimed_slab += 1 << order;
 212         free_pages((unsigned long)b, order);
 213 }
 214
 215 /*
 216  * Allocate a slob block within a given slob_page sp.
 217  */
 218 static void *slob_page_alloc(struct page *sp, size_t size, int align)
 219 {
 220         slob_t *prev, *cur, *aligned = NULL;
 221         int delta = 0, units = SLOB_UNITS(size);
 222
 223         for (prev = NULL, cur = sp->freelist; ; prev = cur, cur = slob_next(cur)) {
 224                 slobidx_t avail = slob_units(cur);
 225
 226                 if (align) {
 227                         aligned = (slob_t *)ALIGN((unsigned long)cur, align);
 228                         delta = aligned - cur;
 229                 }
 230                 if (avail >= units + delta) { /* room enough? */
 231                         slob_t *next;
 232
 233                         if (delta) { /* need to fragment head to align? */
 234                                 next = slob_next(cur);
 235                                 set_slob(aligned, avail - delta, next);
 236                                 set_slob(cur, delta, aligned);
 237                                 prev = cur;
 238                                 cur = aligned;
 239                                 avail = slob_units(cur);
 240                         }
 241
 242                         next = slob_next(cur);
 243                         if (avail == units) { /* exact fit? unlink. */
 244                                 if (prev)
 245                                         set_slob(prev, slob_units(prev), next);
 246                                 else
 247                                         sp->freelist = next;
 248                         } else { /* fragment */
 249                                 if (prev)
 250                                         set_slob(prev, slob_units(prev), cur + units);
 251                                 else
 252                                         sp->freelist = cur + units;
 253                                 set_slob(cur + units, avail - units, next);
 254                         }
 255
 256                         sp->units -= units;
 257                         if (!sp->units)
 258                                 clear_slob_page_free(sp);
 259                         return cur;
 260                 }
 261                 if (slob_last(cur))
 262                         return NULL;
 263         }
 264 }
 265
 266 /*
 267  * slob_alloc: entry point into the slob allocator.
 268  */
 269 static void *slob_alloc(size_t size, gfp_t gfp, int align, int node)
 270 {
 271         struct page *sp;
 272         struct list_head *prev;
 273         struct list_head *slob_list;
 274         slob_t *b = NULL;
 275         unsigned long flags;
 276
 277         if (size < SLOB_BREAK1)
 278                 slob_list = &free_slob_small;
 279         else if (size < SLOB_BREAK2)
 280                 slob_list = &free_slob_medium;
 281         else
 282                 slob_list = &free_slob_large;
 283
 284         spin_lock_irqsave(&slob_lock, flags);
 285         /* Iterate through each partially free page, try to find room */
 286         list_for_each_entry(sp, slob_list, list) {
 287 #ifdef CONFIG_NUMA
 288                 /*
 289                  * If there's a node specification, search for a partial
 290                  * page with a matching node id in the freelist.
 291                  */
 292                 if (node != NUMA_NO_NODE && page_to_nid(sp) != node)
 293                         continue;
 294 #endif
 295                 /* Enough room on this page? */
 296                 if (sp->units < SLOB_UNITS(size))
 297                         continue;
 298
 299                 /* Attempt to alloc */
 300                 prev = sp->list.prev;
 301                 b = slob_page_alloc(sp, size, align);
 302                 if (!b)
 303                         continue;
 304
 305                 /* Improve fragment distribution and reduce our average
 306                  * search time by starting our next search here. (see
 307                  * Knuth vol 1, sec 2.5, pg 449) */
 308                 if (prev != slob_list->prev &&
 309                                 slob_list->next != prev->next)
 310                         list_move_tail(slob_list, prev->next);
 311                 break;
 312         }
 313         spin_unlock_irqrestore(&slob_lock, flags);
 314
 315         /* Not enough space: must allocate a new page */
 316         if (!b) {
 317                 b = slob_new_pages(gfp & ~__GFP_ZERO, 0, node);
 318                 if (!b)
 319                         return NULL;
 320                 sp = virt_to_page(b);
 321                 __SetPageSlab(sp);
 322
 323                 spin_lock_irqsave(&slob_lock, flags);
 324                 sp->units = SLOB_UNITS(PAGE_SIZE);
 325                 sp->freelist = b;
 326                 INIT_LIST_HEAD(&sp->list);
 327                 set_slob(b, SLOB_UNITS(PAGE_SIZE), b + SLOB_UNITS(PAGE_SIZE));
 328                 set_slob_page_free(sp, slob_list);
 329                 b = slob_page_alloc(sp, size, align);
 330                 BUG_ON(!b);
 331                 spin_unlock_irqrestore(&slob_lock, flags);
 332         }
 333         if (unlikely((gfp & __GFP_ZERO) && b))
 334                 memset(b, 0, size);
 335         return b;
 336 }
 337
 338 /*
 339  * slob_free: entry point into the slob allocator.
 340  */
 341 static void slob_free(void *block, int size)
 342 {
 343         struct page *sp;
 344         slob_t *prev, *next, *b = (slob_t *)block;
 345         slobidx_t units;
 346         unsigned long flags;
 347         struct list_head *slob_list;
 348
 349         if (unlikely(ZERO_OR_NULL_PTR(block)))
 350                 return;
 351         BUG_ON(!size);
 352
 353         sp = virt_to_page(block);
 354         units = SLOB_UNITS(size);
 355
 356         spin_lock_irqsave(&slob_lock, flags);
 357
 358         if (sp->units + units == SLOB_UNITS(PAGE_SIZE)) {
 359                 /* Go directly to page allocator. Do not pass slob allocator */
 360                 if (slob_page_free(sp))
 361                         clear_slob_page_free(sp);
 362                 spin_unlock_irqrestore(&slob_lock, flags);
 363                 __ClearPageSlab(sp);
 364                 reset_page_mapcount(sp);
 365                 slob_free_pages(b, 0);
 366                 return;
 367         }
 368
 369         if (!slob_page_free(sp)) {
 370                 /* This slob page is about to become partially free. Easy! */
 371                 sp->units = units;
 372                 sp->freelist = b;
 373                 set_slob(b, units,
 374                         (void *)((unsigned long)(b +
 375                                         SLOB_UNITS(PAGE_SIZE)) & PAGE_MASK));
 376                 if (size < SLOB_BREAK1)
 377                         slob_list = &free_slob_small;
 378                 else if (size < SLOB_BREAK2)
 379                         slob_list = &free_slob_medium;
 380                 else
 381                         slob_list = &free_slob_large;
 382                 set_slob_page_free(sp, slob_list);
 383                 goto out;
 384         }
 385
 386         /*
 387          * Otherwise the page is already partially free, so find reinsertion
 388          * point.
 389          */
 390         sp->units += units;
 391
 392         if (b < (slob_t *)sp->freelist) {
 393                 if (b + units == sp->freelist) {
 394                         units += slob_units(sp->freelist);
 395                         sp->freelist = slob_next(sp->freelist);
 396                 }
 397                 set_slob(b, units, sp->freelist);
 398                 sp->freelist = b;
 399         } else {
 400                 prev = sp->freelist;
 401                 next = slob_next(prev);
 402                 while (b > next) {
 403                         prev = next;
 404                         next = slob_next(prev);
 405                 }
 406
 407                 if (!slob_last(prev) && b + units == next) {
 408                         units += slob_units(next);
 409                         set_slob(b, units, slob_next(next));
 410                 } else
 411                         set_slob(b, units, next);
 412
 413                 if (prev + slob_units(prev) == b) {
 414                         units = slob_units(b) + slob_units(prev);
 415                         set_slob(prev, units, slob_next(b));
 416                 } else
 417                         set_slob(prev, slob_units(prev), b);
 418         }
 419 out:
 420         spin_unlock_irqrestore(&slob_lock, flags);
 421 }
 422
 423 /*
 424  * End of slob allocator proper. Begin kmem_cache_alloc and kmalloc frontend.
 425  */
 426
 427 static __always_inline void *
 428 __do_kmalloc_node(size_t size, gfp_t gfp, int node, unsigned long caller)
 429 {
 430         unsigned int *m;
 431         int align = max_t(size_t, ARCH_KMALLOC_MINALIGN, ARCH_SLAB_MINALIGN);
 432         void *ret;
 433
 434         gfp &= gfp_allowed_mask;
 435
 436         lockdep_trace_alloc(gfp);
 437
 438         if (size < PAGE_SIZE - align) {
 439                 if (!size)
 440                         return ZERO_SIZE_PTR;
 441
 442                 m = slob_alloc(size + align, gfp, align, node);
 443
 444                 if (!m)
 445                         return NULL;
 446                 *m = size;
 447                 ret = (void *)m + align;
 448
 449                 trace_kmalloc_node(caller, ret,
 450                                    size, size + align, gfp, node);
 451         } else {
 452                 unsigned int order = get_order(size);
 453
 454                 if (likely(order))
 455                         gfp |= __GFP_COMP;
 456                 ret = slob_new_pages(gfp, order, node);
 457
 458                 trace_kmalloc_node(caller, ret,
 459                                    size, PAGE_SIZE << order, gfp, node);
 460         }
 461
 462         kmemleak_alloc(ret, size, 1, gfp);
 463         return ret;
 464 }
 465
 466 void *__kmalloc_node(size_t size, gfp_t gfp, int node)
 467 {
 468         return __do_kmalloc_node(size, gfp, node, _RET_IP_);
 469 }
 470 EXPORT_SYMBOL(__kmalloc_node);
 471
 472 #ifdef CONFIG_TRACING
 473 void *__kmalloc_track_caller(size_t size, gfp_t gfp, unsigned long caller)
 474 {
 475         return __do_kmalloc_node(size, gfp, NUMA_NO_NODE, caller);
 476 }
 477
 478 #ifdef CONFIG_NUMA
 479 void *__kmalloc_node_track_caller(size_t size, gfp_t gfp,
 480                                         int node, unsigned long caller)
 481 {
 482         return __do_kmalloc_node(size, gfp, node, caller);
 483 }
 484 #endif
 485 #endif
 486
 487 void kfree(const void *block)
 488 {
 489         struct page *sp;
 490
 491         trace_kfree(_RET_IP_, block);
 492
 493         if (unlikely(ZERO_OR_NULL_PTR(block)))
 494                 return;
 495         kmemleak_free(block);
 496
 497         sp = virt_to_page(block);
 498         if (PageSlab(sp)) {
 499                 int align = max_t(size_t, ARCH_KMALLOC_MINALIGN, ARCH_SLAB_MINALIGN);
 500                 unsigned int *m = (unsigned int *)(block - align);
 501                 slob_free(m, *m + align);
 502         } else
 503                 __free_pages(sp, compound_order(sp));
 504 }
 505 EXPORT_SYMBOL(kfree);
 506
 507 /* can't use ksize for kmem_cache_alloc memory, only kmalloc */
 508 size_t ksize(const void *block)
 509 {
 510         struct page *sp;
 511         int align;
 512         unsigned int *m;
 513
 514         BUG_ON(!block);
 515         if (unlikely(block == ZERO_SIZE_PTR))
 516                 return 0;
 517
 518         sp = virt_to_page(block);
 519         if (unlikely(!PageSlab(sp)))
 520                 return PAGE_SIZE << compound_order(sp);
 521
 522         align = max_t(size_t, ARCH_KMALLOC_MINALIGN, ARCH_SLAB_MINALIGN);
 523         m = (unsigned int *)(block - align);
 524         return SLOB_UNITS(*m) * SLOB_UNIT;
 525 }
 526 EXPORT_SYMBOL(ksize);
 527
 528 int __kmem_cache_create(struct kmem_cache *c, unsigned long flags)
 529 {
 530         size_t align = c->size;
 531
 532         if (flags & SLAB_DESTROY_BY_RCU) {
 533                 /* leave room for rcu footer at the end of object */
 534                 c->size += sizeof(struct slob_rcu);
 535         }
 536         c->flags = flags;
 537         /* ignore alignment unless it's forced */
 538         c->align = (flags & SLAB_HWCACHE_ALIGN) ? SLOB_ALIGN : 0;
 539         if (c->align < ARCH_SLAB_MINALIGN)
 540                 c->align = ARCH_SLAB_MINALIGN;
 541         if (c->align < align)
 542                 c->align = align;
 543
 544         return 0;
 545 }
 546
 547 void *kmem_cache_alloc_node(struct kmem_cache *c, gfp_t flags, int node)
 548 {
 549         void *b;
 550
 551         flags &= gfp_allowed_mask;
 552
 553         lockdep_trace_alloc(flags);
 554
 555         if (c->size < PAGE_SIZE) {
 556                 b = slob_alloc(c->size, flags, c->align, node);
 557                 trace_kmem_cache_alloc_node(_RET_IP_, b, c->object_size,
 558                                             SLOB_UNITS(c->size) * SLOB_UNIT,
 559                                             flags, node);
 560         } else {
 561                 b = slob_new_pages(flags, get_order(c->size), node);
 562                 trace_kmem_cache_alloc_node(_RET_IP_, b, c->object_size,
 563                                             PAGE_SIZE << get_order(c->size),
 564                                             flags, node);
 565         }
 566
 567         if (c->ctor)
 568                 c->ctor(b);
 569
 570         kmemleak_alloc_recursive(b, c->size, 1, c->flags, flags);
 571         return b;
 572 }
 573 EXPORT_SYMBOL(kmem_cache_alloc_node);
 574
 575 static void __kmem_cache_free(void *b, int size)
 576 {
 577         if (size < PAGE_SIZE)
 578                 slob_free(b, size);
 579         else
 580                 slob_free_pages(b, get_order(size));
 581 }
 582
 583 static void kmem_rcu_free(struct rcu_head *head)
 584 {
 585         struct slob_rcu *slob_rcu = (struct slob_rcu *)head;
 586         void *b = (void *)slob_rcu - (slob_rcu->size - sizeof(struct slob_rcu));
 587
 588         __kmem_cache_free(b, slob_rcu->size);
 589 }
 590
 591 void kmem_cache_free(struct kmem_cache *c, void *b)
 592 {
 593         kmemleak_free_recursive(b, c->flags);
 594         if (unlikely(c->flags & SLAB_DESTROY_BY_RCU)) {
 595                 struct slob_rcu *slob_rcu;
 596                 slob_rcu = b + (c->size - sizeof(struct slob_rcu));
 597                 slob_rcu->size = c->size;
 598                 call_rcu(&slob_rcu->head, kmem_rcu_free);
 599         } else {
 600                 __kmem_cache_free(b, c->size);
 601         }
 602
 603         trace_kmem_cache_free(_RET_IP_, b);
 604 }
 605 EXPORT_SYMBOL(kmem_cache_free);
 606
 607 int __kmem_cache_shutdown(struct kmem_cache *c)
 608 {
 609         /* No way to check for remaining objects */
 610         return 0;
 611 }
 612
 613 int kmem_cache_shrink(struct kmem_cache *d)
 614 {
 615         return 0;
 616 }
 617 EXPORT_SYMBOL(kmem_cache_shrink);
 618
 619 struct kmem_cache kmem_cache_boot = {
 620         .name = "kmem_cache",
 621         .size = sizeof(struct kmem_cache),
 622         .flags = SLAB_PANIC,
 623         .align = ARCH_KMALLOC_MINALIGN,
 624 };
 625
 626 void __init kmem_cache_init(void)
 627 {
 628         kmem_cache = &kmem_cache_boot;
 629         slab_state = UP;
 630 }
 631
 632 void __init kmem_cache_init_late(void)
 633 {
 634         slab_state = FULL;
 635 }