slub.c 125.7 KB
Newer Older
C
Christoph Lameter 已提交
1 2 3 4
/*
 * SLUB: A slab allocator that limits cache line use instead of queuing
 * objects in per cpu and per node lists.
 *
5 6
 * The allocator synchronizes using per slab locks or atomic operatios
 * and only uses a centralized lock to manage a pool of partial slabs.
C
Christoph Lameter 已提交
7
 *
C
Christoph Lameter 已提交
8
 * (C) 2007 SGI, Christoph Lameter
9
 * (C) 2011 Linux Foundation, Christoph Lameter
C
Christoph Lameter 已提交
10 11 12
 */

#include <linux/mm.h>
N
Nick Piggin 已提交
13
#include <linux/swap.h> /* struct reclaim_state */
C
Christoph Lameter 已提交
14 15 16 17 18
#include <linux/module.h>
#include <linux/bit_spinlock.h>
#include <linux/interrupt.h>
#include <linux/bitops.h>
#include <linux/slab.h>
19
#include "slab.h"
20
#include <linux/proc_fs.h>
C
Christoph Lameter 已提交
21
#include <linux/seq_file.h>
V
Vegard Nossum 已提交
22
#include <linux/kmemcheck.h>
C
Christoph Lameter 已提交
23 24 25 26
#include <linux/cpu.h>
#include <linux/cpuset.h>
#include <linux/mempolicy.h>
#include <linux/ctype.h>
27
#include <linux/debugobjects.h>
C
Christoph Lameter 已提交
28
#include <linux/kallsyms.h>
29
#include <linux/memory.h>
R
Roman Zippel 已提交
30
#include <linux/math64.h>
A
Akinobu Mita 已提交
31
#include <linux/fault-inject.h>
32
#include <linux/stacktrace.h>
33
#include <linux/prefetch.h>
34
#include <linux/memcontrol.h>
C
Christoph Lameter 已提交
35

36 37
#include <trace/events/kmem.h>

38 39
#include "internal.h"

C
Christoph Lameter 已提交
40 41
/*
 * Lock order:
42
 *   1. slab_mutex (Global Mutex)
43 44
 *   2. node->list_lock
 *   3. slab_lock(page) (Only on some arches and for debugging)
C
Christoph Lameter 已提交
45
 *
46
 *   slab_mutex
47
 *
48
 *   The role of the slab_mutex is to protect the list of all the slabs
49 50 51 52 53 54 55 56 57 58 59 60 61 62
 *   and to synchronize major metadata changes to slab cache structures.
 *
 *   The slab_lock is only used for debugging and on arches that do not
 *   have the ability to do a cmpxchg_double. It only protects the second
 *   double word in the page struct. Meaning
 *	A. page->freelist	-> List of object free in a page
 *	B. page->counters	-> Counters of objects
 *	C. page->frozen		-> frozen state
 *
 *   If a slab is frozen then it is exempt from list management. It is not
 *   on any list. The processor that froze the slab is the one who can
 *   perform list operations on the page. Other processors may put objects
 *   onto the freelist but the processor that froze the slab is the only
 *   one that can retrieve the objects from the page's freelist.
C
Christoph Lameter 已提交
63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82
 *
 *   The list_lock protects the partial and full list on each node and
 *   the partial slab counter. If taken then no new slabs may be added or
 *   removed from the lists nor make the number of partial slabs be modified.
 *   (Note that the total number of slabs is an atomic value that may be
 *   modified without taking the list lock).
 *
 *   The list_lock is a centralized lock and thus we avoid taking it as
 *   much as possible. As long as SLUB does not have to handle partial
 *   slabs, operations can continue without any centralized lock. F.e.
 *   allocating a long series of objects that fill up slabs does not require
 *   the list lock.
 *   Interrupts are disabled during allocation and deallocation in order to
 *   make the slab allocator safe to use in the context of an irq. In addition
 *   interrupts are disabled to ensure that the processor does not change
 *   while handling per_cpu slabs, due to kernel preemption.
 *
 * SLUB assigns one slab for allocation to each processor.
 * Allocations only occur from these slabs called cpu slabs.
 *
C
Christoph Lameter 已提交
83 84
 * Slabs with free elements are kept on a partial list and during regular
 * operations no list for full slabs is used. If an object in a full slab is
C
Christoph Lameter 已提交
85
 * freed then the slab will show up again on the partial lists.
C
Christoph Lameter 已提交
86 87
 * We track full slabs for debugging purposes though because otherwise we
 * cannot scan all objects.
C
Christoph Lameter 已提交
88 89 90 91 92 93 94
 *
 * Slabs are freed when they become empty. Teardown and setup is
 * minimal so we rely on the page allocators per cpu caches for
 * fast frees and allocs.
 *
 * Overloading of page flags that are otherwise used for LRU management.
 *
95 96 97 98 99 100 101 102 103 104 105 106
 * PageActive 		The slab is frozen and exempt from list processing.
 * 			This means that the slab is dedicated to a purpose
 * 			such as satisfying allocations for a specific
 * 			processor. Objects may be freed in the slab while
 * 			it is frozen but slab_free will then skip the usual
 * 			list operations. It is up to the processor holding
 * 			the slab to integrate the slab into the slab lists
 * 			when the slab is no longer needed.
 *
 * 			One use of this flag is to mark slabs that are
 * 			used for allocations. Then such a slab becomes a cpu
 * 			slab. The cpu slab may be equipped with an additional
107
 * 			freelist that allows lockless access to
108 109
 * 			free objects in addition to the regular freelist
 * 			that requires the slab lock.
C
Christoph Lameter 已提交
110 111 112
 *
 * PageError		Slab requires special handling due to debug
 * 			options set. This moves	slab handling out of
113
 * 			the fast path and disables lockless freelists.
C
Christoph Lameter 已提交
114 115
 */

116 117
static inline int kmem_cache_debug(struct kmem_cache *s)
{
118
#ifdef CONFIG_SLUB_DEBUG
119
	return unlikely(s->flags & SLAB_DEBUG_FLAGS);
120
#else
121
	return 0;
122
#endif
123
}
124

C
Christoph Lameter 已提交
125 126 127 128 129 130 131 132 133 134 135
/*
 * Issues still to be resolved:
 *
 * - Support PAGE_ALLOC_DEBUG. Should be easy to do.
 *
 * - Variable sizing of the per node arrays
 */

/* Enable to test recovery from slab corruption on boot */
#undef SLUB_RESILIENCY_TEST

136 137 138
/* Enable to log cmpxchg failures */
#undef SLUB_DEBUG_CMPXCHG

139 140 141 142
/*
 * Mininum number of partial slabs. These will be left on the partial
 * lists even if they are empty. kmem_cache_shrink may reclaim them.
 */
C
Christoph Lameter 已提交
143
#define MIN_PARTIAL 5
C
Christoph Lameter 已提交
144

145 146 147 148 149 150 151
/*
 * Maximum number of desirable partial slabs.
 * The existence of more partial slabs makes kmem_cache_shrink
 * sort the partial list by the number of objects in the.
 */
#define MAX_PARTIAL 10

C
Christoph Lameter 已提交
152 153
#define DEBUG_DEFAULT_FLAGS (SLAB_DEBUG_FREE | SLAB_RED_ZONE | \
				SLAB_POISON | SLAB_STORE_USER)
C
Christoph Lameter 已提交
154

155
/*
156 157 158
 * Debugging flags that require metadata to be stored in the slab.  These get
 * disabled when slub_debug=O is used and a cache's min order increases with
 * metadata.
159
 */
160
#define DEBUG_METADATA_FLAGS (SLAB_RED_ZONE | SLAB_POISON | SLAB_STORE_USER)
161

C
Christoph Lameter 已提交
162 163 164 165
/*
 * Set of flags that will prevent slab merging
 */
#define SLUB_NEVER_MERGE (SLAB_RED_ZONE | SLAB_POISON | SLAB_STORE_USER | \
166 167
		SLAB_TRACE | SLAB_DESTROY_BY_RCU | SLAB_NOLEAKTRACE | \
		SLAB_FAILSLAB)
C
Christoph Lameter 已提交
168 169

#define SLUB_MERGE_SAME (SLAB_DEBUG_FREE | SLAB_RECLAIM_ACCOUNT | \
V
Vegard Nossum 已提交
170
		SLAB_CACHE_DMA | SLAB_NOTRACK)
C
Christoph Lameter 已提交
171

172 173
#define OO_SHIFT	16
#define OO_MASK		((1 << OO_SHIFT) - 1)
174
#define MAX_OBJS_PER_PAGE	32767 /* since page.objects is u15 */
175

C
Christoph Lameter 已提交
176
/* Internal SLUB flags */
C
Christoph Lameter 已提交
177
#define __OBJECT_POISON		0x80000000UL /* Poison object */
178
#define __CMPXCHG_DOUBLE	0x40000000UL /* Use cmpxchg_double */
C
Christoph Lameter 已提交
179 180 181 182 183

#ifdef CONFIG_SMP
static struct notifier_block slab_notifier;
#endif

184 185 186
/*
 * Tracking user of a slab.
 */
187
#define TRACK_ADDRS_COUNT 16
188
struct track {
189
	unsigned long addr;	/* Called from address */
190 191 192
#ifdef CONFIG_STACKTRACE
	unsigned long addrs[TRACK_ADDRS_COUNT];	/* Called from address */
#endif
193 194 195 196 197 198 199
	int cpu;		/* Was running on cpu */
	int pid;		/* Pid context */
	unsigned long when;	/* When did the operation occur */
};

enum track_item { TRACK_ALLOC, TRACK_FREE };

200
#ifdef CONFIG_SYSFS
C
Christoph Lameter 已提交
201 202 203
static int sysfs_slab_add(struct kmem_cache *);
static int sysfs_slab_alias(struct kmem_cache *, const char *);
static void sysfs_slab_remove(struct kmem_cache *);
204
static void memcg_propagate_slab_attrs(struct kmem_cache *s);
C
Christoph Lameter 已提交
205
#else
206 207 208
static inline int sysfs_slab_add(struct kmem_cache *s) { return 0; }
static inline int sysfs_slab_alias(struct kmem_cache *s, const char *p)
							{ return 0; }
209
static inline void sysfs_slab_remove(struct kmem_cache *s) { }
210

211
static inline void memcg_propagate_slab_attrs(struct kmem_cache *s) { }
C
Christoph Lameter 已提交
212 213
#endif

214
static inline void stat(const struct kmem_cache *s, enum stat_item si)
215 216
{
#ifdef CONFIG_SLUB_STATS
217
	__this_cpu_inc(s->cpu_slab->stat[si]);
218 219 220
#endif
}

C
Christoph Lameter 已提交
221 222 223 224 225 226 227 228 229
/********************************************************************
 * 			Core slab cache functions
 *******************************************************************/

static inline struct kmem_cache_node *get_node(struct kmem_cache *s, int node)
{
	return s->node[node];
}

C
Christoph Lameter 已提交
230
/* Verify that a pointer has an address that is valid within a slab page */
231 232 233 234 235
static inline int check_valid_pointer(struct kmem_cache *s,
				struct page *page, const void *object)
{
	void *base;

236
	if (!object)
237 238
		return 1;

239
	base = page_address(page);
240
	if (object < base || object >= base + page->objects * s->size ||
241 242 243 244 245 246 247
		(object - base) % s->size) {
		return 0;
	}

	return 1;
}

248 249 250 251 252
static inline void *get_freepointer(struct kmem_cache *s, void *object)
{
	return *(void **)(object + s->offset);
}

253 254 255 256 257
static void prefetch_freepointer(const struct kmem_cache *s, void *object)
{
	prefetch(object + s->offset);
}

258 259 260 261 262 263 264 265 266 267 268 269
static inline void *get_freepointer_safe(struct kmem_cache *s, void *object)
{
	void *p;

#ifdef CONFIG_DEBUG_PAGEALLOC
	probe_kernel_read(&p, (void **)(object + s->offset), sizeof(p));
#else
	p = get_freepointer(s, object);
#endif
	return p;
}

270 271 272 273 274 275
static inline void set_freepointer(struct kmem_cache *s, void *object, void *fp)
{
	*(void **)(object + s->offset) = fp;
}

/* Loop over all objects in a slab */
276 277
#define for_each_object(__p, __s, __addr, __objects) \
	for (__p = (__addr); __p < (__addr) + (__objects) * (__s)->size;\
278 279 280 281 282 283 284 285
			__p += (__s)->size)

/* Determine object index from a given position */
static inline int slab_index(void *p, struct kmem_cache *s, void *addr)
{
	return (p - addr) / s->size;
}

286 287 288 289 290 291 292 293
static inline size_t slab_ksize(const struct kmem_cache *s)
{
#ifdef CONFIG_SLUB_DEBUG
	/*
	 * Debugging requires use of the padding between object
	 * and whatever may come after it.
	 */
	if (s->flags & (SLAB_RED_ZONE | SLAB_POISON))
294
		return s->object_size;
295 296 297 298 299 300 301 302 303 304 305 306 307 308 309

#endif
	/*
	 * If we have the need to store the freelist pointer
	 * back there or track user information then we can
	 * only use the space before that information.
	 */
	if (s->flags & (SLAB_DESTROY_BY_RCU | SLAB_STORE_USER))
		return s->inuse;
	/*
	 * Else we can use all the padding etc for the allocation
	 */
	return s->size;
}

310 311 312 313 314
static inline int order_objects(int order, unsigned long size, int reserved)
{
	return ((PAGE_SIZE << order) - reserved) / size;
}

315
static inline struct kmem_cache_order_objects oo_make(int order,
316
		unsigned long size, int reserved)
317 318
{
	struct kmem_cache_order_objects x = {
319
		(order << OO_SHIFT) + order_objects(order, size, reserved)
320 321 322 323 324 325 326
	};

	return x;
}

static inline int oo_order(struct kmem_cache_order_objects x)
{
327
	return x.x >> OO_SHIFT;
328 329 330 331
}

static inline int oo_objects(struct kmem_cache_order_objects x)
{
332
	return x.x & OO_MASK;
333 334
}

335 336 337 338 339 340 341 342 343 344 345 346 347
/*
 * Per slab locking using the pagelock
 */
static __always_inline void slab_lock(struct page *page)
{
	bit_spin_lock(PG_locked, &page->flags);
}

static __always_inline void slab_unlock(struct page *page)
{
	__bit_spin_unlock(PG_locked, &page->flags);
}

348 349 350 351 352 353 354
/* Interrupts must be disabled (for the fallback code to work right) */
static inline bool __cmpxchg_double_slab(struct kmem_cache *s, struct page *page,
		void *freelist_old, unsigned long counters_old,
		void *freelist_new, unsigned long counters_new,
		const char *n)
{
	VM_BUG_ON(!irqs_disabled());
355 356
#if defined(CONFIG_HAVE_CMPXCHG_DOUBLE) && \
    defined(CONFIG_HAVE_ALIGNED_STRUCT_PAGE)
357
	if (s->flags & __CMPXCHG_DOUBLE) {
358
		if (cmpxchg_double(&page->freelist, &page->counters,
359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384
			freelist_old, counters_old,
			freelist_new, counters_new))
		return 1;
	} else
#endif
	{
		slab_lock(page);
		if (page->freelist == freelist_old && page->counters == counters_old) {
			page->freelist = freelist_new;
			page->counters = counters_new;
			slab_unlock(page);
			return 1;
		}
		slab_unlock(page);
	}

	cpu_relax();
	stat(s, CMPXCHG_DOUBLE_FAIL);

#ifdef SLUB_DEBUG_CMPXCHG
	printk(KERN_INFO "%s %s: cmpxchg double redo ", n, s->name);
#endif

	return 0;
}

385 386 387 388 389
static inline bool cmpxchg_double_slab(struct kmem_cache *s, struct page *page,
		void *freelist_old, unsigned long counters_old,
		void *freelist_new, unsigned long counters_new,
		const char *n)
{
390 391
#if defined(CONFIG_HAVE_CMPXCHG_DOUBLE) && \
    defined(CONFIG_HAVE_ALIGNED_STRUCT_PAGE)
392
	if (s->flags & __CMPXCHG_DOUBLE) {
393
		if (cmpxchg_double(&page->freelist, &page->counters,
394 395 396 397 398 399
			freelist_old, counters_old,
			freelist_new, counters_new))
		return 1;
	} else
#endif
	{
400 401 402
		unsigned long flags;

		local_irq_save(flags);
403
		slab_lock(page);
404 405 406
		if (page->freelist == freelist_old && page->counters == counters_old) {
			page->freelist = freelist_new;
			page->counters = counters_new;
407
			slab_unlock(page);
408
			local_irq_restore(flags);
409 410
			return 1;
		}
411
		slab_unlock(page);
412
		local_irq_restore(flags);
413 414 415 416 417 418 419 420 421 422 423 424
	}

	cpu_relax();
	stat(s, CMPXCHG_DOUBLE_FAIL);

#ifdef SLUB_DEBUG_CMPXCHG
	printk(KERN_INFO "%s %s: cmpxchg double redo ", n, s->name);
#endif

	return 0;
}

C
Christoph Lameter 已提交
425
#ifdef CONFIG_SLUB_DEBUG
426 427 428
/*
 * Determine a map of object in use on a page.
 *
429
 * Node listlock must be held to guarantee that the page does
430 431 432 433 434 435 436 437 438 439 440
 * not vanish from under us.
 */
static void get_map(struct kmem_cache *s, struct page *page, unsigned long *map)
{
	void *p;
	void *addr = page_address(page);

	for (p = page->freelist; p; p = get_freepointer(s, p))
		set_bit(slab_index(p, s, addr), map);
}

C
Christoph Lameter 已提交
441 442 443
/*
 * Debug settings:
 */
444 445 446
#ifdef CONFIG_SLUB_DEBUG_ON
static int slub_debug = DEBUG_DEFAULT_FLAGS;
#else
C
Christoph Lameter 已提交
447
static int slub_debug;
448
#endif
C
Christoph Lameter 已提交
449 450

static char *slub_debug_slabs;
451
static int disable_higher_order_debug;
C
Christoph Lameter 已提交
452

C
Christoph Lameter 已提交
453 454 455 456 457
/*
 * Object debugging
 */
static void print_section(char *text, u8 *addr, unsigned int length)
{
458 459
	print_hex_dump(KERN_ERR, text, DUMP_PREFIX_ADDRESS, 16, 1, addr,
			length, 1);
C
Christoph Lameter 已提交
460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
}

static struct track *get_track(struct kmem_cache *s, void *object,
	enum track_item alloc)
{
	struct track *p;

	if (s->offset)
		p = object + s->offset + sizeof(void *);
	else
		p = object + s->inuse;

	return p + alloc;
}

static void set_track(struct kmem_cache *s, void *object,
476
			enum track_item alloc, unsigned long addr)
C
Christoph Lameter 已提交
477
{
A
Akinobu Mita 已提交
478
	struct track *p = get_track(s, object, alloc);
C
Christoph Lameter 已提交
479 480

	if (addr) {
481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498
#ifdef CONFIG_STACKTRACE
		struct stack_trace trace;
		int i;

		trace.nr_entries = 0;
		trace.max_entries = TRACK_ADDRS_COUNT;
		trace.entries = p->addrs;
		trace.skip = 3;
		save_stack_trace(&trace);

		/* See rant in lockdep.c */
		if (trace.nr_entries != 0 &&
		    trace.entries[trace.nr_entries - 1] == ULONG_MAX)
			trace.nr_entries--;

		for (i = trace.nr_entries; i < TRACK_ADDRS_COUNT; i++)
			p->addrs[i] = 0;
#endif
C
Christoph Lameter 已提交
499 500
		p->addr = addr;
		p->cpu = smp_processor_id();
A
Alexey Dobriyan 已提交
501
		p->pid = current->pid;
C
Christoph Lameter 已提交
502 503 504 505 506 507 508
		p->when = jiffies;
	} else
		memset(p, 0, sizeof(struct track));
}

static void init_tracking(struct kmem_cache *s, void *object)
{
509 510 511
	if (!(s->flags & SLAB_STORE_USER))
		return;

512 513
	set_track(s, object, TRACK_FREE, 0UL);
	set_track(s, object, TRACK_ALLOC, 0UL);
C
Christoph Lameter 已提交
514 515 516 517 518 519 520
}

static void print_track(const char *s, struct track *t)
{
	if (!t->addr)
		return;

521
	printk(KERN_ERR "INFO: %s in %pS age=%lu cpu=%u pid=%d\n",
522
		s, (void *)t->addr, jiffies - t->when, t->cpu, t->pid);
523 524 525 526 527 528 529 530 531 532
#ifdef CONFIG_STACKTRACE
	{
		int i;
		for (i = 0; i < TRACK_ADDRS_COUNT; i++)
			if (t->addrs[i])
				printk(KERN_ERR "\t%pS\n", (void *)t->addrs[i]);
			else
				break;
	}
#endif
533 534 535 536 537 538 539 540 541 542 543 544 545
}

static void print_tracking(struct kmem_cache *s, void *object)
{
	if (!(s->flags & SLAB_STORE_USER))
		return;

	print_track("Allocated", get_track(s, object, TRACK_ALLOC));
	print_track("Freed", get_track(s, object, TRACK_FREE));
}

static void print_page_info(struct page *page)
{
546 547
	printk(KERN_ERR "INFO: Slab 0x%p objects=%u used=%u fp=0x%p flags=0x%04lx\n",
		page, page->objects, page->inuse, page->freelist, page->flags);
548 549 550 551 552 553 554 555 556 557 558 559 560

}

static void slab_bug(struct kmem_cache *s, char *fmt, ...)
{
	va_list args;
	char buf[100];

	va_start(args, fmt);
	vsnprintf(buf, sizeof(buf), fmt, args);
	va_end(args);
	printk(KERN_ERR "========================================"
			"=====================================\n");
561
	printk(KERN_ERR "BUG %s (%s): %s\n", s->name, print_tainted(), buf);
562 563
	printk(KERN_ERR "----------------------------------------"
			"-------------------------------------\n\n");
564 565

	add_taint(TAINT_BAD_PAGE);
C
Christoph Lameter 已提交
566 567
}

568 569 570 571 572 573 574 575 576 577 578 579
static void slab_fix(struct kmem_cache *s, char *fmt, ...)
{
	va_list args;
	char buf[100];

	va_start(args, fmt);
	vsnprintf(buf, sizeof(buf), fmt, args);
	va_end(args);
	printk(KERN_ERR "FIX %s: %s\n", s->name, buf);
}

static void print_trailer(struct kmem_cache *s, struct page *page, u8 *p)
C
Christoph Lameter 已提交
580 581
{
	unsigned int off;	/* Offset of last byte */
582
	u8 *addr = page_address(page);
583 584 585 586 587 588 589 590 591

	print_tracking(s, p);

	print_page_info(page);

	printk(KERN_ERR "INFO: Object 0x%p @offset=%tu fp=0x%p\n\n",
			p, p - addr, get_freepointer(s, p));

	if (p > addr + 16)
592
		print_section("Bytes b4 ", p - 16, 16);
C
Christoph Lameter 已提交
593

594
	print_section("Object ", p, min_t(unsigned long, s->object_size,
595
				PAGE_SIZE));
C
Christoph Lameter 已提交
596
	if (s->flags & SLAB_RED_ZONE)
597 598
		print_section("Redzone ", p + s->object_size,
			s->inuse - s->object_size);
C
Christoph Lameter 已提交
599 600 601 602 603 604

	if (s->offset)
		off = s->offset + sizeof(void *);
	else
		off = s->inuse;

605
	if (s->flags & SLAB_STORE_USER)
C
Christoph Lameter 已提交
606 607 608 609
		off += 2 * sizeof(struct track);

	if (off != s->size)
		/* Beginning of the filler is the free pointer */
610
		print_section("Padding ", p + off, s->size - off);
611 612

	dump_stack();
C
Christoph Lameter 已提交
613 614 615 616 617
}

static void object_err(struct kmem_cache *s, struct page *page,
			u8 *object, char *reason)
{
618
	slab_bug(s, "%s", reason);
619
	print_trailer(s, page, object);
C
Christoph Lameter 已提交
620 621
}

622
static void slab_err(struct kmem_cache *s, struct page *page, const char *fmt, ...)
C
Christoph Lameter 已提交
623 624 625 626
{
	va_list args;
	char buf[100];

627 628
	va_start(args, fmt);
	vsnprintf(buf, sizeof(buf), fmt, args);
C
Christoph Lameter 已提交
629
	va_end(args);
630
	slab_bug(s, "%s", buf);
631
	print_page_info(page);
C
Christoph Lameter 已提交
632 633 634
	dump_stack();
}

635
static void init_object(struct kmem_cache *s, void *object, u8 val)
C
Christoph Lameter 已提交
636 637 638 639
{
	u8 *p = object;

	if (s->flags & __OBJECT_POISON) {
640 641
		memset(p, POISON_FREE, s->object_size - 1);
		p[s->object_size - 1] = POISON_END;
C
Christoph Lameter 已提交
642 643 644
	}

	if (s->flags & SLAB_RED_ZONE)
645
		memset(p + s->object_size, val, s->inuse - s->object_size);
C
Christoph Lameter 已提交
646 647
}

648 649 650 651 652 653 654 655 656
static void restore_bytes(struct kmem_cache *s, char *message, u8 data,
						void *from, void *to)
{
	slab_fix(s, "Restoring 0x%p-0x%p=0x%x\n", from, to - 1, data);
	memset(from, data, to - from);
}

static int check_bytes_and_report(struct kmem_cache *s, struct page *page,
			u8 *object, char *what,
P
Pekka Enberg 已提交
657
			u8 *start, unsigned int value, unsigned int bytes)
658 659 660 661
{
	u8 *fault;
	u8 *end;

662
	fault = memchr_inv(start, value, bytes);
663 664 665 666 667 668 669 670 671 672 673 674 675 676
	if (!fault)
		return 1;

	end = start + bytes;
	while (end > fault && end[-1] == value)
		end--;

	slab_bug(s, "%s overwritten", what);
	printk(KERN_ERR "INFO: 0x%p-0x%p. First byte 0x%x instead of 0x%x\n",
					fault, end - 1, fault[0], value);
	print_trailer(s, page, object);

	restore_bytes(s, what, value, fault, end);
	return 0;
C
Christoph Lameter 已提交
677 678 679 680 681 682 683 684 685
}

/*
 * Object layout:
 *
 * object address
 * 	Bytes of the object to be managed.
 * 	If the freepointer may overlay the object then the free
 * 	pointer is the first word of the object.
C
Christoph Lameter 已提交
686
 *
C
Christoph Lameter 已提交
687 688 689
 * 	Poisoning uses 0x6b (POISON_FREE) and the last byte is
 * 	0xa5 (POISON_END)
 *
690
 * object + s->object_size
C
Christoph Lameter 已提交
691
 * 	Padding to reach word boundary. This is also used for Redzoning.
C
Christoph Lameter 已提交
692
 * 	Padding is extended by another word if Redzoning is enabled and
693
 * 	object_size == inuse.
C
Christoph Lameter 已提交
694
 *
C
Christoph Lameter 已提交
695 696 697 698
 * 	We fill with 0xbb (RED_INACTIVE) for inactive objects and with
 * 	0xcc (RED_ACTIVE) for objects in use.
 *
 * object + s->inuse
C
Christoph Lameter 已提交
699 700
 * 	Meta data starts here.
 *
C
Christoph Lameter 已提交
701 702
 * 	A. Free pointer (if we cannot overwrite object on free)
 * 	B. Tracking data for SLAB_STORE_USER
C
Christoph Lameter 已提交
703
 * 	C. Padding to reach required alignment boundary or at mininum
C
Christoph Lameter 已提交
704
 * 		one word if debugging is on to be able to detect writes
C
Christoph Lameter 已提交
705 706 707
 * 		before the word boundary.
 *
 *	Padding is done using 0x5a (POISON_INUSE)
C
Christoph Lameter 已提交
708 709
 *
 * object + s->size
C
Christoph Lameter 已提交
710
 * 	Nothing is used beyond s->size.
C
Christoph Lameter 已提交
711
 *
712
 * If slabcaches are merged then the object_size and inuse boundaries are mostly
C
Christoph Lameter 已提交
713
 * ignored. And therefore no slab options that rely on these boundaries
C
Christoph Lameter 已提交
714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731
 * may be used with merged slabcaches.
 */

static int check_pad_bytes(struct kmem_cache *s, struct page *page, u8 *p)
{
	unsigned long off = s->inuse;	/* The end of info */

	if (s->offset)
		/* Freepointer is placed after the object. */
		off += sizeof(void *);

	if (s->flags & SLAB_STORE_USER)
		/* We also have user information there */
		off += 2 * sizeof(struct track);

	if (s->size == off)
		return 1;

732 733
	return check_bytes_and_report(s, page, p, "Object padding",
				p + off, POISON_INUSE, s->size - off);
C
Christoph Lameter 已提交
734 735
}

736
/* Check the pad bytes at the end of a slab page */
C
Christoph Lameter 已提交
737 738
static int slab_pad_check(struct kmem_cache *s, struct page *page)
{
739 740 741 742 743
	u8 *start;
	u8 *fault;
	u8 *end;
	int length;
	int remainder;
C
Christoph Lameter 已提交
744 745 746 747

	if (!(s->flags & SLAB_POISON))
		return 1;

748
	start = page_address(page);
749
	length = (PAGE_SIZE << compound_order(page)) - s->reserved;
750 751
	end = start + length;
	remainder = length % s->size;
C
Christoph Lameter 已提交
752 753 754
	if (!remainder)
		return 1;

755
	fault = memchr_inv(end - remainder, POISON_INUSE, remainder);
756 757 758 759 760 761
	if (!fault)
		return 1;
	while (end > fault && end[-1] == POISON_INUSE)
		end--;

	slab_err(s, page, "Padding overwritten. 0x%p-0x%p", fault, end - 1);
762
	print_section("Padding ", end - remainder, remainder);
763

E
Eric Dumazet 已提交
764
	restore_bytes(s, "slab padding", POISON_INUSE, end - remainder, end);
765
	return 0;
C
Christoph Lameter 已提交
766 767 768
}

static int check_object(struct kmem_cache *s, struct page *page,
769
					void *object, u8 val)
C
Christoph Lameter 已提交
770 771
{
	u8 *p = object;
772
	u8 *endobject = object + s->object_size;
C
Christoph Lameter 已提交
773 774

	if (s->flags & SLAB_RED_ZONE) {
775
		if (!check_bytes_and_report(s, page, object, "Redzone",
776
			endobject, val, s->inuse - s->object_size))
C
Christoph Lameter 已提交
777 778
			return 0;
	} else {
779
		if ((s->flags & SLAB_POISON) && s->object_size < s->inuse) {
I
Ingo Molnar 已提交
780
			check_bytes_and_report(s, page, p, "Alignment padding",
781
				endobject, POISON_INUSE, s->inuse - s->object_size);
I
Ingo Molnar 已提交
782
		}
C
Christoph Lameter 已提交
783 784 785
	}

	if (s->flags & SLAB_POISON) {
786
		if (val != SLUB_RED_ACTIVE && (s->flags & __OBJECT_POISON) &&
787
			(!check_bytes_and_report(s, page, p, "Poison", p,
788
					POISON_FREE, s->object_size - 1) ||
789
			 !check_bytes_and_report(s, page, p, "Poison",
790
				p + s->object_size - 1, POISON_END, 1)))
C
Christoph Lameter 已提交
791 792 793 794 795 796 797
			return 0;
		/*
		 * check_pad_bytes cleans up on its own.
		 */
		check_pad_bytes(s, page, p);
	}

798
	if (!s->offset && val == SLUB_RED_ACTIVE)
C
Christoph Lameter 已提交
799 800 801 802 803 804 805 806 807 808
		/*
		 * Object and freepointer overlap. Cannot check
		 * freepointer while object is allocated.
		 */
		return 1;

	/* Check free pointer validity */
	if (!check_valid_pointer(s, page, get_freepointer(s, p))) {
		object_err(s, page, p, "Freepointer corrupt");
		/*
N
Nick Andrew 已提交
809
		 * No choice but to zap it and thus lose the remainder
C
Christoph Lameter 已提交
810
		 * of the free objects in this slab. May cause
C
Christoph Lameter 已提交
811
		 * another error because the object count is now wrong.
C
Christoph Lameter 已提交
812
		 */
813
		set_freepointer(s, p, NULL);
C
Christoph Lameter 已提交
814 815 816 817 818 819 820
		return 0;
	}
	return 1;
}

static int check_slab(struct kmem_cache *s, struct page *page)
{
821 822
	int maxobj;

C
Christoph Lameter 已提交
823 824 825
	VM_BUG_ON(!irqs_disabled());

	if (!PageSlab(page)) {
826
		slab_err(s, page, "Not a valid slab page");
C
Christoph Lameter 已提交
827 828
		return 0;
	}
829

830
	maxobj = order_objects(compound_order(page), s->size, s->reserved);
831 832 833 834 835 836
	if (page->objects > maxobj) {
		slab_err(s, page, "objects %u > max %u",
			s->name, page->objects, maxobj);
		return 0;
	}
	if (page->inuse > page->objects) {
837
		slab_err(s, page, "inuse %u > max %u",
838
			s->name, page->inuse, page->objects);
C
Christoph Lameter 已提交
839 840 841 842 843 844 845 846
		return 0;
	}
	/* Slab_pad_check fixes things up after itself */
	slab_pad_check(s, page);
	return 1;
}

/*
C
Christoph Lameter 已提交
847 848
 * Determine if a certain object on a page is on the freelist. Must hold the
 * slab lock to guarantee that the chains are in a consistent state.
C
Christoph Lameter 已提交
849 850 851 852
 */
static int on_freelist(struct kmem_cache *s, struct page *page, void *search)
{
	int nr = 0;
853
	void *fp;
C
Christoph Lameter 已提交
854
	void *object = NULL;
855
	unsigned long max_objects;
C
Christoph Lameter 已提交
856

857
	fp = page->freelist;
858
	while (fp && nr <= page->objects) {
C
Christoph Lameter 已提交
859 860 861 862 863 864
		if (fp == search)
			return 1;
		if (!check_valid_pointer(s, page, fp)) {
			if (object) {
				object_err(s, page, object,
					"Freechain corrupt");
865
				set_freepointer(s, object, NULL);
C
Christoph Lameter 已提交
866 867
				break;
			} else {
868
				slab_err(s, page, "Freepointer corrupt");
869
				page->freelist = NULL;
870
				page->inuse = page->objects;
871
				slab_fix(s, "Freelist cleared");
C
Christoph Lameter 已提交
872 873 874 875 876 877 878 879 880
				return 0;
			}
			break;
		}
		object = fp;
		fp = get_freepointer(s, object);
		nr++;
	}

881
	max_objects = order_objects(compound_order(page), s->size, s->reserved);
882 883
	if (max_objects > MAX_OBJS_PER_PAGE)
		max_objects = MAX_OBJS_PER_PAGE;
884 885 886 887 888 889 890

	if (page->objects != max_objects) {
		slab_err(s, page, "Wrong number of objects. Found %d but "
			"should be %d", page->objects, max_objects);
		page->objects = max_objects;
		slab_fix(s, "Number of objects adjusted.");
	}
891
	if (page->inuse != page->objects - nr) {
892
		slab_err(s, page, "Wrong object count. Counter is %d but "
893 894
			"counted were %d", page->inuse, page->objects - nr);
		page->inuse = page->objects - nr;
895
		slab_fix(s, "Object count adjusted.");
C
Christoph Lameter 已提交
896 897 898 899
	}
	return search == NULL;
}

900 901
static void trace(struct kmem_cache *s, struct page *page, void *object,
								int alloc)
C
Christoph Lameter 已提交
902 903 904 905 906 907 908 909 910
{
	if (s->flags & SLAB_TRACE) {
		printk(KERN_INFO "TRACE %s %s 0x%p inuse=%d fp=0x%p\n",
			s->name,
			alloc ? "alloc" : "free",
			object, page->inuse,
			page->freelist);

		if (!alloc)
911
			print_section("Object ", (void *)object, s->object_size);
C
Christoph Lameter 已提交
912 913 914 915 916

		dump_stack();
	}
}

917 918 919 920 921 922
/*
 * Hooks for other subsystems that check memory allocations. In a typical
 * production configuration these hooks all should produce no code at all.
 */
static inline int slab_pre_alloc_hook(struct kmem_cache *s, gfp_t flags)
{
923
	flags &= gfp_allowed_mask;
924 925 926
	lockdep_trace_alloc(flags);
	might_sleep_if(flags & __GFP_WAIT);

927
	return should_failslab(s->object_size, flags, s->flags);
928 929 930 931
}

static inline void slab_post_alloc_hook(struct kmem_cache *s, gfp_t flags, void *object)
{
932
	flags &= gfp_allowed_mask;
933
	kmemcheck_slab_alloc(s, flags, object, slab_ksize(s));
934
	kmemleak_alloc_recursive(object, s->object_size, 1, s->flags, flags);
935 936 937 938 939 940
}

static inline void slab_free_hook(struct kmem_cache *s, void *x)
{
	kmemleak_free_recursive(x, s->flags);

941 942 943 944 945 946 947 948 949 950
	/*
	 * Trouble is that we may no longer disable interupts in the fast path
	 * So in order to make the debug calls that expect irqs to be
	 * disabled we need to disable interrupts temporarily.
	 */
#if defined(CONFIG_KMEMCHECK) || defined(CONFIG_LOCKDEP)
	{
		unsigned long flags;

		local_irq_save(flags);
951 952
		kmemcheck_slab_free(s, x, s->object_size);
		debug_check_no_locks_freed(x, s->object_size);
953 954 955
		local_irq_restore(flags);
	}
#endif
956
	if (!(s->flags & SLAB_DEBUG_OBJECTS))
957
		debug_check_no_obj_freed(x, s->object_size);
958 959
}

960
/*
C
Christoph Lameter 已提交
961
 * Tracking of fully allocated slabs for debugging purposes.
962 963
 *
 * list_lock must be held.
964
 */
965 966
static void add_full(struct kmem_cache *s,
	struct kmem_cache_node *n, struct page *page)
967
{
968 969 970
	if (!(s->flags & SLAB_STORE_USER))
		return;

971 972 973
	list_add(&page->lru, &n->full);
}

974 975 976
/*
 * list_lock must be held.
 */
977 978 979 980 981 982 983 984
static void remove_full(struct kmem_cache *s, struct page *page)
{
	if (!(s->flags & SLAB_STORE_USER))
		return;

	list_del(&page->lru);
}

985 986 987 988 989 990 991 992
/* Tracking of the number of slabs for debugging purposes */
static inline unsigned long slabs_node(struct kmem_cache *s, int node)
{
	struct kmem_cache_node *n = get_node(s, node);

	return atomic_long_read(&n->nr_slabs);
}

993 994 995 996 997
static inline unsigned long node_nr_slabs(struct kmem_cache_node *n)
{
	return atomic_long_read(&n->nr_slabs);
}

998
static inline void inc_slabs_node(struct kmem_cache *s, int node, int objects)
999 1000 1001 1002 1003 1004 1005 1006 1007
{
	struct kmem_cache_node *n = get_node(s, node);

	/*
	 * May be called early in order to allocate a slab for the
	 * kmem_cache_node structure. Solve the chicken-egg
	 * dilemma by deferring the increment of the count during
	 * bootstrap (see early_kmem_cache_node_alloc).
	 */
1008
	if (likely(n)) {
1009
		atomic_long_inc(&n->nr_slabs);
1010 1011
		atomic_long_add(objects, &n->total_objects);
	}
1012
}
1013
static inline void dec_slabs_node(struct kmem_cache *s, int node, int objects)
1014 1015 1016 1017
{
	struct kmem_cache_node *n = get_node(s, node);

	atomic_long_dec(&n->nr_slabs);
1018
	atomic_long_sub(objects, &n->total_objects);
1019 1020 1021
}

/* Object debug checks for alloc/free paths */
C
Christoph Lameter 已提交
1022 1023 1024 1025 1026 1027
static void setup_object_debug(struct kmem_cache *s, struct page *page,
								void *object)
{
	if (!(s->flags & (SLAB_STORE_USER|SLAB_RED_ZONE|__OBJECT_POISON)))
		return;

1028
	init_object(s, object, SLUB_RED_INACTIVE);
C
Christoph Lameter 已提交
1029 1030 1031
	init_tracking(s, object);
}

1032
static noinline int alloc_debug_processing(struct kmem_cache *s, struct page *page,
1033
					void *object, unsigned long addr)
C
Christoph Lameter 已提交
1034 1035 1036 1037 1038 1039
{
	if (!check_slab(s, page))
		goto bad;

	if (!check_valid_pointer(s, page, object)) {
		object_err(s, page, object, "Freelist Pointer check fails");
1040
		goto bad;
C
Christoph Lameter 已提交
1041 1042
	}

1043
	if (!check_object(s, page, object, SLUB_RED_INACTIVE))
C
Christoph Lameter 已提交
1044 1045
		goto bad;

C
Christoph Lameter 已提交
1046 1047 1048 1049
	/* Success perform special debug activities for allocs */
	if (s->flags & SLAB_STORE_USER)
		set_track(s, object, TRACK_ALLOC, addr);
	trace(s, page, object, 1);
1050
	init_object(s, object, SLUB_RED_ACTIVE);
C
Christoph Lameter 已提交
1051
	return 1;
C
Christoph Lameter 已提交
1052

C
Christoph Lameter 已提交
1053 1054 1055 1056 1057
bad:
	if (PageSlab(page)) {
		/*
		 * If this is a slab page then lets do the best we can
		 * to avoid issues in the future. Marking all objects
C
Christoph Lameter 已提交
1058
		 * as used avoids touching the remaining objects.
C
Christoph Lameter 已提交
1059
		 */
1060
		slab_fix(s, "Marking all objects used");
1061
		page->inuse = page->objects;
1062
		page->freelist = NULL;
C
Christoph Lameter 已提交
1063 1064 1065 1066
	}
	return 0;
}

1067 1068 1069
static noinline struct kmem_cache_node *free_debug_processing(
	struct kmem_cache *s, struct page *page, void *object,
	unsigned long addr, unsigned long *flags)
C
Christoph Lameter 已提交
1070
{
1071
	struct kmem_cache_node *n = get_node(s, page_to_nid(page));
1072

1073
	spin_lock_irqsave(&n->list_lock, *flags);
1074 1075
	slab_lock(page);

C
Christoph Lameter 已提交
1076 1077 1078 1079
	if (!check_slab(s, page))
		goto fail;

	if (!check_valid_pointer(s, page, object)) {
1080
		slab_err(s, page, "Invalid object pointer 0x%p", object);
C
Christoph Lameter 已提交
1081 1082 1083 1084
		goto fail;
	}

	if (on_freelist(s, page, object)) {
1085
		object_err(s, page, object, "Object already free");
C
Christoph Lameter 已提交
1086 1087 1088
		goto fail;
	}

1089
	if (!check_object(s, page, object, SLUB_RED_ACTIVE))
1090
		goto out;
C
Christoph Lameter 已提交
1091

1092
	if (unlikely(s != page->slab_cache)) {
I
Ingo Molnar 已提交
1093
		if (!PageSlab(page)) {
1094 1095
			slab_err(s, page, "Attempt to free object(0x%p) "
				"outside of slab", object);
1096
		} else if (!page->slab_cache) {
C
Christoph Lameter 已提交
1097
			printk(KERN_ERR
1098
				"SLUB <none>: no slab for object 0x%p.\n",
C
Christoph Lameter 已提交
1099
						object);
1100
			dump_stack();
P
Pekka Enberg 已提交
1101
		} else
1102 1103
			object_err(s, page, object,
					"page slab pointer corrupt.");
C
Christoph Lameter 已提交
1104 1105
		goto fail;
	}
C
Christoph Lameter 已提交
1106 1107 1108 1109

	if (s->flags & SLAB_STORE_USER)
		set_track(s, object, TRACK_FREE, addr);
	trace(s, page, object, 0);
1110
	init_object(s, object, SLUB_RED_INACTIVE);
1111
out:
1112
	slab_unlock(page);
1113 1114 1115 1116 1117
	/*
	 * Keep node_lock to preserve integrity
	 * until the object is actually freed
	 */
	return n;
C
Christoph Lameter 已提交
1118

C
Christoph Lameter 已提交
1119
fail:
1120 1121
	slab_unlock(page);
	spin_unlock_irqrestore(&n->list_lock, *flags);
1122
	slab_fix(s, "Object at 0x%p not freed", object);
1123
	return NULL;
C
Christoph Lameter 已提交
1124 1125
}

C
Christoph Lameter 已提交
1126 1127
static int __init setup_slub_debug(char *str)
{
1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141
	slub_debug = DEBUG_DEFAULT_FLAGS;
	if (*str++ != '=' || !*str)
		/*
		 * No options specified. Switch on full debugging.
		 */
		goto out;

	if (*str == ',')
		/*
		 * No options but restriction on slabs. This means full
		 * debugging for slabs matching a pattern.
		 */
		goto check_slabs;

1142 1143 1144 1145 1146 1147 1148 1149 1150
	if (tolower(*str) == 'o') {
		/*
		 * Avoid enabling debugging on caches if its minimum order
		 * would increase as a result.
		 */
		disable_higher_order_debug = 1;
		goto out;
	}

1151 1152 1153 1154 1155 1156 1157 1158 1159 1160
	slub_debug = 0;
	if (*str == '-')
		/*
		 * Switch off all debugging measures.
		 */
		goto out;

	/*
	 * Determine which debug features should be switched on
	 */
P
Pekka Enberg 已提交
1161
	for (; *str && *str != ','; str++) {
1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177
		switch (tolower(*str)) {
		case 'f':
			slub_debug |= SLAB_DEBUG_FREE;
			break;
		case 'z':
			slub_debug |= SLAB_RED_ZONE;
			break;
		case 'p':
			slub_debug |= SLAB_POISON;
			break;
		case 'u':
			slub_debug |= SLAB_STORE_USER;
			break;
		case 't':
			slub_debug |= SLAB_TRACE;
			break;
1178 1179 1180
		case 'a':
			slub_debug |= SLAB_FAILSLAB;
			break;
1181 1182
		default:
			printk(KERN_ERR "slub_debug option '%c' "
P
Pekka Enberg 已提交
1183
				"unknown. skipped\n", *str);
1184
		}
C
Christoph Lameter 已提交
1185 1186
	}

1187
check_slabs:
C
Christoph Lameter 已提交
1188 1189
	if (*str == ',')
		slub_debug_slabs = str + 1;
1190
out:
C
Christoph Lameter 已提交
1191 1192 1193 1194 1195
	return 1;
}

__setup("slub_debug", setup_slub_debug);

1196
static unsigned long kmem_cache_flags(unsigned long object_size,
1197
	unsigned long flags, const char *name,
1198
	void (*ctor)(void *))
C
Christoph Lameter 已提交
1199 1200
{
	/*
1201
	 * Enable debugging if selected on the kernel commandline.
C
Christoph Lameter 已提交
1202
	 */
1203
	if (slub_debug && (!slub_debug_slabs ||
1204 1205
		!strncmp(slub_debug_slabs, name, strlen(slub_debug_slabs))))
		flags |= slub_debug;
1206 1207

	return flags;
C
Christoph Lameter 已提交
1208 1209
}
#else
C
Christoph Lameter 已提交
1210 1211
static inline void setup_object_debug(struct kmem_cache *s,
			struct page *page, void *object) {}
C
Christoph Lameter 已提交
1212

C
Christoph Lameter 已提交
1213
static inline int alloc_debug_processing(struct kmem_cache *s,
1214
	struct page *page, void *object, unsigned long addr) { return 0; }
C
Christoph Lameter 已提交
1215

1216 1217 1218
static inline struct kmem_cache_node *free_debug_processing(
	struct kmem_cache *s, struct page *page, void *object,
	unsigned long addr, unsigned long *flags) { return NULL; }
C
Christoph Lameter 已提交
1219 1220 1221 1222

static inline int slab_pad_check(struct kmem_cache *s, struct page *page)
			{ return 1; }
static inline int check_object(struct kmem_cache *s, struct page *page,
1223
			void *object, u8 val) { return 1; }
1224 1225
static inline void add_full(struct kmem_cache *s, struct kmem_cache_node *n,
					struct page *page) {}
1226
static inline void remove_full(struct kmem_cache *s, struct page *page) {}
1227
static inline unsigned long kmem_cache_flags(unsigned long object_size,
1228
	unsigned long flags, const char *name,
1229
	void (*ctor)(void *))
1230 1231 1232
{
	return flags;
}
C
Christoph Lameter 已提交
1233
#define slub_debug 0
1234

1235 1236
#define disable_higher_order_debug 0

1237 1238
static inline unsigned long slabs_node(struct kmem_cache *s, int node)
							{ return 0; }
1239 1240
static inline unsigned long node_nr_slabs(struct kmem_cache_node *n)
							{ return 0; }
1241 1242 1243 1244
static inline void inc_slabs_node(struct kmem_cache *s, int node,
							int objects) {}
static inline void dec_slabs_node(struct kmem_cache *s, int node,
							int objects) {}
1245 1246 1247 1248 1249 1250 1251 1252 1253

static inline int slab_pre_alloc_hook(struct kmem_cache *s, gfp_t flags)
							{ return 0; }

static inline void slab_post_alloc_hook(struct kmem_cache *s, gfp_t flags,
		void *object) {}

static inline void slab_free_hook(struct kmem_cache *s, void *x) {}

1254
#endif /* CONFIG_SLUB_DEBUG */
1255

C
Christoph Lameter 已提交
1256 1257 1258
/*
 * Slab allocation and freeing
 */
1259 1260 1261 1262 1263
static inline struct page *alloc_slab_page(gfp_t flags, int node,
					struct kmem_cache_order_objects oo)
{
	int order = oo_order(oo);

1264 1265
	flags |= __GFP_NOTRACK;

1266
	if (node == NUMA_NO_NODE)
1267 1268
		return alloc_pages(flags, order);
	else
1269
		return alloc_pages_exact_node(node, flags, order);
1270 1271
}

C
Christoph Lameter 已提交
1272 1273
static struct page *allocate_slab(struct kmem_cache *s, gfp_t flags, int node)
{
P
Pekka Enberg 已提交
1274
	struct page *page;
1275
	struct kmem_cache_order_objects oo = s->oo;
1276
	gfp_t alloc_gfp;
C
Christoph Lameter 已提交
1277

1278 1279 1280 1281 1282
	flags &= gfp_allowed_mask;

	if (flags & __GFP_WAIT)
		local_irq_enable();

1283
	flags |= s->allocflags;
1284

1285 1286 1287 1288 1289 1290 1291
	/*
	 * Let the initial higher-order allocation fail under memory pressure
	 * so we fall-back to the minimum order allocation.
	 */
	alloc_gfp = (flags | __GFP_NOWARN | __GFP_NORETRY) & ~__GFP_NOFAIL;

	page = alloc_slab_page(alloc_gfp, node, oo);
1292 1293 1294 1295 1296 1297 1298
	if (unlikely(!page)) {
		oo = s->min;
		/*
		 * Allocation may have failed due to fragmentation.
		 * Try a lower order alloc if possible
		 */
		page = alloc_slab_page(flags, node, oo);
C
Christoph Lameter 已提交
1299

1300 1301
		if (page)
			stat(s, ORDER_FALLBACK);
1302
	}
V
Vegard Nossum 已提交
1303

1304
	if (kmemcheck_enabled && page
1305
		&& !(s->flags & (SLAB_NOTRACK | DEBUG_DEFAULT_FLAGS))) {
1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317
		int pages = 1 << oo_order(oo);

		kmemcheck_alloc_shadow(page, oo_order(oo), flags, node);

		/*
		 * Objects from caches that have a constructor don't get
		 * cleared when they're allocated, so we need to do it here.
		 */
		if (s->ctor)
			kmemcheck_mark_uninitialized_pages(page, pages);
		else
			kmemcheck_mark_unallocated_pages(page, pages);
V
Vegard Nossum 已提交
1318 1319
	}

1320 1321 1322 1323 1324
	if (flags & __GFP_WAIT)
		local_irq_disable();
	if (!page)
		return NULL;

1325
	page->objects = oo_objects(oo);
C
Christoph Lameter 已提交
1326 1327 1328
	mod_zone_page_state(page_zone(page),
		(s->flags & SLAB_RECLAIM_ACCOUNT) ?
		NR_SLAB_RECLAIMABLE : NR_SLAB_UNRECLAIMABLE,
1329
		1 << oo_order(oo));
C
Christoph Lameter 已提交
1330 1331 1332 1333 1334 1335 1336

	return page;
}

static void setup_object(struct kmem_cache *s, struct page *page,
				void *object)
{
C
Christoph Lameter 已提交
1337
	setup_object_debug(s, page, object);
1338
	if (unlikely(s->ctor))
1339
		s->ctor(object);
C
Christoph Lameter 已提交
1340 1341 1342 1343 1344 1345 1346 1347
}

static struct page *new_slab(struct kmem_cache *s, gfp_t flags, int node)
{
	struct page *page;
	void *start;
	void *last;
	void *p;
G
Glauber Costa 已提交
1348
	int order;
C
Christoph Lameter 已提交
1349

C
Christoph Lameter 已提交
1350
	BUG_ON(flags & GFP_SLAB_BUG_MASK);
C
Christoph Lameter 已提交
1351

C
Christoph Lameter 已提交
1352 1353
	page = allocate_slab(s,
		flags & (GFP_RECLAIM_MASK | GFP_CONSTRAINT_MASK), node);
C
Christoph Lameter 已提交
1354 1355 1356
	if (!page)
		goto out;

G
Glauber Costa 已提交
1357
	order = compound_order(page);
1358
	inc_slabs_node(s, page_to_nid(page), page->objects);
G
Glauber Costa 已提交
1359
	memcg_bind_pages(s, order);
1360
	page->slab_cache = s;
1361
	__SetPageSlab(page);
1362 1363
	if (page->pfmemalloc)
		SetPageSlabPfmemalloc(page);
C
Christoph Lameter 已提交
1364 1365 1366 1367

	start = page_address(page);

	if (unlikely(s->flags & SLAB_POISON))
G
Glauber Costa 已提交
1368
		memset(start, POISON_INUSE, PAGE_SIZE << order);
C
Christoph Lameter 已提交
1369 1370

	last = start;
1371
	for_each_object(p, s, start, page->objects) {
C
Christoph Lameter 已提交
1372 1373 1374 1375 1376
		setup_object(s, page, last);
		set_freepointer(s, last, p);
		last = p;
	}
	setup_object(s, page, last);
1377
	set_freepointer(s, last, NULL);
C
Christoph Lameter 已提交
1378 1379

	page->freelist = start;
1380
	page->inuse = page->objects;
1381
	page->frozen = 1;
C
Christoph Lameter 已提交
1382 1383 1384 1385 1386 1387
out:
	return page;
}

static void __free_slab(struct kmem_cache *s, struct page *page)
{
1388 1389
	int order = compound_order(page);
	int pages = 1 << order;
C
Christoph Lameter 已提交
1390

1391
	if (kmem_cache_debug(s)) {
C
Christoph Lameter 已提交
1392 1393 1394
		void *p;

		slab_pad_check(s, page);
1395 1396
		for_each_object(p, s, page_address(page),
						page->objects)
1397
			check_object(s, page, p, SLUB_RED_INACTIVE);
C
Christoph Lameter 已提交
1398 1399
	}

1400
	kmemcheck_free_shadow(page, compound_order(page));
V
Vegard Nossum 已提交
1401

C
Christoph Lameter 已提交
1402 1403 1404
	mod_zone_page_state(page_zone(page),
		(s->flags & SLAB_RECLAIM_ACCOUNT) ?
		NR_SLAB_RECLAIMABLE : NR_SLAB_UNRECLAIMABLE,
P
Pekka Enberg 已提交
1405
		-pages);
C
Christoph Lameter 已提交
1406

1407
	__ClearPageSlabPfmemalloc(page);
1408
	__ClearPageSlab(page);
G
Glauber Costa 已提交
1409 1410

	memcg_release_pages(s, order);
1411
	reset_page_mapcount(page);
N
Nick Piggin 已提交
1412 1413
	if (current->reclaim_state)
		current->reclaim_state->reclaimed_slab += pages;
1414
	__free_memcg_kmem_pages(page, order);
C
Christoph Lameter 已提交
1415 1416
}

1417 1418 1419
#define need_reserve_slab_rcu						\
	(sizeof(((struct page *)NULL)->lru) < sizeof(struct rcu_head))

C
Christoph Lameter 已提交
1420 1421 1422 1423
static void rcu_free_slab(struct rcu_head *h)
{
	struct page *page;

1424 1425 1426 1427 1428
	if (need_reserve_slab_rcu)
		page = virt_to_head_page(h);
	else
		page = container_of((struct list_head *)h, struct page, lru);

1429
	__free_slab(page->slab_cache, page);
C
Christoph Lameter 已提交
1430 1431 1432 1433 1434
}

static void free_slab(struct kmem_cache *s, struct page *page)
{
	if (unlikely(s->flags & SLAB_DESTROY_BY_RCU)) {
1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448
		struct rcu_head *head;

		if (need_reserve_slab_rcu) {
			int order = compound_order(page);
			int offset = (PAGE_SIZE << order) - s->reserved;

			VM_BUG_ON(s->reserved != sizeof(*head));
			head = page_address(page) + offset;
		} else {
			/*
			 * RCU free overloads the RCU head over the LRU
			 */
			head = (void *)&page->lru;
		}
C
Christoph Lameter 已提交
1449 1450 1451 1452 1453 1454 1455 1456

		call_rcu(head, rcu_free_slab);
	} else
		__free_slab(s, page);
}

static void discard_slab(struct kmem_cache *s, struct page *page)
{
1457
	dec_slabs_node(s, page_to_nid(page), page->objects);
C
Christoph Lameter 已提交
1458 1459 1460 1461
	free_slab(s, page);
}

/*
1462 1463 1464
 * Management of partially allocated slabs.
 *
 * list_lock must be held.
C
Christoph Lameter 已提交
1465
 */
1466
static inline void add_partial(struct kmem_cache_node *n,
1467
				struct page *page, int tail)
C
Christoph Lameter 已提交
1468
{
C
Christoph Lameter 已提交
1469
	n->nr_partial++;
1470
	if (tail == DEACTIVATE_TO_TAIL)
1471 1472 1473
		list_add_tail(&page->lru, &n->partial);
	else
		list_add(&page->lru, &n->partial);
C
Christoph Lameter 已提交
1474 1475
}

1476 1477 1478 1479
/*
 * list_lock must be held.
 */
static inline void remove_partial(struct kmem_cache_node *n,
1480 1481 1482 1483 1484 1485
					struct page *page)
{
	list_del(&page->lru);
	n->nr_partial--;
}

C
Christoph Lameter 已提交
1486
/*
1487 1488
 * Remove slab from the partial list, freeze it and
 * return the pointer to the freelist.
C
Christoph Lameter 已提交
1489
 *
1490 1491
 * Returns a list of objects or NULL if it fails.
 *
1492
 * Must hold list_lock since we modify the partial list.
C
Christoph Lameter 已提交
1493
 */
1494
static inline void *acquire_slab(struct kmem_cache *s,
1495
		struct kmem_cache_node *n, struct page *page,
1496
		int mode, int *objects)
C
Christoph Lameter 已提交
1497
{
1498 1499 1500 1501 1502 1503 1504 1505 1506
	void *freelist;
	unsigned long counters;
	struct page new;

	/*
	 * Zap the freelist and set the frozen bit.
	 * The old freelist is the list of objects for the
	 * per cpu allocation list.
	 */
1507 1508 1509
	freelist = page->freelist;
	counters = page->counters;
	new.counters = counters;
1510
	*objects = new.objects - new.inuse;
1511
	if (mode) {
1512
		new.inuse = page->objects;
1513 1514 1515 1516
		new.freelist = NULL;
	} else {
		new.freelist = freelist;
	}
1517

1518 1519
	VM_BUG_ON(new.frozen);
	new.frozen = 1;
1520

1521
	if (!__cmpxchg_double_slab(s, page,
1522
			freelist, counters,
1523
			new.freelist, new.counters,
1524 1525
			"acquire_slab"))
		return NULL;
1526 1527

	remove_partial(n, page);
1528
	WARN_ON(!freelist);
1529
	return freelist;
C
Christoph Lameter 已提交
1530 1531
}

1532
static void put_cpu_partial(struct kmem_cache *s, struct page *page, int drain);
1533
static inline bool pfmemalloc_match(struct page *page, gfp_t gfpflags);
1534

C
Christoph Lameter 已提交
1535
/*
C
Christoph Lameter 已提交
1536
 * Try to allocate a partial slab from a specific node.
C
Christoph Lameter 已提交
1537
 */
1538 1539
static void *get_partial_node(struct kmem_cache *s, struct kmem_cache_node *n,
				struct kmem_cache_cpu *c, gfp_t flags)
C
Christoph Lameter 已提交
1540
{
1541 1542
	struct page *page, *page2;
	void *object = NULL;
1543 1544
	int available = 0;
	int objects;
C
Christoph Lameter 已提交
1545 1546 1547 1548

	/*
	 * Racy check. If we mistakenly see no partial slabs then we
	 * just allocate an empty slab. If we mistakenly try to get a
C
Christoph Lameter 已提交
1549 1550
	 * partial slab and there is none available then get_partials()
	 * will return NULL.
C
Christoph Lameter 已提交
1551 1552 1553 1554 1555
	 */
	if (!n || !n->nr_partial)
		return NULL;

	spin_lock(&n->list_lock);
1556
	list_for_each_entry_safe(page, page2, &n->partial, lru) {
1557
		void *t;
1558

1559 1560 1561
		if (!pfmemalloc_match(page, flags))
			continue;

1562
		t = acquire_slab(s, n, page, object == NULL, &objects);
1563 1564 1565
		if (!t)
			break;

1566
		available += objects;
1567
		if (!object) {
1568 1569 1570 1571
			c->page = page;
			stat(s, ALLOC_FROM_PARTIAL);
			object = t;
		} else {
1572
			put_cpu_partial(s, page, 0);
1573
			stat(s, CPU_PARTIAL_NODE);
1574 1575 1576 1577
		}
		if (kmem_cache_debug(s) || available > s->cpu_partial / 2)
			break;

1578
	}
C
Christoph Lameter 已提交
1579
	spin_unlock(&n->list_lock);
1580
	return object;
C
Christoph Lameter 已提交
1581 1582 1583
}

/*
C
Christoph Lameter 已提交
1584
 * Get a page from somewhere. Search in increasing NUMA distances.
C
Christoph Lameter 已提交
1585
 */
1586
static void *get_any_partial(struct kmem_cache *s, gfp_t flags,
1587
		struct kmem_cache_cpu *c)
C
Christoph Lameter 已提交
1588 1589 1590
{
#ifdef CONFIG_NUMA
	struct zonelist *zonelist;
1591
	struct zoneref *z;
1592 1593
	struct zone *zone;
	enum zone_type high_zoneidx = gfp_zone(flags);
1594
	void *object;
1595
	unsigned int cpuset_mems_cookie;
C
Christoph Lameter 已提交
1596 1597

	/*
C
Christoph Lameter 已提交
1598 1599 1600 1601
	 * The defrag ratio allows a configuration of the tradeoffs between
	 * inter node defragmentation and node local allocations. A lower
	 * defrag_ratio increases the tendency to do local allocations
	 * instead of attempting to obtain partial slabs from other nodes.
C
Christoph Lameter 已提交
1602
	 *
C
Christoph Lameter 已提交
1603 1604 1605 1606
	 * If the defrag_ratio is set to 0 then kmalloc() always
	 * returns node local objects. If the ratio is higher then kmalloc()
	 * may return off node objects because partial slabs are obtained
	 * from other nodes and filled up.
C
Christoph Lameter 已提交
1607
	 *
C
Christoph Lameter 已提交
1608
	 * If /sys/kernel/slab/xx/defrag_ratio is set to 100 (which makes
C
Christoph Lameter 已提交
1609 1610 1611 1612 1613
	 * defrag_ratio = 1000) then every (well almost) allocation will
	 * first attempt to defrag slab caches on other nodes. This means
	 * scanning over all nodes to look for partial slabs which may be
	 * expensive if we do it every time we are trying to find a slab
	 * with available objects.
C
Christoph Lameter 已提交
1614
	 */
1615 1616
	if (!s->remote_node_defrag_ratio ||
			get_cycles() % 1024 > s->remote_node_defrag_ratio)
C
Christoph Lameter 已提交
1617 1618
		return NULL;

1619 1620
	do {
		cpuset_mems_cookie = get_mems_allowed();
1621
		zonelist = node_zonelist(slab_node(), flags);
1622 1623 1624 1625 1626 1627 1628
		for_each_zone_zonelist(zone, z, zonelist, high_zoneidx) {
			struct kmem_cache_node *n;

			n = get_node(s, zone_to_nid(zone));

			if (n && cpuset_zone_allowed_hardwall(zone, flags) &&
					n->nr_partial > s->min_partial) {
1629
				object = get_partial_node(s, n, c, flags);
1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641
				if (object) {
					/*
					 * Return the object even if
					 * put_mems_allowed indicated that
					 * the cpuset mems_allowed was
					 * updated in parallel. It's a
					 * harmless race between the alloc
					 * and the cpuset update.
					 */
					put_mems_allowed(cpuset_mems_cookie);
					return object;
				}
1642
			}
C
Christoph Lameter 已提交
1643
		}
1644
	} while (!put_mems_allowed(cpuset_mems_cookie));
C
Christoph Lameter 已提交
1645 1646 1647 1648 1649 1650 1651
#endif
	return NULL;
}

/*
 * Get a partial page, lock it and return it.
 */
1652
static void *get_partial(struct kmem_cache *s, gfp_t flags, int node,
1653
		struct kmem_cache_cpu *c)
C
Christoph Lameter 已提交
1654
{
1655
	void *object;
1656
	int searchnode = (node == NUMA_NO_NODE) ? numa_node_id() : node;
C
Christoph Lameter 已提交
1657

1658
	object = get_partial_node(s, get_node(s, searchnode), c, flags);
1659 1660
	if (object || node != NUMA_NO_NODE)
		return object;
C
Christoph Lameter 已提交
1661

1662
	return get_any_partial(s, flags, c);
C
Christoph Lameter 已提交
1663 1664
}

1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720
#ifdef CONFIG_PREEMPT
/*
 * Calculate the next globally unique transaction for disambiguiation
 * during cmpxchg. The transactions start with the cpu number and are then
 * incremented by CONFIG_NR_CPUS.
 */
#define TID_STEP  roundup_pow_of_two(CONFIG_NR_CPUS)
#else
/*
 * No preemption supported therefore also no need to check for
 * different cpus.
 */
#define TID_STEP 1
#endif

static inline unsigned long next_tid(unsigned long tid)
{
	return tid + TID_STEP;
}

static inline unsigned int tid_to_cpu(unsigned long tid)
{
	return tid % TID_STEP;
}

static inline unsigned long tid_to_event(unsigned long tid)
{
	return tid / TID_STEP;
}

static inline unsigned int init_tid(int cpu)
{
	return cpu;
}

static inline void note_cmpxchg_failure(const char *n,
		const struct kmem_cache *s, unsigned long tid)
{
#ifdef SLUB_DEBUG_CMPXCHG
	unsigned long actual_tid = __this_cpu_read(s->cpu_slab->tid);

	printk(KERN_INFO "%s %s: cmpxchg redo ", n, s->name);

#ifdef CONFIG_PREEMPT
	if (tid_to_cpu(tid) != tid_to_cpu(actual_tid))
		printk("due to cpu change %d -> %d\n",
			tid_to_cpu(tid), tid_to_cpu(actual_tid));
	else
#endif
	if (tid_to_event(tid) != tid_to_event(actual_tid))
		printk("due to cpu running other code. Event %ld->%ld\n",
			tid_to_event(tid), tid_to_event(actual_tid));
	else
		printk("for unknown reason: actual=%lx was=%lx target=%lx\n",
			actual_tid, tid, next_tid(tid));
#endif
1721
	stat(s, CMPXCHG_DOUBLE_CPU_FAIL);
1722 1723
}

1724
static void init_kmem_cache_cpus(struct kmem_cache *s)
1725 1726 1727 1728 1729 1730
{
	int cpu;

	for_each_possible_cpu(cpu)
		per_cpu_ptr(s->cpu_slab, cpu)->tid = init_tid(cpu);
}
1731

C
Christoph Lameter 已提交
1732 1733 1734
/*
 * Remove the cpu slab
 */
1735
static void deactivate_slab(struct kmem_cache *s, struct page *page, void *freelist)
C
Christoph Lameter 已提交
1736
{
1737 1738 1739 1740 1741
	enum slab_modes { M_NONE, M_PARTIAL, M_FULL, M_FREE };
	struct kmem_cache_node *n = get_node(s, page_to_nid(page));
	int lock = 0;
	enum slab_modes l = M_NONE, m = M_NONE;
	void *nextfree;
1742
	int tail = DEACTIVATE_TO_HEAD;
1743 1744 1745 1746
	struct page new;
	struct page old;

	if (page->freelist) {
1747
		stat(s, DEACTIVATE_REMOTE_FREES);
1748
		tail = DEACTIVATE_TO_TAIL;
1749 1750
	}

1751
	/*
1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770
	 * Stage one: Free all available per cpu objects back
	 * to the page freelist while it is still frozen. Leave the
	 * last one.
	 *
	 * There is no need to take the list->lock because the page
	 * is still frozen.
	 */
	while (freelist && (nextfree = get_freepointer(s, freelist))) {
		void *prior;
		unsigned long counters;

		do {
			prior = page->freelist;
			counters = page->counters;
			set_freepointer(s, freelist, prior);
			new.counters = counters;
			new.inuse--;
			VM_BUG_ON(!new.frozen);

1771
		} while (!__cmpxchg_double_slab(s, page,
1772 1773 1774 1775 1776 1777 1778
			prior, counters,
			freelist, new.counters,
			"drain percpu freelist"));

		freelist = nextfree;
	}

1779
	/*
1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791
	 * Stage two: Ensure that the page is unfrozen while the
	 * list presence reflects the actual number of objects
	 * during unfreeze.
	 *
	 * We setup the list membership and then perform a cmpxchg
	 * with the count. If there is a mismatch then the page
	 * is not unfrozen but the page is on the wrong list.
	 *
	 * Then we restart the process which may have to remove
	 * the page from the list that we just put it on again
	 * because the number of objects in the slab may have
	 * changed.
1792
	 */
1793
redo:
1794

1795 1796 1797
	old.freelist = page->freelist;
	old.counters = page->counters;
	VM_BUG_ON(!old.frozen);
1798

1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809
	/* Determine target state of the slab */
	new.counters = old.counters;
	if (freelist) {
		new.inuse--;
		set_freepointer(s, freelist, old.freelist);
		new.freelist = freelist;
	} else
		new.freelist = old.freelist;

	new.frozen = 0;

1810
	if (!new.inuse && n->nr_partial > s->min_partial)
1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842
		m = M_FREE;
	else if (new.freelist) {
		m = M_PARTIAL;
		if (!lock) {
			lock = 1;
			/*
			 * Taking the spinlock removes the possiblity
			 * that acquire_slab() will see a slab page that
			 * is frozen
			 */
			spin_lock(&n->list_lock);
		}
	} else {
		m = M_FULL;
		if (kmem_cache_debug(s) && !lock) {
			lock = 1;
			/*
			 * This also ensures that the scanning of full
			 * slabs from diagnostic functions will not see
			 * any frozen slabs.
			 */
			spin_lock(&n->list_lock);
		}
	}

	if (l != m) {

		if (l == M_PARTIAL)

			remove_partial(n, page);

		else if (l == M_FULL)
1843

1844 1845 1846 1847 1848
			remove_full(s, page);

		if (m == M_PARTIAL) {

			add_partial(n, page, tail);
1849
			stat(s, tail);
1850 1851

		} else if (m == M_FULL) {
1852

1853 1854 1855 1856 1857 1858 1859
			stat(s, DEACTIVATE_FULL);
			add_full(s, n, page);

		}
	}

	l = m;
1860
	if (!__cmpxchg_double_slab(s, page,
1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872
				old.freelist, old.counters,
				new.freelist, new.counters,
				"unfreezing slab"))
		goto redo;

	if (lock)
		spin_unlock(&n->list_lock);

	if (m == M_FREE) {
		stat(s, DEACTIVATE_EMPTY);
		discard_slab(s, page);
		stat(s, FREE_SLAB);
1873
	}
C
Christoph Lameter 已提交
1874 1875
}

1876 1877 1878
/*
 * Unfreeze all the cpu partial slabs.
 *
1879 1880 1881
 * This function must be called with interrupts disabled
 * for the cpu using c (or some other guarantee must be there
 * to guarantee no concurrent accesses).
1882
 */
1883 1884
static void unfreeze_partials(struct kmem_cache *s,
		struct kmem_cache_cpu *c)
1885
{
1886
	struct kmem_cache_node *n = NULL, *n2 = NULL;
1887
	struct page *page, *discard_page = NULL;
1888 1889 1890 1891 1892 1893

	while ((page = c->partial)) {
		struct page new;
		struct page old;

		c->partial = page->next;
1894 1895 1896 1897 1898 1899 1900 1901 1902

		n2 = get_node(s, page_to_nid(page));
		if (n != n2) {
			if (n)
				spin_unlock(&n->list_lock);

			n = n2;
			spin_lock(&n->list_lock);
		}
1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914

		do {

			old.freelist = page->freelist;
			old.counters = page->counters;
			VM_BUG_ON(!old.frozen);

			new.counters = old.counters;
			new.freelist = old.freelist;

			new.frozen = 0;

1915
		} while (!__cmpxchg_double_slab(s, page,
1916 1917 1918 1919
				old.freelist, old.counters,
				new.freelist, new.counters,
				"unfreezing slab"));

1920
		if (unlikely(!new.inuse && n->nr_partial > s->min_partial)) {
1921 1922
			page->next = discard_page;
			discard_page = page;
1923 1924 1925
		} else {
			add_partial(n, page, DEACTIVATE_TO_TAIL);
			stat(s, FREE_ADD_PARTIAL);
1926 1927 1928 1929 1930
		}
	}

	if (n)
		spin_unlock(&n->list_lock);
1931 1932 1933 1934 1935 1936 1937 1938 1939

	while (discard_page) {
		page = discard_page;
		discard_page = discard_page->next;

		stat(s, DEACTIVATE_EMPTY);
		discard_slab(s, page);
		stat(s, FREE_SLAB);
	}
1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950
}

/*
 * Put a page that was just frozen (in __slab_free) into a partial page
 * slot if available. This is done without interrupts disabled and without
 * preemption disabled. The cmpxchg is racy and may put the partial page
 * onto a random cpus partial slot.
 *
 * If we did not find a slot then simply move all the partials to the
 * per node partial list.
 */
1951
static void put_cpu_partial(struct kmem_cache *s, struct page *page, int drain)
1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971
{
	struct page *oldpage;
	int pages;
	int pobjects;

	do {
		pages = 0;
		pobjects = 0;
		oldpage = this_cpu_read(s->cpu_slab->partial);

		if (oldpage) {
			pobjects = oldpage->pobjects;
			pages = oldpage->pages;
			if (drain && pobjects > s->cpu_partial) {
				unsigned long flags;
				/*
				 * partial array is full. Move the existing
				 * set to the per node partial list.
				 */
				local_irq_save(flags);
1972
				unfreeze_partials(s, this_cpu_ptr(s->cpu_slab));
1973
				local_irq_restore(flags);
1974
				oldpage = NULL;
1975 1976
				pobjects = 0;
				pages = 0;
1977
				stat(s, CPU_PARTIAL_DRAIN);
1978 1979 1980 1981 1982 1983 1984 1985 1986 1987
			}
		}

		pages++;
		pobjects += page->objects - page->inuse;

		page->pages = pages;
		page->pobjects = pobjects;
		page->next = oldpage;

1988
	} while (this_cpu_cmpxchg(s->cpu_slab->partial, oldpage, page) != oldpage);
1989 1990
}

1991
static inline void flush_slab(struct kmem_cache *s, struct kmem_cache_cpu *c)
C
Christoph Lameter 已提交
1992
{
1993
	stat(s, CPUSLAB_FLUSH);
1994 1995 1996 1997 1998
	deactivate_slab(s, c->page, c->freelist);

	c->tid = next_tid(c->tid);
	c->page = NULL;
	c->freelist = NULL;
C
Christoph Lameter 已提交
1999 2000 2001 2002
}

/*
 * Flush cpu slab.
C
Christoph Lameter 已提交
2003
 *
C
Christoph Lameter 已提交
2004 2005
 * Called from IPI handler with interrupts disabled.
 */
2006
static inline void __flush_cpu_slab(struct kmem_cache *s, int cpu)
C
Christoph Lameter 已提交
2007
{
2008
	struct kmem_cache_cpu *c = per_cpu_ptr(s->cpu_slab, cpu);
C
Christoph Lameter 已提交
2009

2010 2011 2012 2013
	if (likely(c)) {
		if (c->page)
			flush_slab(s, c);

2014
		unfreeze_partials(s, c);
2015
	}
C
Christoph Lameter 已提交
2016 2017 2018 2019 2020 2021
}

static void flush_cpu_slab(void *d)
{
	struct kmem_cache *s = d;

2022
	__flush_cpu_slab(s, smp_processor_id());
C
Christoph Lameter 已提交
2023 2024
}

2025 2026 2027 2028 2029
static bool has_cpu_slab(int cpu, void *info)
{
	struct kmem_cache *s = info;
	struct kmem_cache_cpu *c = per_cpu_ptr(s->cpu_slab, cpu);

2030
	return c->page || c->partial;
2031 2032
}

C
Christoph Lameter 已提交
2033 2034
static void flush_all(struct kmem_cache *s)
{
2035
	on_each_cpu_cond(has_cpu_slab, flush_cpu_slab, s, 1, GFP_ATOMIC);
C
Christoph Lameter 已提交
2036 2037
}

2038 2039 2040 2041
/*
 * Check if the objects in a per cpu structure fit numa
 * locality expectations.
 */
2042
static inline int node_match(struct page *page, int node)
2043 2044
{
#ifdef CONFIG_NUMA
2045
	if (node != NUMA_NO_NODE && page_to_nid(page) != node)
2046 2047 2048 2049 2050
		return 0;
#endif
	return 1;
}

P
Pekka Enberg 已提交
2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069
static int count_free(struct page *page)
{
	return page->objects - page->inuse;
}

static unsigned long count_partial(struct kmem_cache_node *n,
					int (*get_count)(struct page *))
{
	unsigned long flags;
	unsigned long x = 0;
	struct page *page;

	spin_lock_irqsave(&n->list_lock, flags);
	list_for_each_entry(page, &n->partial, lru)
		x += get_count(page);
	spin_unlock_irqrestore(&n->list_lock, flags);
	return x;
}

2070 2071 2072 2073 2074 2075 2076 2077 2078
static inline unsigned long node_nr_objs(struct kmem_cache_node *n)
{
#ifdef CONFIG_SLUB_DEBUG
	return atomic_long_read(&n->total_objects);
#else
	return 0;
#endif
}

P
Pekka Enberg 已提交
2079 2080 2081 2082 2083 2084 2085 2086 2087
static noinline void
slab_out_of_memory(struct kmem_cache *s, gfp_t gfpflags, int nid)
{
	int node;

	printk(KERN_WARNING
		"SLUB: Unable to allocate memory on node %d (gfp=0x%x)\n",
		nid, gfpflags);
	printk(KERN_WARNING "  cache: %s, object size: %d, buffer size: %d, "
2088
		"default order: %d, min order: %d\n", s->name, s->object_size,
P
Pekka Enberg 已提交
2089 2090
		s->size, oo_order(s->oo), oo_order(s->min));

2091
	if (oo_order(s->min) > get_order(s->object_size))
2092 2093 2094
		printk(KERN_WARNING "  %s debugging increased min order, use "
		       "slub_debug=O to disable.\n", s->name);

P
Pekka Enberg 已提交
2095 2096 2097 2098 2099 2100 2101 2102 2103
	for_each_online_node(node) {
		struct kmem_cache_node *n = get_node(s, node);
		unsigned long nr_slabs;
		unsigned long nr_objs;
		unsigned long nr_free;

		if (!n)
			continue;

2104 2105 2106
		nr_free  = count_partial(n, count_free);
		nr_slabs = node_nr_slabs(n);
		nr_objs  = node_nr_objs(n);
P
Pekka Enberg 已提交
2107 2108 2109 2110 2111 2112 2113

		printk(KERN_WARNING
			"  node %d: slabs: %ld, objs: %ld, free: %ld\n",
			node, nr_slabs, nr_objs, nr_free);
	}
}

2114 2115 2116
static inline void *new_slab_objects(struct kmem_cache *s, gfp_t flags,
			int node, struct kmem_cache_cpu **pc)
{
2117
	void *freelist;
2118 2119
	struct kmem_cache_cpu *c = *pc;
	struct page *page;
2120

2121
	freelist = get_partial(s, flags, node, c);
2122

2123 2124 2125 2126
	if (freelist)
		return freelist;

	page = new_slab(s, flags, node);
2127 2128 2129 2130 2131 2132 2133 2134 2135
	if (page) {
		c = __this_cpu_ptr(s->cpu_slab);
		if (c->page)
			flush_slab(s, c);

		/*
		 * No other reference to the page yet so we can
		 * muck around with it freely without cmpxchg
		 */
2136
		freelist = page->freelist;
2137 2138 2139 2140 2141 2142
		page->freelist = NULL;

		stat(s, ALLOC_SLAB);
		c->page = page;
		*pc = c;
	} else
2143
		freelist = NULL;
2144

2145
	return freelist;
2146 2147
}

2148 2149 2150 2151 2152 2153 2154 2155
static inline bool pfmemalloc_match(struct page *page, gfp_t gfpflags)
{
	if (unlikely(PageSlabPfmemalloc(page)))
		return gfp_pfmemalloc_allowed(gfpflags);

	return true;
}

2156 2157 2158 2159 2160 2161 2162
/*
 * Check the page->freelist of a page and either transfer the freelist to the per cpu freelist
 * or deactivate the page.
 *
 * The page is still frozen if the return value is not NULL.
 *
 * If this function returns NULL then the page has been unfrozen.
2163 2164
 *
 * This function must be called with interrupt disabled.
2165 2166 2167 2168 2169 2170 2171 2172 2173 2174
 */
static inline void *get_freelist(struct kmem_cache *s, struct page *page)
{
	struct page new;
	unsigned long counters;
	void *freelist;

	do {
		freelist = page->freelist;
		counters = page->counters;
2175

2176 2177 2178 2179 2180 2181
		new.counters = counters;
		VM_BUG_ON(!new.frozen);

		new.inuse = page->objects;
		new.frozen = freelist != NULL;

2182
	} while (!__cmpxchg_double_slab(s, page,
2183 2184 2185 2186 2187 2188 2189
		freelist, counters,
		NULL, new.counters,
		"get_freelist"));

	return freelist;
}

C
Christoph Lameter 已提交
2190
/*
2191 2192 2193 2194 2195 2196
 * Slow path. The lockless freelist is empty or we need to perform
 * debugging duties.
 *
 * Processing is still very fast if new objects have been freed to the
 * regular freelist. In that case we simply take over the regular freelist
 * as the lockless freelist and zap the regular freelist.
C
Christoph Lameter 已提交
2197
 *
2198 2199 2200
 * If that is not working then we fall back to the partial lists. We take the
 * first element of the freelist as the object to allocate now and move the
 * rest of the freelist to the lockless freelist.
C
Christoph Lameter 已提交
2201
 *
2202
 * And if we were unable to get a new slab from the partial slab lists then
C
Christoph Lameter 已提交
2203 2204
 * we need to allocate a new slab. This is the slowest path since it involves
 * a call to the page allocator and the setup of a new slab.
C
Christoph Lameter 已提交
2205
 */
2206 2207
static void *__slab_alloc(struct kmem_cache *s, gfp_t gfpflags, int node,
			  unsigned long addr, struct kmem_cache_cpu *c)
C
Christoph Lameter 已提交
2208
{
2209
	void *freelist;
2210
	struct page *page;
2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221
	unsigned long flags;

	local_irq_save(flags);
#ifdef CONFIG_PREEMPT
	/*
	 * We may have been preempted and rescheduled on a different
	 * cpu before disabling interrupts. Need to reload cpu area
	 * pointer.
	 */
	c = this_cpu_ptr(s->cpu_slab);
#endif
C
Christoph Lameter 已提交
2222

2223 2224
	page = c->page;
	if (!page)
C
Christoph Lameter 已提交
2225
		goto new_slab;
2226
redo:
2227

2228
	if (unlikely(!node_match(page, node))) {
2229
		stat(s, ALLOC_NODE_MISMATCH);
2230
		deactivate_slab(s, page, c->freelist);
2231 2232
		c->page = NULL;
		c->freelist = NULL;
2233 2234
		goto new_slab;
	}
C
Christoph Lameter 已提交
2235

2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247
	/*
	 * By rights, we should be searching for a slab page that was
	 * PFMEMALLOC but right now, we are losing the pfmemalloc
	 * information when the page leaves the per-cpu allocator
	 */
	if (unlikely(!pfmemalloc_match(page, gfpflags))) {
		deactivate_slab(s, page, c->freelist);
		c->page = NULL;
		c->freelist = NULL;
		goto new_slab;
	}

2248
	/* must check again c->freelist in case of cpu migration or IRQ */
2249 2250
	freelist = c->freelist;
	if (freelist)
2251
		goto load_freelist;
2252

2253
	stat(s, ALLOC_SLOWPATH);
2254

2255
	freelist = get_freelist(s, page);
C
Christoph Lameter 已提交
2256

2257
	if (!freelist) {
2258 2259
		c->page = NULL;
		stat(s, DEACTIVATE_BYPASS);
2260
		goto new_slab;
2261
	}
C
Christoph Lameter 已提交
2262

2263
	stat(s, ALLOC_REFILL);
C
Christoph Lameter 已提交
2264

2265
load_freelist:
2266 2267 2268 2269 2270 2271
	/*
	 * freelist is pointing to the list of objects to be used.
	 * page is pointing to the page from which the objects are obtained.
	 * That page must be frozen for per cpu allocations to work.
	 */
	VM_BUG_ON(!c->page->frozen);
2272
	c->freelist = get_freepointer(s, freelist);
2273 2274
	c->tid = next_tid(c->tid);
	local_irq_restore(flags);
2275
	return freelist;
C
Christoph Lameter 已提交
2276 2277

new_slab:
2278

2279
	if (c->partial) {
2280 2281
		page = c->page = c->partial;
		c->partial = page->next;
2282 2283 2284
		stat(s, CPU_PARTIAL_ALLOC);
		c->freelist = NULL;
		goto redo;
C
Christoph Lameter 已提交
2285 2286
	}

2287
	freelist = new_slab_objects(s, gfpflags, node, &c);
2288

2289 2290 2291
	if (unlikely(!freelist)) {
		if (!(gfpflags & __GFP_NOWARN) && printk_ratelimit())
			slab_out_of_memory(s, gfpflags, node);
2292

2293 2294
		local_irq_restore(flags);
		return NULL;
C
Christoph Lameter 已提交
2295
	}
2296

2297
	page = c->page;
2298
	if (likely(!kmem_cache_debug(s) && pfmemalloc_match(page, gfpflags)))
2299
		goto load_freelist;
2300

2301
	/* Only entered in the debug case */
2302
	if (kmem_cache_debug(s) && !alloc_debug_processing(s, page, freelist, addr))
2303
		goto new_slab;	/* Slab failed checks. Next slab needed */
2304

2305
	deactivate_slab(s, page, get_freepointer(s, freelist));
2306 2307
	c->page = NULL;
	c->freelist = NULL;
2308
	local_irq_restore(flags);
2309
	return freelist;
2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321
}

/*
 * Inlined fastpath so that allocation functions (kmalloc, kmem_cache_alloc)
 * have the fastpath folded into their functions. So no function call
 * overhead for requests that can be satisfied on the fastpath.
 *
 * The fastpath works by first checking if the lockless freelist can be used.
 * If not then __slab_alloc is called for slow processing.
 *
 * Otherwise we can simply pick the next object from the lockless free list.
 */
2322
static __always_inline void *slab_alloc_node(struct kmem_cache *s,
2323
		gfp_t gfpflags, int node, unsigned long addr)
2324 2325
{
	void **object;
2326
	struct kmem_cache_cpu *c;
2327
	struct page *page;
2328
	unsigned long tid;
2329

2330
	if (slab_pre_alloc_hook(s, gfpflags))
A
Akinobu Mita 已提交
2331
		return NULL;
2332

2333
	s = memcg_kmem_get_cache(s, gfpflags);
2334 2335 2336 2337 2338 2339 2340 2341
redo:

	/*
	 * Must read kmem_cache cpu data via this cpu ptr. Preemption is
	 * enabled. We may switch back and forth between cpus while
	 * reading from one cpu area. That does not matter as long
	 * as we end up on the original cpu again when doing the cmpxchg.
	 */
2342
	c = __this_cpu_ptr(s->cpu_slab);
2343 2344 2345 2346 2347 2348 2349 2350 2351 2352

	/*
	 * The transaction ids are globally unique per cpu and per operation on
	 * a per cpu queue. Thus they can be guarantee that the cmpxchg_double
	 * occurs on the right processor and that there was no operation on the
	 * linked list in between.
	 */
	tid = c->tid;
	barrier();

2353
	object = c->freelist;
2354
	page = c->page;
2355
	if (unlikely(!object || !node_match(page, node)))
2356
		object = __slab_alloc(s, gfpflags, node, addr, c);
2357 2358

	else {
2359 2360
		void *next_object = get_freepointer_safe(s, object);

2361
		/*
L
Lucas De Marchi 已提交
2362
		 * The cmpxchg will only match if there was no additional
2363 2364 2365 2366 2367 2368 2369 2370 2371 2372
		 * operation and if we are on the right processor.
		 *
		 * The cmpxchg does the following atomically (without lock semantics!)
		 * 1. Relocate first pointer to the current per cpu area.
		 * 2. Verify that tid and freelist have not been changed
		 * 3. If they were not changed replace tid and freelist
		 *
		 * Since this is without lock semantics the protection is only against
		 * code executing on this cpu *not* from access by other cpus.
		 */
2373
		if (unlikely(!this_cpu_cmpxchg_double(
2374 2375
				s->cpu_slab->freelist, s->cpu_slab->tid,
				object, tid,
2376
				next_object, next_tid(tid)))) {
2377 2378 2379 2380

			note_cmpxchg_failure("slab_alloc", s, tid);
			goto redo;
		}
2381
		prefetch_freepointer(s, next_object);
2382
		stat(s, ALLOC_FASTPATH);
2383
	}
2384

2385
	if (unlikely(gfpflags & __GFP_ZERO) && object)
2386
		memset(object, 0, s->object_size);
2387

2388
	slab_post_alloc_hook(s, gfpflags, object);
V
Vegard Nossum 已提交
2389

2390
	return object;
C
Christoph Lameter 已提交
2391 2392
}

2393 2394 2395 2396 2397 2398
static __always_inline void *slab_alloc(struct kmem_cache *s,
		gfp_t gfpflags, unsigned long addr)
{
	return slab_alloc_node(s, gfpflags, NUMA_NO_NODE, addr);
}

C
Christoph Lameter 已提交
2399 2400
void *kmem_cache_alloc(struct kmem_cache *s, gfp_t gfpflags)
{
2401
	void *ret = slab_alloc(s, gfpflags, _RET_IP_);
E
Eduard - Gabriel Munteanu 已提交
2402

2403
	trace_kmem_cache_alloc(_RET_IP_, ret, s->object_size, s->size, gfpflags);
E
Eduard - Gabriel Munteanu 已提交
2404 2405

	return ret;
C
Christoph Lameter 已提交
2406 2407 2408
}
EXPORT_SYMBOL(kmem_cache_alloc);

2409
#ifdef CONFIG_TRACING
2410 2411
void *kmem_cache_alloc_trace(struct kmem_cache *s, gfp_t gfpflags, size_t size)
{
2412
	void *ret = slab_alloc(s, gfpflags, _RET_IP_);
2413 2414 2415 2416 2417 2418
	trace_kmalloc(_RET_IP_, ret, size, s->size, gfpflags);
	return ret;
}
EXPORT_SYMBOL(kmem_cache_alloc_trace);

void *kmalloc_order_trace(size_t size, gfp_t flags, unsigned int order)
E
Eduard - Gabriel Munteanu 已提交
2419
{
2420 2421 2422
	void *ret = kmalloc_order(size, flags, order);
	trace_kmalloc(_RET_IP_, ret, size, PAGE_SIZE << order, flags);
	return ret;
E
Eduard - Gabriel Munteanu 已提交
2423
}
2424
EXPORT_SYMBOL(kmalloc_order_trace);
E
Eduard - Gabriel Munteanu 已提交
2425 2426
#endif

C
Christoph Lameter 已提交
2427 2428 2429
#ifdef CONFIG_NUMA
void *kmem_cache_alloc_node(struct kmem_cache *s, gfp_t gfpflags, int node)
{
2430
	void *ret = slab_alloc_node(s, gfpflags, node, _RET_IP_);
E
Eduard - Gabriel Munteanu 已提交
2431

2432
	trace_kmem_cache_alloc_node(_RET_IP_, ret,
2433
				    s->object_size, s->size, gfpflags, node);
E
Eduard - Gabriel Munteanu 已提交
2434 2435

	return ret;
C
Christoph Lameter 已提交
2436 2437 2438
}
EXPORT_SYMBOL(kmem_cache_alloc_node);

2439
#ifdef CONFIG_TRACING
2440
void *kmem_cache_alloc_node_trace(struct kmem_cache *s,
E
Eduard - Gabriel Munteanu 已提交
2441
				    gfp_t gfpflags,
2442
				    int node, size_t size)
E
Eduard - Gabriel Munteanu 已提交
2443
{
2444
	void *ret = slab_alloc_node(s, gfpflags, node, _RET_IP_);
2445 2446 2447 2448

	trace_kmalloc_node(_RET_IP_, ret,
			   size, s->size, gfpflags, node);
	return ret;
E
Eduard - Gabriel Munteanu 已提交
2449
}
2450
EXPORT_SYMBOL(kmem_cache_alloc_node_trace);
E
Eduard - Gabriel Munteanu 已提交
2451
#endif
2452
#endif
E
Eduard - Gabriel Munteanu 已提交
2453

C
Christoph Lameter 已提交
2454
/*
2455 2456
 * Slow patch handling. This may still be called frequently since objects
 * have a longer lifetime than the cpu slabs in most processing loads.
C
Christoph Lameter 已提交
2457
 *
2458 2459 2460
 * So we still attempt to reduce cache line usage. Just take the slab
 * lock and free the item. If there is no additional partial page
 * handling required then we can return immediately.
C
Christoph Lameter 已提交
2461
 */
2462
static void __slab_free(struct kmem_cache *s, struct page *page,
2463
			void *x, unsigned long addr)
C
Christoph Lameter 已提交
2464 2465 2466
{
	void *prior;
	void **object = (void *)x;
2467 2468 2469 2470
	int was_frozen;
	struct page new;
	unsigned long counters;
	struct kmem_cache_node *n = NULL;
2471
	unsigned long uninitialized_var(flags);
C
Christoph Lameter 已提交
2472

2473
	stat(s, FREE_SLOWPATH);
C
Christoph Lameter 已提交
2474

2475 2476
	if (kmem_cache_debug(s) &&
		!(n = free_debug_processing(s, page, x, addr, &flags)))
2477
		return;
C
Christoph Lameter 已提交
2478

2479
	do {
2480 2481 2482 2483
		if (unlikely(n)) {
			spin_unlock_irqrestore(&n->list_lock, flags);
			n = NULL;
		}
2484 2485 2486 2487 2488 2489
		prior = page->freelist;
		counters = page->counters;
		set_freepointer(s, object, prior);
		new.counters = counters;
		was_frozen = new.frozen;
		new.inuse--;
2490
		if ((!new.inuse || !prior) && !was_frozen) {
2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513

			if (!kmem_cache_debug(s) && !prior)

				/*
				 * Slab was on no list before and will be partially empty
				 * We can defer the list move and instead freeze it.
				 */
				new.frozen = 1;

			else { /* Needs to be taken off a list */

	                        n = get_node(s, page_to_nid(page));
				/*
				 * Speculatively acquire the list_lock.
				 * If the cmpxchg does not succeed then we may
				 * drop the list_lock without any processing.
				 *
				 * Otherwise the list_lock will synchronize with
				 * other processors updating the list of slabs.
				 */
				spin_lock_irqsave(&n->list_lock, flags);

			}
2514
		}
C
Christoph Lameter 已提交
2515

2516 2517 2518 2519
	} while (!cmpxchg_double_slab(s, page,
		prior, counters,
		object, new.counters,
		"__slab_free"));
C
Christoph Lameter 已提交
2520

2521
	if (likely(!n)) {
2522 2523 2524 2525 2526

		/*
		 * If we just froze the page then put it onto the
		 * per cpu partial list.
		 */
2527
		if (new.frozen && !was_frozen) {
2528
			put_cpu_partial(s, page, 1);
2529 2530
			stat(s, CPU_PARTIAL_FREE);
		}
2531
		/*
2532 2533 2534 2535 2536
		 * The list lock was not taken therefore no list
		 * activity can be necessary.
		 */
                if (was_frozen)
                        stat(s, FREE_FROZEN);
2537
                return;
2538
        }
C
Christoph Lameter 已提交
2539

2540 2541 2542
	if (unlikely(!new.inuse && n->nr_partial > s->min_partial))
		goto slab_empty;

C
Christoph Lameter 已提交
2543
	/*
2544 2545
	 * Objects left in the slab. If it was not on the partial list before
	 * then add it.
C
Christoph Lameter 已提交
2546
	 */
2547 2548 2549 2550
	if (kmem_cache_debug(s) && unlikely(!prior)) {
		remove_full(s, page);
		add_partial(n, page, DEACTIVATE_TO_TAIL);
		stat(s, FREE_ADD_PARTIAL);
2551
	}
2552
	spin_unlock_irqrestore(&n->list_lock, flags);
C
Christoph Lameter 已提交
2553 2554 2555
	return;

slab_empty:
2556
	if (prior) {
C
Christoph Lameter 已提交
2557
		/*
2558
		 * Slab on the partial list.
C
Christoph Lameter 已提交
2559
		 */
2560
		remove_partial(n, page);
2561
		stat(s, FREE_REMOVE_PARTIAL);
2562 2563 2564
	} else
		/* Slab must be on the full list */
		remove_full(s, page);
2565

2566
	spin_unlock_irqrestore(&n->list_lock, flags);
2567
	stat(s, FREE_SLAB);
C
Christoph Lameter 已提交
2568 2569 2570
	discard_slab(s, page);
}

2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581
/*
 * Fastpath with forced inlining to produce a kfree and kmem_cache_free that
 * can perform fastpath freeing without additional function calls.
 *
 * The fastpath is only possible if we are freeing to the current cpu slab
 * of this processor. This typically the case if we have just allocated
 * the item before.
 *
 * If fastpath is not possible then fall back to __slab_free where we deal
 * with all sorts of special processing.
 */
P
Pekka Enberg 已提交
2582
static __always_inline void slab_free(struct kmem_cache *s,
2583
			struct page *page, void *x, unsigned long addr)
2584 2585
{
	void **object = (void *)x;
2586
	struct kmem_cache_cpu *c;
2587
	unsigned long tid;
2588

2589 2590
	slab_free_hook(s, x);

2591 2592 2593 2594 2595 2596 2597
redo:
	/*
	 * Determine the currently cpus per cpu slab.
	 * The cpu may change afterward. However that does not matter since
	 * data is retrieved via this pointer. If we are on the same cpu
	 * during the cmpxchg then the free will succedd.
	 */
2598
	c = __this_cpu_ptr(s->cpu_slab);
2599

2600 2601
	tid = c->tid;
	barrier();
2602

2603
	if (likely(page == c->page)) {
2604
		set_freepointer(s, object, c->freelist);
2605

2606
		if (unlikely(!this_cpu_cmpxchg_double(
2607 2608 2609 2610 2611 2612 2613
				s->cpu_slab->freelist, s->cpu_slab->tid,
				c->freelist, tid,
				object, next_tid(tid)))) {

			note_cmpxchg_failure("slab_free", s, tid);
			goto redo;
		}
2614
		stat(s, FREE_FASTPATH);
2615
	} else
2616
		__slab_free(s, page, x, addr);
2617 2618 2619

}

C
Christoph Lameter 已提交
2620 2621
void kmem_cache_free(struct kmem_cache *s, void *x)
{
2622 2623
	s = cache_from_obj(s, x);
	if (!s)
2624
		return;
2625
	slab_free(s, virt_to_head_page(x), x, _RET_IP_);
2626
	trace_kmem_cache_free(_RET_IP_, x);
C
Christoph Lameter 已提交
2627 2628 2629 2630
}
EXPORT_SYMBOL(kmem_cache_free);

/*
C
Christoph Lameter 已提交
2631 2632 2633 2634
 * Object placement in a slab is made very easy because we always start at
 * offset 0. If we tune the size of the object to the alignment then we can
 * get the required alignment by putting one properly sized object after
 * another.
C
Christoph Lameter 已提交
2635 2636 2637 2638
 *
 * Notice that the allocation order determines the sizes of the per cpu
 * caches. Each processor has always one slab available for allocations.
 * Increasing the allocation order reduces the number of times that slabs
C
Christoph Lameter 已提交
2639
 * must be moved on and off the partial lists and is therefore a factor in
C
Christoph Lameter 已提交
2640 2641 2642 2643 2644 2645 2646 2647 2648 2649
 * locking overhead.
 */

/*
 * Mininum / Maximum order of slab pages. This influences locking overhead
 * and slab fragmentation. A higher order reduces the number of partial slabs
 * and increases the number of allocations possible without having to
 * take the list_lock.
 */
static int slub_min_order;
2650
static int slub_max_order = PAGE_ALLOC_COSTLY_ORDER;
2651
static int slub_min_objects;
C
Christoph Lameter 已提交
2652 2653 2654

/*
 * Merge control. If this is set then no merging of slab caches will occur.
C
Christoph Lameter 已提交
2655
 * (Could be removed. This was introduced to pacify the merge skeptics.)
C
Christoph Lameter 已提交
2656 2657 2658 2659 2660 2661
 */
static int slub_nomerge;

/*
 * Calculate the order of allocation given an slab object size.
 *
C
Christoph Lameter 已提交
2662 2663 2664 2665
 * The order of allocation has significant impact on performance and other
 * system components. Generally order 0 allocations should be preferred since
 * order 0 does not cause fragmentation in the page allocator. Larger objects
 * be problematic to put into order 0 slabs because there may be too much
C
Christoph Lameter 已提交
2666
 * unused space left. We go to a higher order if more than 1/16th of the slab
C
Christoph Lameter 已提交
2667 2668 2669 2670 2671 2672
 * would be wasted.
 *
 * In order to reach satisfactory performance we must ensure that a minimum
 * number of objects is in one slab. Otherwise we may generate too much
 * activity on the partial lists which requires taking the list_lock. This is
 * less a concern for large slabs though which are rarely used.
C
Christoph Lameter 已提交
2673
 *
C
Christoph Lameter 已提交
2674 2675 2676 2677
 * slub_max_order specifies the order where we begin to stop considering the
 * number of objects in a slab as critical. If we reach slub_max_order then
 * we try to keep the page order as low as possible. So we accept more waste
 * of space in favor of a small page order.
C
Christoph Lameter 已提交
2678
 *
C
Christoph Lameter 已提交
2679 2680 2681 2682
 * Higher order allocations also allow the placement of more objects in a
 * slab and thereby reduce object handling overhead. If the user has
 * requested a higher mininum order then we start with that one instead of
 * the smallest order which will fit the object.
C
Christoph Lameter 已提交
2683
 */
2684
static inline int slab_order(int size, int min_objects,
2685
				int max_order, int fract_leftover, int reserved)
C
Christoph Lameter 已提交
2686 2687 2688
{
	int order;
	int rem;
2689
	int min_order = slub_min_order;
C
Christoph Lameter 已提交
2690

2691
	if (order_objects(min_order, size, reserved) > MAX_OBJS_PER_PAGE)
2692
		return get_order(size * MAX_OBJS_PER_PAGE) - 1;
2693

2694
	for (order = max(min_order,
2695 2696
				fls(min_objects * size - 1) - PAGE_SHIFT);
			order <= max_order; order++) {
C
Christoph Lameter 已提交
2697

2698
		unsigned long slab_size = PAGE_SIZE << order;
C
Christoph Lameter 已提交
2699

2700
		if (slab_size < min_objects * size + reserved)
C
Christoph Lameter 已提交
2701 2702
			continue;

2703
		rem = (slab_size - reserved) % size;
C
Christoph Lameter 已提交
2704

2705
		if (rem <= slab_size / fract_leftover)
C
Christoph Lameter 已提交
2706 2707 2708
			break;

	}
C
Christoph Lameter 已提交
2709

C
Christoph Lameter 已提交
2710 2711 2712
	return order;
}

2713
static inline int calculate_order(int size, int reserved)
2714 2715 2716 2717
{
	int order;
	int min_objects;
	int fraction;
2718
	int max_objects;
2719 2720 2721 2722 2723 2724 2725 2726 2727 2728

	/*
	 * Attempt to find best configuration for a slab. This
	 * works by first attempting to generate a layout with
	 * the best configuration and backing off gradually.
	 *
	 * First we reduce the acceptable waste in a slab. Then
	 * we reduce the minimum objects required in a slab.
	 */
	min_objects = slub_min_objects;
2729 2730
	if (!min_objects)
		min_objects = 4 * (fls(nr_cpu_ids) + 1);
2731
	max_objects = order_objects(slub_max_order, size, reserved);
2732 2733
	min_objects = min(min_objects, max_objects);

2734
	while (min_objects > 1) {
C
Christoph Lameter 已提交
2735
		fraction = 16;
2736 2737
		while (fraction >= 4) {
			order = slab_order(size, min_objects,
2738
					slub_max_order, fraction, reserved);
2739 2740 2741 2742
			if (order <= slub_max_order)
				return order;
			fraction /= 2;
		}
2743
		min_objects--;
2744 2745 2746 2747 2748 2749
	}

	/*
	 * We were unable to place multiple objects in a slab. Now
	 * lets see if we can place a single object there.
	 */
2750
	order = slab_order(size, 1, slub_max_order, 1, reserved);
2751 2752 2753 2754 2755 2756
	if (order <= slub_max_order)
		return order;

	/*
	 * Doh this slab cannot be placed using slub_max_order.
	 */
2757
	order = slab_order(size, 1, MAX_ORDER, 1, reserved);
D
David Rientjes 已提交
2758
	if (order < MAX_ORDER)
2759 2760 2761 2762
		return order;
	return -ENOSYS;
}

2763
static void
2764
init_kmem_cache_node(struct kmem_cache_node *n)
C
Christoph Lameter 已提交
2765 2766 2767 2768
{
	n->nr_partial = 0;
	spin_lock_init(&n->list_lock);
	INIT_LIST_HEAD(&n->partial);
2769
#ifdef CONFIG_SLUB_DEBUG
2770
	atomic_long_set(&n->nr_slabs, 0);
2771
	atomic_long_set(&n->total_objects, 0);
2772
	INIT_LIST_HEAD(&n->full);
2773
#endif
C
Christoph Lameter 已提交
2774 2775
}

2776
static inline int alloc_kmem_cache_cpus(struct kmem_cache *s)
2777
{
2778
	BUILD_BUG_ON(PERCPU_DYNAMIC_EARLY_SIZE <
2779
			KMALLOC_SHIFT_HIGH * sizeof(struct kmem_cache_cpu));
2780

2781
	/*
2782 2783
	 * Must align to double word boundary for the double cmpxchg
	 * instructions to work; see __pcpu_double_call_return_bool().
2784
	 */
2785 2786
	s->cpu_slab = __alloc_percpu(sizeof(struct kmem_cache_cpu),
				     2 * sizeof(void *));
2787 2788 2789 2790 2791

	if (!s->cpu_slab)
		return 0;

	init_kmem_cache_cpus(s);
2792

2793
	return 1;
2794 2795
}

2796 2797
static struct kmem_cache *kmem_cache_node;

C
Christoph Lameter 已提交
2798 2799 2800 2801 2802 2803
/*
 * No kmalloc_node yet so do it by hand. We know that this is the first
 * slab on the node for this slabcache. There are no concurrent accesses
 * possible.
 *
 * Note that this function only works on the kmalloc_node_cache
2804 2805
 * when allocating for the kmalloc_node_cache. This is used for bootstrapping
 * memory on a fresh node that has no slab structures yet.
C
Christoph Lameter 已提交
2806
 */
2807
static void early_kmem_cache_node_alloc(int node)
C
Christoph Lameter 已提交
2808 2809 2810 2811
{
	struct page *page;
	struct kmem_cache_node *n;

2812
	BUG_ON(kmem_cache_node->size < sizeof(struct kmem_cache_node));
C
Christoph Lameter 已提交
2813

2814
	page = new_slab(kmem_cache_node, GFP_NOWAIT, node);
C
Christoph Lameter 已提交
2815 2816

	BUG_ON(!page);
2817 2818 2819 2820 2821 2822 2823
	if (page_to_nid(page) != node) {
		printk(KERN_ERR "SLUB: Unable to allocate memory from "
				"node %d\n", node);
		printk(KERN_ERR "SLUB: Allocating a useless per node structure "
				"in order to be able to continue\n");
	}

C
Christoph Lameter 已提交
2824 2825
	n = page->freelist;
	BUG_ON(!n);
2826
	page->freelist = get_freepointer(kmem_cache_node, n);
2827
	page->inuse = 1;
2828
	page->frozen = 0;
2829
	kmem_cache_node->node[node] = n;
2830
#ifdef CONFIG_SLUB_DEBUG
2831
	init_object(kmem_cache_node, n, SLUB_RED_ACTIVE);
2832
	init_tracking(kmem_cache_node, n);
2833
#endif
2834
	init_kmem_cache_node(n);
2835
	inc_slabs_node(kmem_cache_node, node, page->objects);
C
Christoph Lameter 已提交
2836

2837
	add_partial(n, page, DEACTIVATE_TO_HEAD);
C
Christoph Lameter 已提交
2838 2839 2840 2841 2842 2843
}

static void free_kmem_cache_nodes(struct kmem_cache *s)
{
	int node;

C
Christoph Lameter 已提交
2844
	for_each_node_state(node, N_NORMAL_MEMORY) {
C
Christoph Lameter 已提交
2845
		struct kmem_cache_node *n = s->node[node];
2846

2847
		if (n)
2848 2849
			kmem_cache_free(kmem_cache_node, n);

C
Christoph Lameter 已提交
2850 2851 2852 2853
		s->node[node] = NULL;
	}
}

2854
static int init_kmem_cache_nodes(struct kmem_cache *s)
C
Christoph Lameter 已提交
2855 2856 2857
{
	int node;

C
Christoph Lameter 已提交
2858
	for_each_node_state(node, N_NORMAL_MEMORY) {
C
Christoph Lameter 已提交
2859 2860
		struct kmem_cache_node *n;

2861
		if (slab_state == DOWN) {
2862
			early_kmem_cache_node_alloc(node);
2863 2864
			continue;
		}
2865
		n = kmem_cache_alloc_node(kmem_cache_node,
2866
						GFP_KERNEL, node);
C
Christoph Lameter 已提交
2867

2868 2869 2870
		if (!n) {
			free_kmem_cache_nodes(s);
			return 0;
C
Christoph Lameter 已提交
2871
		}
2872

C
Christoph Lameter 已提交
2873
		s->node[node] = n;
2874
		init_kmem_cache_node(n);
C
Christoph Lameter 已提交
2875 2876 2877 2878
	}
	return 1;
}

2879
static void set_min_partial(struct kmem_cache *s, unsigned long min)
2880 2881 2882 2883 2884 2885 2886 2887
{
	if (min < MIN_PARTIAL)
		min = MIN_PARTIAL;
	else if (min > MAX_PARTIAL)
		min = MAX_PARTIAL;
	s->min_partial = min;
}

C
Christoph Lameter 已提交
2888 2889 2890 2891
/*
 * calculate_sizes() determines the order and the distribution of data within
 * a slab object.
 */
2892
static int calculate_sizes(struct kmem_cache *s, int forced_order)
C
Christoph Lameter 已提交
2893 2894
{
	unsigned long flags = s->flags;
2895
	unsigned long size = s->object_size;
2896
	int order;
C
Christoph Lameter 已提交
2897

2898 2899 2900 2901 2902 2903 2904 2905
	/*
	 * Round up object size to the next word boundary. We can only
	 * place the free pointer at word boundaries and this determines
	 * the possible location of the free pointer.
	 */
	size = ALIGN(size, sizeof(void *));

#ifdef CONFIG_SLUB_DEBUG
C
Christoph Lameter 已提交
2906 2907 2908 2909 2910 2911
	/*
	 * Determine if we can poison the object itself. If the user of
	 * the slab may touch the object after free or before allocation
	 * then we should never poison the object itself.
	 */
	if ((flags & SLAB_POISON) && !(flags & SLAB_DESTROY_BY_RCU) &&
2912
			!s->ctor)
C
Christoph Lameter 已提交
2913 2914 2915 2916 2917 2918
		s->flags |= __OBJECT_POISON;
	else
		s->flags &= ~__OBJECT_POISON;


	/*
C
Christoph Lameter 已提交
2919
	 * If we are Redzoning then check if there is some space between the
C
Christoph Lameter 已提交
2920
	 * end of the object and the free pointer. If not then add an
C
Christoph Lameter 已提交
2921
	 * additional word to have some bytes to store Redzone information.
C
Christoph Lameter 已提交
2922
	 */
2923
	if ((flags & SLAB_RED_ZONE) && size == s->object_size)
C
Christoph Lameter 已提交
2924
		size += sizeof(void *);
C
Christoph Lameter 已提交
2925
#endif
C
Christoph Lameter 已提交
2926 2927

	/*
C
Christoph Lameter 已提交
2928 2929
	 * With that we have determined the number of bytes in actual use
	 * by the object. This is the potential offset to the free pointer.
C
Christoph Lameter 已提交
2930 2931 2932 2933
	 */
	s->inuse = size;

	if (((flags & (SLAB_DESTROY_BY_RCU | SLAB_POISON)) ||
2934
		s->ctor)) {
C
Christoph Lameter 已提交
2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946
		/*
		 * Relocate free pointer after the object if it is not
		 * permitted to overwrite the first word of the object on
		 * kmem_cache_free.
		 *
		 * This is the case if we do RCU, have a constructor or
		 * destructor or are poisoning the objects.
		 */
		s->offset = size;
		size += sizeof(void *);
	}

2947
#ifdef CONFIG_SLUB_DEBUG
C
Christoph Lameter 已提交
2948 2949 2950 2951 2952 2953 2954
	if (flags & SLAB_STORE_USER)
		/*
		 * Need to store information about allocs and frees after
		 * the object.
		 */
		size += 2 * sizeof(struct track);

2955
	if (flags & SLAB_RED_ZONE)
C
Christoph Lameter 已提交
2956 2957 2958 2959
		/*
		 * Add some empty padding so that we can catch
		 * overwrites from earlier objects rather than let
		 * tracking information or the free pointer be
2960
		 * corrupted if a user writes before the start
C
Christoph Lameter 已提交
2961 2962 2963
		 * of the object.
		 */
		size += sizeof(void *);
C
Christoph Lameter 已提交
2964
#endif
C
Christoph Lameter 已提交
2965

C
Christoph Lameter 已提交
2966 2967 2968 2969 2970
	/*
	 * SLUB stores one object immediately after another beginning from
	 * offset 0. In order to align the objects we have to simply size
	 * each object to conform to the alignment.
	 */
2971
	size = ALIGN(size, s->align);
C
Christoph Lameter 已提交
2972
	s->size = size;
2973 2974 2975
	if (forced_order >= 0)
		order = forced_order;
	else
2976
		order = calculate_order(size, s->reserved);
C
Christoph Lameter 已提交
2977

2978
	if (order < 0)
C
Christoph Lameter 已提交
2979 2980
		return 0;

2981
	s->allocflags = 0;
2982
	if (order)
2983 2984 2985
		s->allocflags |= __GFP_COMP;

	if (s->flags & SLAB_CACHE_DMA)
2986
		s->allocflags |= GFP_DMA;
2987 2988 2989 2990

	if (s->flags & SLAB_RECLAIM_ACCOUNT)
		s->allocflags |= __GFP_RECLAIMABLE;

C
Christoph Lameter 已提交
2991 2992 2993
	/*
	 * Determine the number of objects per slab
	 */
2994 2995
	s->oo = oo_make(order, size, s->reserved);
	s->min = oo_make(get_order(size), size, s->reserved);
2996 2997
	if (oo_objects(s->oo) > oo_objects(s->max))
		s->max = s->oo;
C
Christoph Lameter 已提交
2998

2999
	return !!oo_objects(s->oo);
C
Christoph Lameter 已提交
3000 3001
}

3002
static int kmem_cache_open(struct kmem_cache *s, unsigned long flags)
C
Christoph Lameter 已提交
3003
{
3004
	s->flags = kmem_cache_flags(s->size, flags, s->name, s->ctor);
3005
	s->reserved = 0;
C
Christoph Lameter 已提交
3006

3007 3008
	if (need_reserve_slab_rcu && (s->flags & SLAB_DESTROY_BY_RCU))
		s->reserved = sizeof(struct rcu_head);
C
Christoph Lameter 已提交
3009

3010
	if (!calculate_sizes(s, -1))
C
Christoph Lameter 已提交
3011
		goto error;
3012 3013 3014 3015 3016
	if (disable_higher_order_debug) {
		/*
		 * Disable debugging flags that store metadata if the min slab
		 * order increased.
		 */
3017
		if (get_order(s->size) > get_order(s->object_size)) {
3018 3019 3020 3021 3022 3023
			s->flags &= ~DEBUG_METADATA_FLAGS;
			s->offset = 0;
			if (!calculate_sizes(s, -1))
				goto error;
		}
	}
C
Christoph Lameter 已提交
3024

3025 3026
#if defined(CONFIG_HAVE_CMPXCHG_DOUBLE) && \
    defined(CONFIG_HAVE_ALIGNED_STRUCT_PAGE)
3027 3028 3029 3030 3031
	if (system_has_cmpxchg_double() && (s->flags & SLAB_DEBUG_FLAGS) == 0)
		/* Enable fast mode */
		s->flags |= __CMPXCHG_DOUBLE;
#endif

3032 3033 3034 3035
	/*
	 * The larger the object size is, the more pages we want on the partial
	 * list to avoid pounding the page allocator excessively.
	 */
3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050
	set_min_partial(s, ilog2(s->size) / 2);

	/*
	 * cpu_partial determined the maximum number of objects kept in the
	 * per cpu partial lists of a processor.
	 *
	 * Per cpu partial lists mainly contain slabs that just have one
	 * object freed. If they are used for allocation then they can be
	 * filled up again with minimal effort. The slab will never hit the
	 * per node partial lists and therefore no locking will be required.
	 *
	 * This setting also determines
	 *
	 * A) The number of objects from per cpu partial slabs dumped to the
	 *    per node list when we reach the limit.
3051
	 * B) The number of objects in cpu partial slabs to extract from the
3052 3053 3054
	 *    per node list when we run out of per cpu objects. We only fetch 50%
	 *    to keep some capacity around for frees.
	 */
3055 3056 3057
	if (kmem_cache_debug(s))
		s->cpu_partial = 0;
	else if (s->size >= PAGE_SIZE)
3058 3059 3060 3061 3062 3063 3064 3065
		s->cpu_partial = 2;
	else if (s->size >= 1024)
		s->cpu_partial = 6;
	else if (s->size >= 256)
		s->cpu_partial = 13;
	else
		s->cpu_partial = 30;

C
Christoph Lameter 已提交
3066
#ifdef CONFIG_NUMA
3067
	s->remote_node_defrag_ratio = 1000;
C
Christoph Lameter 已提交
3068
#endif
3069
	if (!init_kmem_cache_nodes(s))
3070
		goto error;
C
Christoph Lameter 已提交
3071

3072
	if (alloc_kmem_cache_cpus(s))
3073
		return 0;
3074

3075
	free_kmem_cache_nodes(s);
C
Christoph Lameter 已提交
3076 3077 3078 3079
error:
	if (flags & SLAB_PANIC)
		panic("Cannot create slab %s size=%lu realsize=%u "
			"order=%u offset=%u flags=%lx\n",
3080
			s->name, (unsigned long)s->size, s->size, oo_order(s->oo),
C
Christoph Lameter 已提交
3081
			s->offset, flags);
3082
	return -EINVAL;
C
Christoph Lameter 已提交
3083 3084
}

3085 3086 3087 3088 3089 3090
static void list_slab_objects(struct kmem_cache *s, struct page *page,
							const char *text)
{
#ifdef CONFIG_SLUB_DEBUG
	void *addr = page_address(page);
	void *p;
N
Namhyung Kim 已提交
3091 3092
	unsigned long *map = kzalloc(BITS_TO_LONGS(page->objects) *
				     sizeof(long), GFP_ATOMIC);
E
Eric Dumazet 已提交
3093 3094
	if (!map)
		return;
3095
	slab_err(s, page, text, s->name);
3096 3097
	slab_lock(page);

3098
	get_map(s, page, map);
3099 3100 3101 3102 3103 3104 3105 3106 3107
	for_each_object(p, s, addr, page->objects) {

		if (!test_bit(slab_index(p, s, addr), map)) {
			printk(KERN_ERR "INFO: Object 0x%p @offset=%tu\n",
							p, p - addr);
			print_tracking(s, p);
		}
	}
	slab_unlock(page);
E
Eric Dumazet 已提交
3108
	kfree(map);
3109 3110 3111
#endif
}

C
Christoph Lameter 已提交
3112
/*
C
Christoph Lameter 已提交
3113
 * Attempt to free all partial slabs on a node.
3114 3115
 * This is called from kmem_cache_close(). We must be the last thread
 * using the cache and therefore we do not need to lock anymore.
C
Christoph Lameter 已提交
3116
 */
C
Christoph Lameter 已提交
3117
static void free_partial(struct kmem_cache *s, struct kmem_cache_node *n)
C
Christoph Lameter 已提交
3118 3119 3120
{
	struct page *page, *h;

3121
	list_for_each_entry_safe(page, h, &n->partial, lru) {
C
Christoph Lameter 已提交
3122
		if (!page->inuse) {
3123
			remove_partial(n, page);
C
Christoph Lameter 已提交
3124
			discard_slab(s, page);
3125 3126
		} else {
			list_slab_objects(s, page,
3127
			"Objects remaining in %s on kmem_cache_close()");
C
Christoph Lameter 已提交
3128
		}
3129
	}
C
Christoph Lameter 已提交
3130 3131 3132
}

/*
C
Christoph Lameter 已提交
3133
 * Release all resources used by a slab cache.
C
Christoph Lameter 已提交
3134
 */
3135
static inline int kmem_cache_close(struct kmem_cache *s)
C
Christoph Lameter 已提交
3136 3137 3138 3139 3140
{
	int node;

	flush_all(s);
	/* Attempt to free all objects */
C
Christoph Lameter 已提交
3141
	for_each_node_state(node, N_NORMAL_MEMORY) {
C
Christoph Lameter 已提交
3142 3143
		struct kmem_cache_node *n = get_node(s, node);

C
Christoph Lameter 已提交
3144 3145
		free_partial(s, n);
		if (n->nr_partial || slabs_node(s, node))
C
Christoph Lameter 已提交
3146 3147
			return 1;
	}
3148
	free_percpu(s->cpu_slab);
C
Christoph Lameter 已提交
3149 3150 3151 3152
	free_kmem_cache_nodes(s);
	return 0;
}

3153
int __kmem_cache_shutdown(struct kmem_cache *s)
C
Christoph Lameter 已提交
3154
{
3155
	int rc = kmem_cache_close(s);
3156

3157 3158 3159 3160 3161 3162 3163 3164 3165 3166
	if (!rc) {
		/*
		 * We do the same lock strategy around sysfs_slab_add, see
		 * __kmem_cache_create. Because this is pretty much the last
		 * operation we do and the lock will be released shortly after
		 * that in slab_common.c, we could just move sysfs_slab_remove
		 * to a later point in common code. We should do that when we
		 * have a common sysfs framework for all allocators.
		 */
		mutex_unlock(&slab_mutex);
C
Christoph Lameter 已提交
3167
		sysfs_slab_remove(s);
3168 3169
		mutex_lock(&slab_mutex);
	}
3170 3171

	return rc;
C
Christoph Lameter 已提交
3172 3173 3174 3175 3176 3177 3178 3179
}

/********************************************************************
 *		Kmalloc subsystem
 *******************************************************************/

static int __init setup_slub_min_order(char *str)
{
P
Pekka Enberg 已提交
3180
	get_option(&str, &slub_min_order);
C
Christoph Lameter 已提交
3181 3182 3183 3184 3185 3186 3187 3188

	return 1;
}

__setup("slub_min_order=", setup_slub_min_order);

static int __init setup_slub_max_order(char *str)
{
P
Pekka Enberg 已提交
3189
	get_option(&str, &slub_max_order);
D
David Rientjes 已提交
3190
	slub_max_order = min(slub_max_order, MAX_ORDER - 1);
C
Christoph Lameter 已提交
3191 3192 3193 3194 3195 3196 3197 3198

	return 1;
}

__setup("slub_max_order=", setup_slub_max_order);

static int __init setup_slub_min_objects(char *str)
{
P
Pekka Enberg 已提交
3199
	get_option(&str, &slub_min_objects);
C
Christoph Lameter 已提交
3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215

	return 1;
}

__setup("slub_min_objects=", setup_slub_min_objects);

static int __init setup_slub_nomerge(char *str)
{
	slub_nomerge = 1;
	return 1;
}

__setup("slub_nomerge", setup_slub_nomerge);

void *__kmalloc(size_t size, gfp_t flags)
{
3216
	struct kmem_cache *s;
E
Eduard - Gabriel Munteanu 已提交
3217
	void *ret;
C
Christoph Lameter 已提交
3218

3219
	if (unlikely(size > KMALLOC_MAX_CACHE_SIZE))
3220
		return kmalloc_large(size, flags);
3221

3222
	s = kmalloc_slab(size, flags);
3223 3224

	if (unlikely(ZERO_OR_NULL_PTR(s)))
3225 3226
		return s;

3227
	ret = slab_alloc(s, flags, _RET_IP_);
E
Eduard - Gabriel Munteanu 已提交
3228

3229
	trace_kmalloc(_RET_IP_, ret, size, s->size, flags);
E
Eduard - Gabriel Munteanu 已提交
3230 3231

	return ret;
C
Christoph Lameter 已提交
3232 3233 3234
}
EXPORT_SYMBOL(__kmalloc);

3235
#ifdef CONFIG_NUMA
3236 3237
static void *kmalloc_large_node(size_t size, gfp_t flags, int node)
{
3238
	struct page *page;
3239
	void *ptr = NULL;
3240

3241
	flags |= __GFP_COMP | __GFP_NOTRACK | __GFP_KMEMCG;
3242
	page = alloc_pages_node(node, flags, get_order(size));
3243
	if (page)
3244 3245 3246 3247
		ptr = page_address(page);

	kmemleak_alloc(ptr, size, 1, flags);
	return ptr;
3248 3249
}

C
Christoph Lameter 已提交
3250 3251
void *__kmalloc_node(size_t size, gfp_t flags, int node)
{
3252
	struct kmem_cache *s;
E
Eduard - Gabriel Munteanu 已提交
3253
	void *ret;
C
Christoph Lameter 已提交
3254

3255
	if (unlikely(size > KMALLOC_MAX_CACHE_SIZE)) {
E
Eduard - Gabriel Munteanu 已提交
3256 3257
		ret = kmalloc_large_node(size, flags, node);

3258 3259 3260
		trace_kmalloc_node(_RET_IP_, ret,
				   size, PAGE_SIZE << get_order(size),
				   flags, node);
E
Eduard - Gabriel Munteanu 已提交
3261 3262 3263

		return ret;
	}
3264

3265
	s = kmalloc_slab(size, flags);
3266 3267

	if (unlikely(ZERO_OR_NULL_PTR(s)))
3268 3269
		return s;

3270
	ret = slab_alloc_node(s, flags, node, _RET_IP_);
E
Eduard - Gabriel Munteanu 已提交
3271

3272
	trace_kmalloc_node(_RET_IP_, ret, size, s->size, flags, node);
E
Eduard - Gabriel Munteanu 已提交
3273 3274

	return ret;
C
Christoph Lameter 已提交
3275 3276 3277 3278 3279 3280
}
EXPORT_SYMBOL(__kmalloc_node);
#endif

size_t ksize(const void *object)
{
3281
	struct page *page;
C
Christoph Lameter 已提交
3282

3283
	if (unlikely(object == ZERO_SIZE_PTR))
3284 3285
		return 0;

3286 3287
	page = virt_to_head_page(object);

P
Pekka Enberg 已提交
3288 3289
	if (unlikely(!PageSlab(page))) {
		WARN_ON(!PageCompound(page));
3290
		return PAGE_SIZE << compound_order(page);
P
Pekka Enberg 已提交
3291
	}
C
Christoph Lameter 已提交
3292

3293
	return slab_ksize(page->slab_cache);
C
Christoph Lameter 已提交
3294
}
K
Kirill A. Shutemov 已提交
3295
EXPORT_SYMBOL(ksize);
C
Christoph Lameter 已提交
3296

3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317
#ifdef CONFIG_SLUB_DEBUG
bool verify_mem_not_deleted(const void *x)
{
	struct page *page;
	void *object = (void *)x;
	unsigned long flags;
	bool rv;

	if (unlikely(ZERO_OR_NULL_PTR(x)))
		return false;

	local_irq_save(flags);

	page = virt_to_head_page(x);
	if (unlikely(!PageSlab(page))) {
		/* maybe it was from stack? */
		rv = true;
		goto out_unlock;
	}

	slab_lock(page);
3318 3319
	if (on_freelist(page->slab_cache, page, object)) {
		object_err(page->slab_cache, page, object, "Object is on free-list");
3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332
		rv = false;
	} else {
		rv = true;
	}
	slab_unlock(page);

out_unlock:
	local_irq_restore(flags);
	return rv;
}
EXPORT_SYMBOL(verify_mem_not_deleted);
#endif

C
Christoph Lameter 已提交
3333 3334 3335
void kfree(const void *x)
{
	struct page *page;
3336
	void *object = (void *)x;
C
Christoph Lameter 已提交
3337

3338 3339
	trace_kfree(_RET_IP_, x);

3340
	if (unlikely(ZERO_OR_NULL_PTR(x)))
C
Christoph Lameter 已提交
3341 3342
		return;

3343
	page = virt_to_head_page(x);
3344
	if (unlikely(!PageSlab(page))) {
3345
		BUG_ON(!PageCompound(page));
3346
		kmemleak_free(x);
3347
		__free_memcg_kmem_pages(page, compound_order(page));
3348 3349
		return;
	}
3350
	slab_free(page->slab_cache, page, object, _RET_IP_);
C
Christoph Lameter 已提交
3351 3352 3353
}
EXPORT_SYMBOL(kfree);

3354
/*
C
Christoph Lameter 已提交
3355 3356 3357 3358 3359 3360 3361 3362
 * kmem_cache_shrink removes empty slabs from the partial lists and sorts
 * the remaining slabs by the number of items in use. The slabs with the
 * most items in use come first. New allocations will then fill those up
 * and thus they can be removed from the partial lists.
 *
 * The slabs with the least items are placed last. This results in them
 * being allocated from last increasing the chance that the last objects
 * are freed in them.
3363 3364 3365 3366 3367 3368 3369 3370
 */
int kmem_cache_shrink(struct kmem_cache *s)
{
	int node;
	int i;
	struct kmem_cache_node *n;
	struct page *page;
	struct page *t;
3371
	int objects = oo_objects(s->max);
3372
	struct list_head *slabs_by_inuse =
3373
		kmalloc(sizeof(struct list_head) * objects, GFP_KERNEL);
3374 3375 3376 3377 3378 3379
	unsigned long flags;

	if (!slabs_by_inuse)
		return -ENOMEM;

	flush_all(s);
C
Christoph Lameter 已提交
3380
	for_each_node_state(node, N_NORMAL_MEMORY) {
3381 3382 3383 3384 3385
		n = get_node(s, node);

		if (!n->nr_partial)
			continue;

3386
		for (i = 0; i < objects; i++)
3387 3388 3389 3390 3391
			INIT_LIST_HEAD(slabs_by_inuse + i);

		spin_lock_irqsave(&n->list_lock, flags);

		/*
C
Christoph Lameter 已提交
3392
		 * Build lists indexed by the items in use in each slab.
3393
		 *
C
Christoph Lameter 已提交
3394 3395
		 * Note that concurrent frees may occur while we hold the
		 * list_lock. page->inuse here is the upper limit.
3396 3397
		 */
		list_for_each_entry_safe(page, t, &n->partial, lru) {
3398 3399 3400
			list_move(&page->lru, slabs_by_inuse + page->inuse);
			if (!page->inuse)
				n->nr_partial--;
3401 3402 3403
		}

		/*
C
Christoph Lameter 已提交
3404 3405
		 * Rebuild the partial list with the slabs filled up most
		 * first and the least used slabs at the end.
3406
		 */
3407
		for (i = objects - 1; i > 0; i--)
3408 3409 3410
			list_splice(slabs_by_inuse + i, n->partial.prev);

		spin_unlock_irqrestore(&n->list_lock, flags);
3411 3412 3413 3414

		/* Release empty slabs */
		list_for_each_entry_safe(page, t, slabs_by_inuse, lru)
			discard_slab(s, page);
3415 3416 3417 3418 3419 3420 3421
	}

	kfree(slabs_by_inuse);
	return 0;
}
EXPORT_SYMBOL(kmem_cache_shrink);

P
Pekka Enberg 已提交
3422
#if defined(CONFIG_MEMORY_HOTPLUG)
3423 3424 3425 3426
static int slab_mem_going_offline_callback(void *arg)
{
	struct kmem_cache *s;

3427
	mutex_lock(&slab_mutex);
3428 3429
	list_for_each_entry(s, &slab_caches, list)
		kmem_cache_shrink(s);
3430
	mutex_unlock(&slab_mutex);
3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441

	return 0;
}

static void slab_mem_offline_callback(void *arg)
{
	struct kmem_cache_node *n;
	struct kmem_cache *s;
	struct memory_notify *marg = arg;
	int offline_node;

3442
	offline_node = marg->status_change_nid_normal;
3443 3444 3445 3446 3447 3448 3449 3450

	/*
	 * If the node still has available memory. we need kmem_cache_node
	 * for it yet.
	 */
	if (offline_node < 0)
		return;

3451
	mutex_lock(&slab_mutex);
3452 3453 3454 3455 3456 3457
	list_for_each_entry(s, &slab_caches, list) {
		n = get_node(s, offline_node);
		if (n) {
			/*
			 * if n->nr_slabs > 0, slabs still exist on the node
			 * that is going down. We were unable to free them,
3458
			 * and offline_pages() function shouldn't call this
3459 3460
			 * callback. So, we must fail.
			 */
3461
			BUG_ON(slabs_node(s, offline_node));
3462 3463

			s->node[offline_node] = NULL;
3464
			kmem_cache_free(kmem_cache_node, n);
3465 3466
		}
	}
3467
	mutex_unlock(&slab_mutex);
3468 3469 3470 3471 3472 3473 3474
}

static int slab_mem_going_online_callback(void *arg)
{
	struct kmem_cache_node *n;
	struct kmem_cache *s;
	struct memory_notify *marg = arg;
3475
	int nid = marg->status_change_nid_normal;
3476 3477 3478 3479 3480 3481 3482 3483 3484 3485
	int ret = 0;

	/*
	 * If the node's memory is already available, then kmem_cache_node is
	 * already created. Nothing to do.
	 */
	if (nid < 0)
		return 0;

	/*
3486
	 * We are bringing a node online. No memory is available yet. We must
3487 3488 3489
	 * allocate a kmem_cache_node structure in order to bring the node
	 * online.
	 */
3490
	mutex_lock(&slab_mutex);
3491 3492 3493 3494 3495 3496
	list_for_each_entry(s, &slab_caches, list) {
		/*
		 * XXX: kmem_cache_alloc_node will fallback to other nodes
		 *      since memory is not yet available from the node that
		 *      is brought up.
		 */
3497
		n = kmem_cache_alloc(kmem_cache_node, GFP_KERNEL);
3498 3499 3500 3501
		if (!n) {
			ret = -ENOMEM;
			goto out;
		}
3502
		init_kmem_cache_node(n);
3503 3504 3505
		s->node[nid] = n;
	}
out:
3506
	mutex_unlock(&slab_mutex);
3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529
	return ret;
}

static int slab_memory_callback(struct notifier_block *self,
				unsigned long action, void *arg)
{
	int ret = 0;

	switch (action) {
	case MEM_GOING_ONLINE:
		ret = slab_mem_going_online_callback(arg);
		break;
	case MEM_GOING_OFFLINE:
		ret = slab_mem_going_offline_callback(arg);
		break;
	case MEM_OFFLINE:
	case MEM_CANCEL_ONLINE:
		slab_mem_offline_callback(arg);
		break;
	case MEM_ONLINE:
	case MEM_CANCEL_OFFLINE:
		break;
	}
3530 3531 3532 3533
	if (ret)
		ret = notifier_from_errno(ret);
	else
		ret = NOTIFY_OK;
3534 3535 3536 3537 3538
	return ret;
}

#endif /* CONFIG_MEMORY_HOTPLUG */

C
Christoph Lameter 已提交
3539 3540 3541 3542
/********************************************************************
 *			Basic setup of slabs
 *******************************************************************/

3543 3544
/*
 * Used for early kmem_cache structures that were allocated using
3545 3546
 * the page allocator. Allocate them properly then fix up the pointers
 * that may be pointing to the wrong kmem_cache structure.
3547 3548
 */

3549
static struct kmem_cache * __init bootstrap(struct kmem_cache *static_cache)
3550 3551
{
	int node;
3552
	struct kmem_cache *s = kmem_cache_zalloc(kmem_cache, GFP_NOWAIT);
3553

3554
	memcpy(s, static_cache, kmem_cache->object_size);
3555

3556 3557 3558 3559 3560 3561
	/*
	 * This runs very early, and only the boot processor is supposed to be
	 * up.  Even if it weren't true, IRQs are not up so we couldn't fire
	 * IPIs around.
	 */
	__flush_cpu_slab(s, smp_processor_id());
3562 3563 3564 3565 3566 3567
	for_each_node_state(node, N_NORMAL_MEMORY) {
		struct kmem_cache_node *n = get_node(s, node);
		struct page *p;

		if (n) {
			list_for_each_entry(p, &n->partial, lru)
3568
				p->slab_cache = s;
3569

L
Li Zefan 已提交
3570
#ifdef CONFIG_SLUB_DEBUG
3571
			list_for_each_entry(p, &n->full, lru)
3572
				p->slab_cache = s;
3573 3574 3575
#endif
		}
	}
3576 3577
	list_add(&s->list, &slab_caches);
	return s;
3578 3579
}

C
Christoph Lameter 已提交
3580 3581
void __init kmem_cache_init(void)
{
3582 3583
	static __initdata struct kmem_cache boot_kmem_cache,
		boot_kmem_cache_node;
3584

3585 3586 3587
	if (debug_guardpage_minorder())
		slub_max_order = 0;

3588 3589
	kmem_cache_node = &boot_kmem_cache_node;
	kmem_cache = &boot_kmem_cache;
3590

3591 3592
	create_boot_cache(kmem_cache_node, "kmem_cache_node",
		sizeof(struct kmem_cache_node), SLAB_HWCACHE_ALIGN);
3593

3594
	hotplug_memory_notifier(slab_memory_callback, SLAB_CALLBACK_PRI);
C
Christoph Lameter 已提交
3595 3596 3597 3598

	/* Able to allocate the per node structures */
	slab_state = PARTIAL;

3599 3600 3601 3602
	create_boot_cache(kmem_cache, "kmem_cache",
			offsetof(struct kmem_cache, node) +
				nr_node_ids * sizeof(struct kmem_cache_node *),
		       SLAB_HWCACHE_ALIGN);
3603

3604
	kmem_cache = bootstrap(&boot_kmem_cache);
C
Christoph Lameter 已提交
3605

3606 3607 3608 3609 3610
	/*
	 * Allocate kmem_cache_node properly from the kmem_cache slab.
	 * kmem_cache_node is separately allocated so no need to
	 * update any list pointers.
	 */
3611
	kmem_cache_node = bootstrap(&boot_kmem_cache_node);
3612 3613

	/* Now we can use the kmem_cache to allocate kmalloc slabs */
3614
	create_kmalloc_caches(0);
C
Christoph Lameter 已提交
3615 3616 3617

#ifdef CONFIG_SMP
	register_cpu_notifier(&slab_notifier);
3618
#endif
C
Christoph Lameter 已提交
3619

I
Ingo Molnar 已提交
3620
	printk(KERN_INFO
3621
		"SLUB: HWalign=%d, Order=%d-%d, MinObjects=%d,"
3622
		" CPUs=%d, Nodes=%d\n",
3623
		cache_line_size(),
C
Christoph Lameter 已提交
3624 3625 3626 3627
		slub_min_order, slub_max_order, slub_min_objects,
		nr_cpu_ids, nr_node_ids);
}

3628 3629 3630 3631
void __init kmem_cache_init_late(void)
{
}

C
Christoph Lameter 已提交
3632 3633 3634 3635 3636 3637 3638 3639
/*
 * Find a mergeable slab cache
 */
static int slab_unmergeable(struct kmem_cache *s)
{
	if (slub_nomerge || (s->flags & SLUB_NEVER_MERGE))
		return 1;

3640
	if (s->ctor)
C
Christoph Lameter 已提交
3641 3642
		return 1;

3643 3644 3645 3646 3647 3648
	/*
	 * We may have set a slab to be unmergeable during bootstrap.
	 */
	if (s->refcount < 0)
		return 1;

C
Christoph Lameter 已提交
3649 3650 3651
	return 0;
}

3652
static struct kmem_cache *find_mergeable(struct mem_cgroup *memcg, size_t size,
3653
		size_t align, unsigned long flags, const char *name,
3654
		void (*ctor)(void *))
C
Christoph Lameter 已提交
3655
{
3656
	struct kmem_cache *s;
C
Christoph Lameter 已提交
3657 3658 3659 3660

	if (slub_nomerge || (flags & SLUB_NEVER_MERGE))
		return NULL;

3661
	if (ctor)
C
Christoph Lameter 已提交
3662 3663 3664 3665 3666
		return NULL;

	size = ALIGN(size, sizeof(void *));
	align = calculate_alignment(flags, align, size);
	size = ALIGN(size, align);
3667
	flags = kmem_cache_flags(size, flags, name, NULL);
C
Christoph Lameter 已提交
3668

3669
	list_for_each_entry(s, &slab_caches, list) {
C
Christoph Lameter 已提交
3670 3671 3672 3673 3674 3675
		if (slab_unmergeable(s))
			continue;

		if (size > s->size)
			continue;

3676
		if ((flags & SLUB_MERGE_SAME) != (s->flags & SLUB_MERGE_SAME))
C
Christoph Lameter 已提交
3677 3678 3679 3680 3681
				continue;
		/*
		 * Check if alignment is compatible.
		 * Courtesy of Adrian Drzewiecki
		 */
P
Pekka Enberg 已提交
3682
		if ((s->size & ~(align - 1)) != s->size)
C
Christoph Lameter 已提交
3683 3684 3685 3686 3687
			continue;

		if (s->size - size >= sizeof(void *))
			continue;

3688 3689 3690
		if (!cache_match_memcg(s, memcg))
			continue;

C
Christoph Lameter 已提交
3691 3692 3693 3694 3695
		return s;
	}
	return NULL;
}

3696 3697 3698
struct kmem_cache *
__kmem_cache_alias(struct mem_cgroup *memcg, const char *name, size_t size,
		   size_t align, unsigned long flags, void (*ctor)(void *))
C
Christoph Lameter 已提交
3699 3700 3701
{
	struct kmem_cache *s;

3702
	s = find_mergeable(memcg, size, align, flags, name, ctor);
C
Christoph Lameter 已提交
3703 3704 3705 3706 3707 3708
	if (s) {
		s->refcount++;
		/*
		 * Adjust the object sizes so that we clear
		 * the complete object on kzalloc.
		 */
3709
		s->object_size = max(s->object_size, (int)size);
C
Christoph Lameter 已提交
3710
		s->inuse = max_t(int, s->inuse, ALIGN(size, sizeof(void *)));
C
Christoph Lameter 已提交
3711

3712 3713
		if (sysfs_slab_alias(s, name)) {
			s->refcount--;
3714
			s = NULL;
3715
		}
3716
	}
C
Christoph Lameter 已提交
3717

3718 3719
	return s;
}
P
Pekka Enberg 已提交
3720

3721
int __kmem_cache_create(struct kmem_cache *s, unsigned long flags)
3722
{
3723 3724 3725 3726 3727
	int err;

	err = kmem_cache_open(s, flags);
	if (err)
		return err;
3728

3729 3730 3731 3732
	/* Mutex is not taken during early boot */
	if (slab_state <= UP)
		return 0;

3733
	memcg_propagate_slab_attrs(s);
3734 3735 3736
	mutex_unlock(&slab_mutex);
	err = sysfs_slab_add(s);
	mutex_lock(&slab_mutex);
3737

3738 3739
	if (err)
		kmem_cache_close(s);
3740

3741
	return err;
C
Christoph Lameter 已提交
3742 3743 3744 3745
}

#ifdef CONFIG_SMP
/*
C
Christoph Lameter 已提交
3746 3747
 * Use the cpu notifier to insure that the cpu slabs are flushed when
 * necessary.
C
Christoph Lameter 已提交
3748 3749 3750 3751 3752
 */
static int __cpuinit slab_cpuup_callback(struct notifier_block *nfb,
		unsigned long action, void *hcpu)
{
	long cpu = (long)hcpu;
3753 3754
	struct kmem_cache *s;
	unsigned long flags;
C
Christoph Lameter 已提交
3755 3756 3757

	switch (action) {
	case CPU_UP_CANCELED:
3758
	case CPU_UP_CANCELED_FROZEN:
C
Christoph Lameter 已提交
3759
	case CPU_DEAD:
3760
	case CPU_DEAD_FROZEN:
3761
		mutex_lock(&slab_mutex);
3762 3763 3764 3765 3766
		list_for_each_entry(s, &slab_caches, list) {
			local_irq_save(flags);
			__flush_cpu_slab(s, cpu);
			local_irq_restore(flags);
		}
3767
		mutex_unlock(&slab_mutex);
C
Christoph Lameter 已提交
3768 3769 3770 3771 3772 3773 3774
		break;
	default:
		break;
	}
	return NOTIFY_OK;
}

P
Pekka Enberg 已提交
3775
static struct notifier_block __cpuinitdata slab_notifier = {
I
Ingo Molnar 已提交
3776
	.notifier_call = slab_cpuup_callback
P
Pekka Enberg 已提交
3777
};
C
Christoph Lameter 已提交
3778 3779 3780

#endif

3781
void *__kmalloc_track_caller(size_t size, gfp_t gfpflags, unsigned long caller)
C
Christoph Lameter 已提交
3782
{
3783
	struct kmem_cache *s;
3784
	void *ret;
3785

3786
	if (unlikely(size > KMALLOC_MAX_CACHE_SIZE))
3787 3788
		return kmalloc_large(size, gfpflags);

3789
	s = kmalloc_slab(size, gfpflags);
C
Christoph Lameter 已提交
3790

3791
	if (unlikely(ZERO_OR_NULL_PTR(s)))
3792
		return s;
C
Christoph Lameter 已提交
3793

3794
	ret = slab_alloc(s, gfpflags, caller);
3795

L
Lucas De Marchi 已提交
3796
	/* Honor the call site pointer we received. */
3797
	trace_kmalloc(caller, ret, size, s->size, gfpflags);
3798 3799

	return ret;
C
Christoph Lameter 已提交
3800 3801
}

3802
#ifdef CONFIG_NUMA
C
Christoph Lameter 已提交
3803
void *__kmalloc_node_track_caller(size_t size, gfp_t gfpflags,
3804
					int node, unsigned long caller)
C
Christoph Lameter 已提交
3805
{
3806
	struct kmem_cache *s;
3807
	void *ret;
3808

3809
	if (unlikely(size > KMALLOC_MAX_CACHE_SIZE)) {
3810 3811 3812 3813 3814 3815 3816 3817
		ret = kmalloc_large_node(size, gfpflags, node);

		trace_kmalloc_node(caller, ret,
				   size, PAGE_SIZE << get_order(size),
				   gfpflags, node);

		return ret;
	}
3818

3819
	s = kmalloc_slab(size, gfpflags);
C
Christoph Lameter 已提交
3820

3821
	if (unlikely(ZERO_OR_NULL_PTR(s)))
3822
		return s;
C
Christoph Lameter 已提交
3823

3824
	ret = slab_alloc_node(s, gfpflags, node, caller);
3825

L
Lucas De Marchi 已提交
3826
	/* Honor the call site pointer we received. */
3827
	trace_kmalloc_node(caller, ret, size, s->size, gfpflags, node);
3828 3829

	return ret;
C
Christoph Lameter 已提交
3830
}
3831
#endif
C
Christoph Lameter 已提交
3832

3833
#ifdef CONFIG_SYSFS
3834 3835 3836 3837 3838 3839 3840 3841 3842
static int count_inuse(struct page *page)
{
	return page->inuse;
}

static int count_total(struct page *page)
{
	return page->objects;
}
3843
#endif
3844

3845
#ifdef CONFIG_SLUB_DEBUG
3846 3847
static int validate_slab(struct kmem_cache *s, struct page *page,
						unsigned long *map)
3848 3849
{
	void *p;
3850
	void *addr = page_address(page);
3851 3852 3853 3854 3855 3856

	if (!check_slab(s, page) ||
			!on_freelist(s, page, NULL))
		return 0;

	/* Now we know that a valid freelist exists */
3857
	bitmap_zero(map, page->objects);
3858

3859 3860 3861 3862 3863
	get_map(s, page, map);
	for_each_object(p, s, addr, page->objects) {
		if (test_bit(slab_index(p, s, addr), map))
			if (!check_object(s, page, p, SLUB_RED_INACTIVE))
				return 0;
3864 3865
	}

3866
	for_each_object(p, s, addr, page->objects)
3867
		if (!test_bit(slab_index(p, s, addr), map))
3868
			if (!check_object(s, page, p, SLUB_RED_ACTIVE))
3869 3870 3871 3872
				return 0;
	return 1;
}

3873 3874
static void validate_slab_slab(struct kmem_cache *s, struct page *page,
						unsigned long *map)
3875
{
3876 3877 3878
	slab_lock(page);
	validate_slab(s, page, map);
	slab_unlock(page);
3879 3880
}

3881 3882
static int validate_slab_node(struct kmem_cache *s,
		struct kmem_cache_node *n, unsigned long *map)
3883 3884 3885 3886 3887 3888 3889 3890
{
	unsigned long count = 0;
	struct page *page;
	unsigned long flags;

	spin_lock_irqsave(&n->list_lock, flags);

	list_for_each_entry(page, &n->partial, lru) {
3891
		validate_slab_slab(s, page, map);
3892 3893 3894 3895 3896 3897 3898 3899 3900 3901
		count++;
	}
	if (count != n->nr_partial)
		printk(KERN_ERR "SLUB %s: %ld partial slabs counted but "
			"counter=%ld\n", s->name, count, n->nr_partial);

	if (!(s->flags & SLAB_STORE_USER))
		goto out;

	list_for_each_entry(page, &n->full, lru) {
3902
		validate_slab_slab(s, page, map);
3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914
		count++;
	}
	if (count != atomic_long_read(&n->nr_slabs))
		printk(KERN_ERR "SLUB: %s %ld slabs counted but "
			"counter=%ld\n", s->name, count,
			atomic_long_read(&n->nr_slabs));

out:
	spin_unlock_irqrestore(&n->list_lock, flags);
	return count;
}

3915
static long validate_slab_cache(struct kmem_cache *s)
3916 3917 3918
{
	int node;
	unsigned long count = 0;
3919
	unsigned long *map = kmalloc(BITS_TO_LONGS(oo_objects(s->max)) *
3920 3921 3922 3923
				sizeof(unsigned long), GFP_KERNEL);

	if (!map)
		return -ENOMEM;
3924 3925

	flush_all(s);
C
Christoph Lameter 已提交
3926
	for_each_node_state(node, N_NORMAL_MEMORY) {
3927 3928
		struct kmem_cache_node *n = get_node(s, node);

3929
		count += validate_slab_node(s, n, map);
3930
	}
3931
	kfree(map);
3932 3933
	return count;
}
3934
/*
C
Christoph Lameter 已提交
3935
 * Generate lists of code addresses where slabcache objects are allocated
3936 3937 3938 3939 3940
 * and freed.
 */

struct location {
	unsigned long count;
3941
	unsigned long addr;
3942 3943 3944 3945 3946
	long long sum_time;
	long min_time;
	long max_time;
	long min_pid;
	long max_pid;
R
Rusty Russell 已提交
3947
	DECLARE_BITMAP(cpus, NR_CPUS);
3948
	nodemask_t nodes;
3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963
};

struct loc_track {
	unsigned long max;
	unsigned long count;
	struct location *loc;
};

static void free_loc_track(struct loc_track *t)
{
	if (t->max)
		free_pages((unsigned long)t->loc,
			get_order(sizeof(struct location) * t->max));
}

3964
static int alloc_loc_track(struct loc_track *t, unsigned long max, gfp_t flags)
3965 3966 3967 3968 3969 3970
{
	struct location *l;
	int order;

	order = get_order(sizeof(struct location) * max);

3971
	l = (void *)__get_free_pages(flags, order);
3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984
	if (!l)
		return 0;

	if (t->count) {
		memcpy(l, t->loc, sizeof(struct location) * t->count);
		free_loc_track(t);
	}
	t->max = max;
	t->loc = l;
	return 1;
}

static int add_location(struct loc_track *t, struct kmem_cache *s,
3985
				const struct track *track)
3986 3987 3988
{
	long start, end, pos;
	struct location *l;
3989
	unsigned long caddr;
3990
	unsigned long age = jiffies - track->when;
3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005

	start = -1;
	end = t->count;

	for ( ; ; ) {
		pos = start + (end - start + 1) / 2;

		/*
		 * There is nothing at "end". If we end up there
		 * we need to add something to before end.
		 */
		if (pos == end)
			break;

		caddr = t->loc[pos].addr;
4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021
		if (track->addr == caddr) {

			l = &t->loc[pos];
			l->count++;
			if (track->when) {
				l->sum_time += age;
				if (age < l->min_time)
					l->min_time = age;
				if (age > l->max_time)
					l->max_time = age;

				if (track->pid < l->min_pid)
					l->min_pid = track->pid;
				if (track->pid > l->max_pid)
					l->max_pid = track->pid;

R
Rusty Russell 已提交
4022 4023
				cpumask_set_cpu(track->cpu,
						to_cpumask(l->cpus));
4024 4025
			}
			node_set(page_to_nid(virt_to_page(track)), l->nodes);
4026 4027 4028
			return 1;
		}

4029
		if (track->addr < caddr)
4030 4031 4032 4033 4034 4035
			end = pos;
		else
			start = pos;
	}

	/*
C
Christoph Lameter 已提交
4036
	 * Not found. Insert new tracking element.
4037
	 */
4038
	if (t->count >= t->max && !alloc_loc_track(t, 2 * t->max, GFP_ATOMIC))
4039 4040 4041 4042 4043 4044 4045 4046
		return 0;

	l = t->loc + pos;
	if (pos < t->count)
		memmove(l + 1, l,
			(t->count - pos) * sizeof(struct location));
	t->count++;
	l->count = 1;
4047 4048 4049 4050 4051 4052
	l->addr = track->addr;
	l->sum_time = age;
	l->min_time = age;
	l->max_time = age;
	l->min_pid = track->pid;
	l->max_pid = track->pid;
R
Rusty Russell 已提交
4053 4054
	cpumask_clear(to_cpumask(l->cpus));
	cpumask_set_cpu(track->cpu, to_cpumask(l->cpus));
4055 4056
	nodes_clear(l->nodes);
	node_set(page_to_nid(virt_to_page(track)), l->nodes);
4057 4058 4059 4060
	return 1;
}

static void process_slab(struct loc_track *t, struct kmem_cache *s,
E
Eric Dumazet 已提交
4061
		struct page *page, enum track_item alloc,
N
Namhyung Kim 已提交
4062
		unsigned long *map)
4063
{
4064
	void *addr = page_address(page);
4065 4066
	void *p;

4067
	bitmap_zero(map, page->objects);
4068
	get_map(s, page, map);
4069

4070
	for_each_object(p, s, addr, page->objects)
4071 4072
		if (!test_bit(slab_index(p, s, addr), map))
			add_location(t, s, get_track(s, p, alloc));
4073 4074 4075 4076 4077
}

static int list_locations(struct kmem_cache *s, char *buf,
					enum track_item alloc)
{
4078
	int len = 0;
4079
	unsigned long i;
4080
	struct loc_track t = { 0, 0, NULL };
4081
	int node;
E
Eric Dumazet 已提交
4082 4083
	unsigned long *map = kmalloc(BITS_TO_LONGS(oo_objects(s->max)) *
				     sizeof(unsigned long), GFP_KERNEL);
4084

E
Eric Dumazet 已提交
4085 4086 4087
	if (!map || !alloc_loc_track(&t, PAGE_SIZE / sizeof(struct location),
				     GFP_TEMPORARY)) {
		kfree(map);
4088
		return sprintf(buf, "Out of memory\n");
E
Eric Dumazet 已提交
4089
	}
4090 4091 4092
	/* Push back cpu slabs */
	flush_all(s);

C
Christoph Lameter 已提交
4093
	for_each_node_state(node, N_NORMAL_MEMORY) {
4094 4095 4096 4097
		struct kmem_cache_node *n = get_node(s, node);
		unsigned long flags;
		struct page *page;

4098
		if (!atomic_long_read(&n->nr_slabs))
4099 4100 4101 4102
			continue;

		spin_lock_irqsave(&n->list_lock, flags);
		list_for_each_entry(page, &n->partial, lru)
E
Eric Dumazet 已提交
4103
			process_slab(&t, s, page, alloc, map);
4104
		list_for_each_entry(page, &n->full, lru)
E
Eric Dumazet 已提交
4105
			process_slab(&t, s, page, alloc, map);
4106 4107 4108 4109
		spin_unlock_irqrestore(&n->list_lock, flags);
	}

	for (i = 0; i < t.count; i++) {
4110
		struct location *l = &t.loc[i];
4111

H
Hugh Dickins 已提交
4112
		if (len > PAGE_SIZE - KSYM_SYMBOL_LEN - 100)
4113
			break;
4114
		len += sprintf(buf + len, "%7ld ", l->count);
4115 4116

		if (l->addr)
J
Joe Perches 已提交
4117
			len += sprintf(buf + len, "%pS", (void *)l->addr);
4118
		else
4119
			len += sprintf(buf + len, "<not-available>");
4120 4121

		if (l->sum_time != l->min_time) {
4122
			len += sprintf(buf + len, " age=%ld/%ld/%ld",
R
Roman Zippel 已提交
4123 4124 4125
				l->min_time,
				(long)div_u64(l->sum_time, l->count),
				l->max_time);
4126
		} else
4127
			len += sprintf(buf + len, " age=%ld",
4128 4129 4130
				l->min_time);

		if (l->min_pid != l->max_pid)
4131
			len += sprintf(buf + len, " pid=%ld-%ld",
4132 4133
				l->min_pid, l->max_pid);
		else
4134
			len += sprintf(buf + len, " pid=%ld",
4135 4136
				l->min_pid);

R
Rusty Russell 已提交
4137 4138
		if (num_online_cpus() > 1 &&
				!cpumask_empty(to_cpumask(l->cpus)) &&
4139 4140 4141
				len < PAGE_SIZE - 60) {
			len += sprintf(buf + len, " cpus=");
			len += cpulist_scnprintf(buf + len, PAGE_SIZE - len - 50,
R
Rusty Russell 已提交
4142
						 to_cpumask(l->cpus));
4143 4144
		}

4145
		if (nr_online_nodes > 1 && !nodes_empty(l->nodes) &&
4146 4147 4148
				len < PAGE_SIZE - 60) {
			len += sprintf(buf + len, " nodes=");
			len += nodelist_scnprintf(buf + len, PAGE_SIZE - len - 50,
4149 4150 4151
					l->nodes);
		}

4152
		len += sprintf(buf + len, "\n");
4153 4154 4155
	}

	free_loc_track(&t);
E
Eric Dumazet 已提交
4156
	kfree(map);
4157
	if (!t.count)
4158 4159
		len += sprintf(buf, "No data\n");
	return len;
4160
}
4161
#endif
4162

4163 4164 4165 4166 4167
#ifdef SLUB_RESILIENCY_TEST
static void resiliency_test(void)
{
	u8 *p;

4168
	BUILD_BUG_ON(KMALLOC_MIN_SIZE > 16 || KMALLOC_SHIFT_HIGH < 10);
4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221 4222 4223 4224

	printk(KERN_ERR "SLUB resiliency testing\n");
	printk(KERN_ERR "-----------------------\n");
	printk(KERN_ERR "A. Corruption after allocation\n");

	p = kzalloc(16, GFP_KERNEL);
	p[16] = 0x12;
	printk(KERN_ERR "\n1. kmalloc-16: Clobber Redzone/next pointer"
			" 0x12->0x%p\n\n", p + 16);

	validate_slab_cache(kmalloc_caches[4]);

	/* Hmmm... The next two are dangerous */
	p = kzalloc(32, GFP_KERNEL);
	p[32 + sizeof(void *)] = 0x34;
	printk(KERN_ERR "\n2. kmalloc-32: Clobber next pointer/next slab"
			" 0x34 -> -0x%p\n", p);
	printk(KERN_ERR
		"If allocated object is overwritten then not detectable\n\n");

	validate_slab_cache(kmalloc_caches[5]);
	p = kzalloc(64, GFP_KERNEL);
	p += 64 + (get_cycles() & 0xff) * sizeof(void *);
	*p = 0x56;
	printk(KERN_ERR "\n3. kmalloc-64: corrupting random byte 0x56->0x%p\n",
									p);
	printk(KERN_ERR
		"If allocated object is overwritten then not detectable\n\n");
	validate_slab_cache(kmalloc_caches[6]);

	printk(KERN_ERR "\nB. Corruption after free\n");
	p = kzalloc(128, GFP_KERNEL);
	kfree(p);
	*p = 0x78;
	printk(KERN_ERR "1. kmalloc-128: Clobber first word 0x78->0x%p\n\n", p);
	validate_slab_cache(kmalloc_caches[7]);

	p = kzalloc(256, GFP_KERNEL);
	kfree(p);
	p[50] = 0x9a;
	printk(KERN_ERR "\n2. kmalloc-256: Clobber 50th byte 0x9a->0x%p\n\n",
			p);
	validate_slab_cache(kmalloc_caches[8]);

	p = kzalloc(512, GFP_KERNEL);
	kfree(p);
	p[512] = 0xab;
	printk(KERN_ERR "\n3. kmalloc-512: Clobber redzone 0xab->0x%p\n\n", p);
	validate_slab_cache(kmalloc_caches[9]);
}
#else
#ifdef CONFIG_SYSFS
static void resiliency_test(void) {};
#endif
#endif

4225
#ifdef CONFIG_SYSFS
C
Christoph Lameter 已提交
4226
enum slab_stat_type {
4227 4228 4229 4230 4231
	SL_ALL,			/* All slabs */
	SL_PARTIAL,		/* Only partially allocated slabs */
	SL_CPU,			/* Only slabs used for cpu caches */
	SL_OBJECTS,		/* Determine allocated objects not slabs */
	SL_TOTAL		/* Determine object capacity not slabs */
C
Christoph Lameter 已提交
4232 4233
};

4234
#define SO_ALL		(1 << SL_ALL)
C
Christoph Lameter 已提交
4235 4236 4237
#define SO_PARTIAL	(1 << SL_PARTIAL)
#define SO_CPU		(1 << SL_CPU)
#define SO_OBJECTS	(1 << SL_OBJECTS)
4238
#define SO_TOTAL	(1 << SL_TOTAL)
C
Christoph Lameter 已提交
4239

4240 4241
static ssize_t show_slab_objects(struct kmem_cache *s,
			    char *buf, unsigned long flags)
C
Christoph Lameter 已提交
4242 4243 4244 4245 4246 4247 4248 4249
{
	unsigned long total = 0;
	int node;
	int x;
	unsigned long *nodes;
	unsigned long *per_cpu;

	nodes = kzalloc(2 * sizeof(unsigned long) * nr_node_ids, GFP_KERNEL);
4250 4251
	if (!nodes)
		return -ENOMEM;
C
Christoph Lameter 已提交
4252 4253
	per_cpu = nodes + nr_node_ids;

4254 4255
	if (flags & SO_CPU) {
		int cpu;
C
Christoph Lameter 已提交
4256

4257
		for_each_possible_cpu(cpu) {
4258
			struct kmem_cache_cpu *c = per_cpu_ptr(s->cpu_slab, cpu);
4259
			int node;
4260
			struct page *page;
4261

4262
			page = ACCESS_ONCE(c->page);
4263 4264
			if (!page)
				continue;
4265

4266 4267 4268 4269 4270 4271 4272
			node = page_to_nid(page);
			if (flags & SO_TOTAL)
				x = page->objects;
			else if (flags & SO_OBJECTS)
				x = page->inuse;
			else
				x = 1;
4273

4274 4275 4276 4277
			total += x;
			nodes[node] += x;

			page = ACCESS_ONCE(c->partial);
4278 4279
			if (page) {
				x = page->pobjects;
4280 4281
				total += x;
				nodes[node] += x;
4282
			}
4283

4284
			per_cpu[node]++;
C
Christoph Lameter 已提交
4285 4286 4287
		}
	}

4288
	lock_memory_hotplug();
4289
#ifdef CONFIG_SLUB_DEBUG
4290 4291 4292 4293 4294 4295 4296 4297 4298
	if (flags & SO_ALL) {
		for_each_node_state(node, N_NORMAL_MEMORY) {
			struct kmem_cache_node *n = get_node(s, node);

		if (flags & SO_TOTAL)
			x = atomic_long_read(&n->total_objects);
		else if (flags & SO_OBJECTS)
			x = atomic_long_read(&n->total_objects) -
				count_partial(n, count_free);
C
Christoph Lameter 已提交
4299 4300

			else
4301
				x = atomic_long_read(&n->nr_slabs);
C
Christoph Lameter 已提交
4302 4303 4304 4305
			total += x;
			nodes[node] += x;
		}

4306 4307 4308
	} else
#endif
	if (flags & SO_PARTIAL) {
4309 4310
		for_each_node_state(node, N_NORMAL_MEMORY) {
			struct kmem_cache_node *n = get_node(s, node);
C
Christoph Lameter 已提交
4311

4312 4313 4314 4315
			if (flags & SO_TOTAL)
				x = count_partial(n, count_total);
			else if (flags & SO_OBJECTS)
				x = count_partial(n, count_inuse);
C
Christoph Lameter 已提交
4316
			else
4317
				x = n->nr_partial;
C
Christoph Lameter 已提交
4318 4319 4320 4321 4322 4323
			total += x;
			nodes[node] += x;
		}
	}
	x = sprintf(buf, "%lu", total);
#ifdef CONFIG_NUMA
C
Christoph Lameter 已提交
4324
	for_each_node_state(node, N_NORMAL_MEMORY)
C
Christoph Lameter 已提交
4325 4326 4327 4328
		if (nodes[node])
			x += sprintf(buf + x, " N%d=%lu",
					node, nodes[node]);
#endif
4329
	unlock_memory_hotplug();
C
Christoph Lameter 已提交
4330 4331 4332 4333
	kfree(nodes);
	return x + sprintf(buf + x, "\n");
}

4334
#ifdef CONFIG_SLUB_DEBUG
C
Christoph Lameter 已提交
4335 4336 4337 4338
static int any_slab_objects(struct kmem_cache *s)
{
	int node;

4339
	for_each_online_node(node) {
C
Christoph Lameter 已提交
4340 4341
		struct kmem_cache_node *n = get_node(s, node);

4342 4343 4344
		if (!n)
			continue;

4345
		if (atomic_long_read(&n->total_objects))
C
Christoph Lameter 已提交
4346 4347 4348 4349
			return 1;
	}
	return 0;
}
4350
#endif
C
Christoph Lameter 已提交
4351 4352

#define to_slab_attr(n) container_of(n, struct slab_attribute, attr)
4353
#define to_slab(n) container_of(n, struct kmem_cache, kobj)
C
Christoph Lameter 已提交
4354 4355 4356 4357 4358 4359 4360 4361

struct slab_attribute {
	struct attribute attr;
	ssize_t (*show)(struct kmem_cache *s, char *buf);
	ssize_t (*store)(struct kmem_cache *s, const char *x, size_t count);
};

#define SLAB_ATTR_RO(_name) \
4362 4363
	static struct slab_attribute _name##_attr = \
	__ATTR(_name, 0400, _name##_show, NULL)
C
Christoph Lameter 已提交
4364 4365 4366

#define SLAB_ATTR(_name) \
	static struct slab_attribute _name##_attr =  \
4367
	__ATTR(_name, 0600, _name##_show, _name##_store)
C
Christoph Lameter 已提交
4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382

static ssize_t slab_size_show(struct kmem_cache *s, char *buf)
{
	return sprintf(buf, "%d\n", s->size);
}
SLAB_ATTR_RO(slab_size);

static ssize_t align_show(struct kmem_cache *s, char *buf)
{
	return sprintf(buf, "%d\n", s->align);
}
SLAB_ATTR_RO(align);

static ssize_t object_size_show(struct kmem_cache *s, char *buf)
{
4383
	return sprintf(buf, "%d\n", s->object_size);
C
Christoph Lameter 已提交
4384 4385 4386 4387 4388
}
SLAB_ATTR_RO(object_size);

static ssize_t objs_per_slab_show(struct kmem_cache *s, char *buf)
{
4389
	return sprintf(buf, "%d\n", oo_objects(s->oo));
C
Christoph Lameter 已提交
4390 4391 4392
}
SLAB_ATTR_RO(objs_per_slab);

4393 4394 4395
static ssize_t order_store(struct kmem_cache *s,
				const char *buf, size_t length)
{
4396 4397 4398 4399 4400 4401
	unsigned long order;
	int err;

	err = strict_strtoul(buf, 10, &order);
	if (err)
		return err;
4402 4403 4404 4405 4406 4407 4408 4409

	if (order > slub_max_order || order < slub_min_order)
		return -EINVAL;

	calculate_sizes(s, order);
	return length;
}

C
Christoph Lameter 已提交
4410 4411
static ssize_t order_show(struct kmem_cache *s, char *buf)
{
4412
	return sprintf(buf, "%d\n", oo_order(s->oo));
C
Christoph Lameter 已提交
4413
}
4414
SLAB_ATTR(order);
C
Christoph Lameter 已提交
4415

4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430
static ssize_t min_partial_show(struct kmem_cache *s, char *buf)
{
	return sprintf(buf, "%lu\n", s->min_partial);
}

static ssize_t min_partial_store(struct kmem_cache *s, const char *buf,
				 size_t length)
{
	unsigned long min;
	int err;

	err = strict_strtoul(buf, 10, &min);
	if (err)
		return err;

4431
	set_min_partial(s, min);
4432 4433 4434 4435
	return length;
}
SLAB_ATTR(min_partial);

4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447 4448 4449
static ssize_t cpu_partial_show(struct kmem_cache *s, char *buf)
{
	return sprintf(buf, "%u\n", s->cpu_partial);
}

static ssize_t cpu_partial_store(struct kmem_cache *s, const char *buf,
				 size_t length)
{
	unsigned long objects;
	int err;

	err = strict_strtoul(buf, 10, &objects);
	if (err)
		return err;
4450 4451
	if (objects && kmem_cache_debug(s))
		return -EINVAL;
4452 4453 4454 4455 4456 4457 4458

	s->cpu_partial = objects;
	flush_all(s);
	return length;
}
SLAB_ATTR(cpu_partial);

C
Christoph Lameter 已提交
4459 4460
static ssize_t ctor_show(struct kmem_cache *s, char *buf)
{
J
Joe Perches 已提交
4461 4462 4463
	if (!s->ctor)
		return 0;
	return sprintf(buf, "%pS\n", s->ctor);
C
Christoph Lameter 已提交
4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474
}
SLAB_ATTR_RO(ctor);

static ssize_t aliases_show(struct kmem_cache *s, char *buf)
{
	return sprintf(buf, "%d\n", s->refcount - 1);
}
SLAB_ATTR_RO(aliases);

static ssize_t partial_show(struct kmem_cache *s, char *buf)
{
4475
	return show_slab_objects(s, buf, SO_PARTIAL);
C
Christoph Lameter 已提交
4476 4477 4478 4479 4480
}
SLAB_ATTR_RO(partial);

static ssize_t cpu_slabs_show(struct kmem_cache *s, char *buf)
{
4481
	return show_slab_objects(s, buf, SO_CPU);
C
Christoph Lameter 已提交
4482 4483 4484 4485 4486
}
SLAB_ATTR_RO(cpu_slabs);

static ssize_t objects_show(struct kmem_cache *s, char *buf)
{
4487
	return show_slab_objects(s, buf, SO_ALL|SO_OBJECTS);
C
Christoph Lameter 已提交
4488 4489 4490
}
SLAB_ATTR_RO(objects);

4491 4492 4493 4494 4495 4496
static ssize_t objects_partial_show(struct kmem_cache *s, char *buf)
{
	return show_slab_objects(s, buf, SO_PARTIAL|SO_OBJECTS);
}
SLAB_ATTR_RO(objects_partial);

4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 4522 4523 4524 4525 4526 4527
static ssize_t slabs_cpu_partial_show(struct kmem_cache *s, char *buf)
{
	int objects = 0;
	int pages = 0;
	int cpu;
	int len;

	for_each_online_cpu(cpu) {
		struct page *page = per_cpu_ptr(s->cpu_slab, cpu)->partial;

		if (page) {
			pages += page->pages;
			objects += page->pobjects;
		}
	}

	len = sprintf(buf, "%d(%d)", objects, pages);

#ifdef CONFIG_SMP
	for_each_online_cpu(cpu) {
		struct page *page = per_cpu_ptr(s->cpu_slab, cpu) ->partial;

		if (page && len < PAGE_SIZE - 20)
			len += sprintf(buf + len, " C%d=%d(%d)", cpu,
				page->pobjects, page->pages);
	}
#endif
	return len + sprintf(buf + len, "\n");
}
SLAB_ATTR_RO(slabs_cpu_partial);

4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562
static ssize_t reclaim_account_show(struct kmem_cache *s, char *buf)
{
	return sprintf(buf, "%d\n", !!(s->flags & SLAB_RECLAIM_ACCOUNT));
}

static ssize_t reclaim_account_store(struct kmem_cache *s,
				const char *buf, size_t length)
{
	s->flags &= ~SLAB_RECLAIM_ACCOUNT;
	if (buf[0] == '1')
		s->flags |= SLAB_RECLAIM_ACCOUNT;
	return length;
}
SLAB_ATTR(reclaim_account);

static ssize_t hwcache_align_show(struct kmem_cache *s, char *buf)
{
	return sprintf(buf, "%d\n", !!(s->flags & SLAB_HWCACHE_ALIGN));
}
SLAB_ATTR_RO(hwcache_align);

#ifdef CONFIG_ZONE_DMA
static ssize_t cache_dma_show(struct kmem_cache *s, char *buf)
{
	return sprintf(buf, "%d\n", !!(s->flags & SLAB_CACHE_DMA));
}
SLAB_ATTR_RO(cache_dma);
#endif

static ssize_t destroy_by_rcu_show(struct kmem_cache *s, char *buf)
{
	return sprintf(buf, "%d\n", !!(s->flags & SLAB_DESTROY_BY_RCU));
}
SLAB_ATTR_RO(destroy_by_rcu);

4563 4564 4565 4566 4567 4568
static ssize_t reserved_show(struct kmem_cache *s, char *buf)
{
	return sprintf(buf, "%d\n", s->reserved);
}
SLAB_ATTR_RO(reserved);

4569
#ifdef CONFIG_SLUB_DEBUG
4570 4571 4572 4573 4574 4575
static ssize_t slabs_show(struct kmem_cache *s, char *buf)
{
	return show_slab_objects(s, buf, SO_ALL);
}
SLAB_ATTR_RO(slabs);

4576 4577 4578 4579 4580 4581
static ssize_t total_objects_show(struct kmem_cache *s, char *buf)
{
	return show_slab_objects(s, buf, SO_ALL|SO_TOTAL);
}
SLAB_ATTR_RO(total_objects);

C
Christoph Lameter 已提交
4582 4583 4584 4585 4586 4587 4588 4589 4590
static ssize_t sanity_checks_show(struct kmem_cache *s, char *buf)
{
	return sprintf(buf, "%d\n", !!(s->flags & SLAB_DEBUG_FREE));
}

static ssize_t sanity_checks_store(struct kmem_cache *s,
				const char *buf, size_t length)
{
	s->flags &= ~SLAB_DEBUG_FREE;
4591 4592
	if (buf[0] == '1') {
		s->flags &= ~__CMPXCHG_DOUBLE;
C
Christoph Lameter 已提交
4593
		s->flags |= SLAB_DEBUG_FREE;
4594
	}
C
Christoph Lameter 已提交
4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607
	return length;
}
SLAB_ATTR(sanity_checks);

static ssize_t trace_show(struct kmem_cache *s, char *buf)
{
	return sprintf(buf, "%d\n", !!(s->flags & SLAB_TRACE));
}

static ssize_t trace_store(struct kmem_cache *s, const char *buf,
							size_t length)
{
	s->flags &= ~SLAB_TRACE;
4608 4609
	if (buf[0] == '1') {
		s->flags &= ~__CMPXCHG_DOUBLE;
C
Christoph Lameter 已提交
4610
		s->flags |= SLAB_TRACE;
4611
	}
C
Christoph Lameter 已提交
4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627
	return length;
}
SLAB_ATTR(trace);

static ssize_t red_zone_show(struct kmem_cache *s, char *buf)
{
	return sprintf(buf, "%d\n", !!(s->flags & SLAB_RED_ZONE));
}

static ssize_t red_zone_store(struct kmem_cache *s,
				const char *buf, size_t length)
{
	if (any_slab_objects(s))
		return -EBUSY;

	s->flags &= ~SLAB_RED_ZONE;
4628 4629
	if (buf[0] == '1') {
		s->flags &= ~__CMPXCHG_DOUBLE;
C
Christoph Lameter 已提交
4630
		s->flags |= SLAB_RED_ZONE;
4631
	}
4632
	calculate_sizes(s, -1);
C
Christoph Lameter 已提交
4633 4634 4635 4636 4637 4638 4639 4640 4641 4642 4643 4644 4645 4646 4647 4648
	return length;
}
SLAB_ATTR(red_zone);

static ssize_t poison_show(struct kmem_cache *s, char *buf)
{
	return sprintf(buf, "%d\n", !!(s->flags & SLAB_POISON));
}

static ssize_t poison_store(struct kmem_cache *s,
				const char *buf, size_t length)
{
	if (any_slab_objects(s))
		return -EBUSY;

	s->flags &= ~SLAB_POISON;
4649 4650
	if (buf[0] == '1') {
		s->flags &= ~__CMPXCHG_DOUBLE;
C
Christoph Lameter 已提交
4651
		s->flags |= SLAB_POISON;
4652
	}
4653
	calculate_sizes(s, -1);
C
Christoph Lameter 已提交
4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669
	return length;
}
SLAB_ATTR(poison);

static ssize_t store_user_show(struct kmem_cache *s, char *buf)
{
	return sprintf(buf, "%d\n", !!(s->flags & SLAB_STORE_USER));
}

static ssize_t store_user_store(struct kmem_cache *s,
				const char *buf, size_t length)
{
	if (any_slab_objects(s))
		return -EBUSY;

	s->flags &= ~SLAB_STORE_USER;
4670 4671
	if (buf[0] == '1') {
		s->flags &= ~__CMPXCHG_DOUBLE;
C
Christoph Lameter 已提交
4672
		s->flags |= SLAB_STORE_USER;
4673
	}
4674
	calculate_sizes(s, -1);
C
Christoph Lameter 已提交
4675 4676 4677 4678
	return length;
}
SLAB_ATTR(store_user);

4679 4680 4681 4682 4683 4684 4685 4686
static ssize_t validate_show(struct kmem_cache *s, char *buf)
{
	return 0;
}

static ssize_t validate_store(struct kmem_cache *s,
			const char *buf, size_t length)
{
4687 4688 4689 4690 4691 4692 4693 4694
	int ret = -EINVAL;

	if (buf[0] == '1') {
		ret = validate_slab_cache(s);
		if (ret >= 0)
			ret = length;
	}
	return ret;
4695 4696
}
SLAB_ATTR(validate);
4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729

static ssize_t alloc_calls_show(struct kmem_cache *s, char *buf)
{
	if (!(s->flags & SLAB_STORE_USER))
		return -ENOSYS;
	return list_locations(s, buf, TRACK_ALLOC);
}
SLAB_ATTR_RO(alloc_calls);

static ssize_t free_calls_show(struct kmem_cache *s, char *buf)
{
	if (!(s->flags & SLAB_STORE_USER))
		return -ENOSYS;
	return list_locations(s, buf, TRACK_FREE);
}
SLAB_ATTR_RO(free_calls);
#endif /* CONFIG_SLUB_DEBUG */

#ifdef CONFIG_FAILSLAB
static ssize_t failslab_show(struct kmem_cache *s, char *buf)
{
	return sprintf(buf, "%d\n", !!(s->flags & SLAB_FAILSLAB));
}

static ssize_t failslab_store(struct kmem_cache *s, const char *buf,
							size_t length)
{
	s->flags &= ~SLAB_FAILSLAB;
	if (buf[0] == '1')
		s->flags |= SLAB_FAILSLAB;
	return length;
}
SLAB_ATTR(failslab);
4730
#endif
4731

4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750
static ssize_t shrink_show(struct kmem_cache *s, char *buf)
{
	return 0;
}

static ssize_t shrink_store(struct kmem_cache *s,
			const char *buf, size_t length)
{
	if (buf[0] == '1') {
		int rc = kmem_cache_shrink(s);

		if (rc)
			return rc;
	} else
		return -EINVAL;
	return length;
}
SLAB_ATTR(shrink);

C
Christoph Lameter 已提交
4751
#ifdef CONFIG_NUMA
4752
static ssize_t remote_node_defrag_ratio_show(struct kmem_cache *s, char *buf)
C
Christoph Lameter 已提交
4753
{
4754
	return sprintf(buf, "%d\n", s->remote_node_defrag_ratio / 10);
C
Christoph Lameter 已提交
4755 4756
}

4757
static ssize_t remote_node_defrag_ratio_store(struct kmem_cache *s,
C
Christoph Lameter 已提交
4758 4759
				const char *buf, size_t length)
{
4760 4761 4762 4763 4764 4765 4766
	unsigned long ratio;
	int err;

	err = strict_strtoul(buf, 10, &ratio);
	if (err)
		return err;

4767
	if (ratio <= 100)
4768
		s->remote_node_defrag_ratio = ratio * 10;
C
Christoph Lameter 已提交
4769 4770 4771

	return length;
}
4772
SLAB_ATTR(remote_node_defrag_ratio);
C
Christoph Lameter 已提交
4773 4774
#endif

4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786
#ifdef CONFIG_SLUB_STATS
static int show_stat(struct kmem_cache *s, char *buf, enum stat_item si)
{
	unsigned long sum  = 0;
	int cpu;
	int len;
	int *data = kmalloc(nr_cpu_ids * sizeof(int), GFP_KERNEL);

	if (!data)
		return -ENOMEM;

	for_each_online_cpu(cpu) {
4787
		unsigned x = per_cpu_ptr(s->cpu_slab, cpu)->stat[si];
4788 4789 4790 4791 4792 4793 4794

		data[cpu] = x;
		sum += x;
	}

	len = sprintf(buf, "%lu", sum);

4795
#ifdef CONFIG_SMP
4796 4797
	for_each_online_cpu(cpu) {
		if (data[cpu] && len < PAGE_SIZE - 20)
4798
			len += sprintf(buf + len, " C%d=%u", cpu, data[cpu]);
4799
	}
4800
#endif
4801 4802 4803 4804
	kfree(data);
	return len + sprintf(buf + len, "\n");
}

D
David Rientjes 已提交
4805 4806 4807 4808 4809
static void clear_stat(struct kmem_cache *s, enum stat_item si)
{
	int cpu;

	for_each_online_cpu(cpu)
4810
		per_cpu_ptr(s->cpu_slab, cpu)->stat[si] = 0;
D
David Rientjes 已提交
4811 4812
}

4813 4814 4815 4816 4817
#define STAT_ATTR(si, text) 					\
static ssize_t text##_show(struct kmem_cache *s, char *buf)	\
{								\
	return show_stat(s, buf, si);				\
}								\
D
David Rientjes 已提交
4818 4819 4820 4821 4822 4823 4824 4825 4826
static ssize_t text##_store(struct kmem_cache *s,		\
				const char *buf, size_t length)	\
{								\
	if (buf[0] != '0')					\
		return -EINVAL;					\
	clear_stat(s, si);					\
	return length;						\
}								\
SLAB_ATTR(text);						\
4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837

STAT_ATTR(ALLOC_FASTPATH, alloc_fastpath);
STAT_ATTR(ALLOC_SLOWPATH, alloc_slowpath);
STAT_ATTR(FREE_FASTPATH, free_fastpath);
STAT_ATTR(FREE_SLOWPATH, free_slowpath);
STAT_ATTR(FREE_FROZEN, free_frozen);
STAT_ATTR(FREE_ADD_PARTIAL, free_add_partial);
STAT_ATTR(FREE_REMOVE_PARTIAL, free_remove_partial);
STAT_ATTR(ALLOC_FROM_PARTIAL, alloc_from_partial);
STAT_ATTR(ALLOC_SLAB, alloc_slab);
STAT_ATTR(ALLOC_REFILL, alloc_refill);
4838
STAT_ATTR(ALLOC_NODE_MISMATCH, alloc_node_mismatch);
4839 4840 4841 4842 4843 4844 4845
STAT_ATTR(FREE_SLAB, free_slab);
STAT_ATTR(CPUSLAB_FLUSH, cpuslab_flush);
STAT_ATTR(DEACTIVATE_FULL, deactivate_full);
STAT_ATTR(DEACTIVATE_EMPTY, deactivate_empty);
STAT_ATTR(DEACTIVATE_TO_HEAD, deactivate_to_head);
STAT_ATTR(DEACTIVATE_TO_TAIL, deactivate_to_tail);
STAT_ATTR(DEACTIVATE_REMOTE_FREES, deactivate_remote_frees);
4846
STAT_ATTR(DEACTIVATE_BYPASS, deactivate_bypass);
4847
STAT_ATTR(ORDER_FALLBACK, order_fallback);
4848 4849
STAT_ATTR(CMPXCHG_DOUBLE_CPU_FAIL, cmpxchg_double_cpu_fail);
STAT_ATTR(CMPXCHG_DOUBLE_FAIL, cmpxchg_double_fail);
4850 4851
STAT_ATTR(CPU_PARTIAL_ALLOC, cpu_partial_alloc);
STAT_ATTR(CPU_PARTIAL_FREE, cpu_partial_free);
4852 4853
STAT_ATTR(CPU_PARTIAL_NODE, cpu_partial_node);
STAT_ATTR(CPU_PARTIAL_DRAIN, cpu_partial_drain);
4854 4855
#endif

P
Pekka Enberg 已提交
4856
static struct attribute *slab_attrs[] = {
C
Christoph Lameter 已提交
4857 4858 4859 4860
	&slab_size_attr.attr,
	&object_size_attr.attr,
	&objs_per_slab_attr.attr,
	&order_attr.attr,
4861
	&min_partial_attr.attr,
4862
	&cpu_partial_attr.attr,
C
Christoph Lameter 已提交
4863
	&objects_attr.attr,
4864
	&objects_partial_attr.attr,
C
Christoph Lameter 已提交
4865 4866 4867 4868 4869 4870 4871 4872
	&partial_attr.attr,
	&cpu_slabs_attr.attr,
	&ctor_attr.attr,
	&aliases_attr.attr,
	&align_attr.attr,
	&hwcache_align_attr.attr,
	&reclaim_account_attr.attr,
	&destroy_by_rcu_attr.attr,
4873
	&shrink_attr.attr,
4874
	&reserved_attr.attr,
4875
	&slabs_cpu_partial_attr.attr,
4876
#ifdef CONFIG_SLUB_DEBUG
4877 4878 4879 4880
	&total_objects_attr.attr,
	&slabs_attr.attr,
	&sanity_checks_attr.attr,
	&trace_attr.attr,
C
Christoph Lameter 已提交
4881 4882 4883
	&red_zone_attr.attr,
	&poison_attr.attr,
	&store_user_attr.attr,
4884
	&validate_attr.attr,
4885 4886
	&alloc_calls_attr.attr,
	&free_calls_attr.attr,
4887
#endif
C
Christoph Lameter 已提交
4888 4889 4890 4891
#ifdef CONFIG_ZONE_DMA
	&cache_dma_attr.attr,
#endif
#ifdef CONFIG_NUMA
4892
	&remote_node_defrag_ratio_attr.attr,
4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904
#endif
#ifdef CONFIG_SLUB_STATS
	&alloc_fastpath_attr.attr,
	&alloc_slowpath_attr.attr,
	&free_fastpath_attr.attr,
	&free_slowpath_attr.attr,
	&free_frozen_attr.attr,
	&free_add_partial_attr.attr,
	&free_remove_partial_attr.attr,
	&alloc_from_partial_attr.attr,
	&alloc_slab_attr.attr,
	&alloc_refill_attr.attr,
4905
	&alloc_node_mismatch_attr.attr,
4906 4907 4908 4909 4910 4911 4912
	&free_slab_attr.attr,
	&cpuslab_flush_attr.attr,
	&deactivate_full_attr.attr,
	&deactivate_empty_attr.attr,
	&deactivate_to_head_attr.attr,
	&deactivate_to_tail_attr.attr,
	&deactivate_remote_frees_attr.attr,
4913
	&deactivate_bypass_attr.attr,
4914
	&order_fallback_attr.attr,
4915 4916
	&cmpxchg_double_fail_attr.attr,
	&cmpxchg_double_cpu_fail_attr.attr,
4917 4918
	&cpu_partial_alloc_attr.attr,
	&cpu_partial_free_attr.attr,
4919 4920
	&cpu_partial_node_attr.attr,
	&cpu_partial_drain_attr.attr,
C
Christoph Lameter 已提交
4921
#endif
4922 4923 4924 4925
#ifdef CONFIG_FAILSLAB
	&failslab_attr.attr,
#endif

C
Christoph Lameter 已提交
4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949 4950 4951 4952 4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966
	NULL
};

static struct attribute_group slab_attr_group = {
	.attrs = slab_attrs,
};

static ssize_t slab_attr_show(struct kobject *kobj,
				struct attribute *attr,
				char *buf)
{
	struct slab_attribute *attribute;
	struct kmem_cache *s;
	int err;

	attribute = to_slab_attr(attr);
	s = to_slab(kobj);

	if (!attribute->show)
		return -EIO;

	err = attribute->show(s, buf);

	return err;
}

static ssize_t slab_attr_store(struct kobject *kobj,
				struct attribute *attr,
				const char *buf, size_t len)
{
	struct slab_attribute *attribute;
	struct kmem_cache *s;
	int err;

	attribute = to_slab_attr(attr);
	s = to_slab(kobj);

	if (!attribute->store)
		return -EIO;

	err = attribute->store(s, buf, len);
4967 4968 4969
#ifdef CONFIG_MEMCG_KMEM
	if (slab_state >= FULL && err >= 0 && is_root_cache(s)) {
		int i;
C
Christoph Lameter 已提交
4970

4971 4972 4973 4974
		mutex_lock(&slab_mutex);
		if (s->max_attr_size < len)
			s->max_attr_size = len;

4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991
		/*
		 * This is a best effort propagation, so this function's return
		 * value will be determined by the parent cache only. This is
		 * basically because not all attributes will have a well
		 * defined semantics for rollbacks - most of the actions will
		 * have permanent effects.
		 *
		 * Returning the error value of any of the children that fail
		 * is not 100 % defined, in the sense that users seeing the
		 * error code won't be able to know anything about the state of
		 * the cache.
		 *
		 * Only returning the error code for the parent cache at least
		 * has well defined semantics. The cache being written to
		 * directly either failed or succeeded, in which case we loop
		 * through the descendants with best-effort propagation.
		 */
4992 4993 4994 4995 4996 4997 4998 4999
		for_each_memcg_cache_index(i) {
			struct kmem_cache *c = cache_from_memcg(s, i);
			if (c)
				attribute->store(c, buf, len);
		}
		mutex_unlock(&slab_mutex);
	}
#endif
C
Christoph Lameter 已提交
5000 5001 5002
	return err;
}

5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055
static void memcg_propagate_slab_attrs(struct kmem_cache *s)
{
#ifdef CONFIG_MEMCG_KMEM
	int i;
	char *buffer = NULL;

	if (!is_root_cache(s))
		return;

	/*
	 * This mean this cache had no attribute written. Therefore, no point
	 * in copying default values around
	 */
	if (!s->max_attr_size)
		return;

	for (i = 0; i < ARRAY_SIZE(slab_attrs); i++) {
		char mbuf[64];
		char *buf;
		struct slab_attribute *attr = to_slab_attr(slab_attrs[i]);

		if (!attr || !attr->store || !attr->show)
			continue;

		/*
		 * It is really bad that we have to allocate here, so we will
		 * do it only as a fallback. If we actually allocate, though,
		 * we can just use the allocated buffer until the end.
		 *
		 * Most of the slub attributes will tend to be very small in
		 * size, but sysfs allows buffers up to a page, so they can
		 * theoretically happen.
		 */
		if (buffer)
			buf = buffer;
		else if (s->max_attr_size < ARRAY_SIZE(mbuf))
			buf = mbuf;
		else {
			buffer = (char *) get_zeroed_page(GFP_KERNEL);
			if (WARN_ON(!buffer))
				continue;
			buf = buffer;
		}

		attr->show(s->memcg_params->root_cache, buf);
		attr->store(s, buf, strlen(buf));
	}

	if (buffer)
		free_page((unsigned long)buffer);
#endif
}

5056
static const struct sysfs_ops slab_sysfs_ops = {
C
Christoph Lameter 已提交
5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073
	.show = slab_attr_show,
	.store = slab_attr_store,
};

static struct kobj_type slab_ktype = {
	.sysfs_ops = &slab_sysfs_ops,
};

static int uevent_filter(struct kset *kset, struct kobject *kobj)
{
	struct kobj_type *ktype = get_ktype(kobj);

	if (ktype == &slab_ktype)
		return 1;
	return 0;
}

5074
static const struct kset_uevent_ops slab_uevent_ops = {
C
Christoph Lameter 已提交
5075 5076 5077
	.filter = uevent_filter,
};

5078
static struct kset *slab_kset;
C
Christoph Lameter 已提交
5079 5080 5081 5082

#define ID_STR_LENGTH 64

/* Create a unique string id for a slab cache:
C
Christoph Lameter 已提交
5083 5084
 *
 * Format	:[flags-]size
C
Christoph Lameter 已提交
5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106
 */
static char *create_unique_id(struct kmem_cache *s)
{
	char *name = kmalloc(ID_STR_LENGTH, GFP_KERNEL);
	char *p = name;

	BUG_ON(!name);

	*p++ = ':';
	/*
	 * First flags affecting slabcache operations. We will only
	 * get here for aliasable slabs so we do not need to support
	 * too many flags. The flags here must cover all flags that
	 * are matched during merging to guarantee that the id is
	 * unique.
	 */
	if (s->flags & SLAB_CACHE_DMA)
		*p++ = 'd';
	if (s->flags & SLAB_RECLAIM_ACCOUNT)
		*p++ = 'a';
	if (s->flags & SLAB_DEBUG_FREE)
		*p++ = 'F';
V
Vegard Nossum 已提交
5107 5108
	if (!(s->flags & SLAB_NOTRACK))
		*p++ = 't';
C
Christoph Lameter 已提交
5109 5110 5111
	if (p != name + 1)
		*p++ = '-';
	p += sprintf(p, "%07d", s->size);
5112 5113 5114 5115 5116 5117

#ifdef CONFIG_MEMCG_KMEM
	if (!is_root_cache(s))
		p += sprintf(p, "-%08d", memcg_cache_id(s->memcg_params->memcg));
#endif

C
Christoph Lameter 已提交
5118 5119 5120 5121 5122 5123 5124 5125
	BUG_ON(p > name + ID_STR_LENGTH - 1);
	return name;
}

static int sysfs_slab_add(struct kmem_cache *s)
{
	int err;
	const char *name;
5126
	int unmergeable = slab_unmergeable(s);
C
Christoph Lameter 已提交
5127 5128 5129 5130 5131 5132 5133

	if (unmergeable) {
		/*
		 * Slabcache can never be merged so we can use the name proper.
		 * This is typically the case for debug situations. In that
		 * case we can catch duplicate names easily.
		 */
5134
		sysfs_remove_link(&slab_kset->kobj, s->name);
C
Christoph Lameter 已提交
5135 5136 5137 5138 5139 5140 5141 5142 5143
		name = s->name;
	} else {
		/*
		 * Create a unique name for the slab as a target
		 * for the symlinks.
		 */
		name = create_unique_id(s);
	}

5144
	s->kobj.kset = slab_kset;
5145 5146 5147
	err = kobject_init_and_add(&s->kobj, &slab_ktype, NULL, name);
	if (err) {
		kobject_put(&s->kobj);
C
Christoph Lameter 已提交
5148
		return err;
5149
	}
C
Christoph Lameter 已提交
5150 5151

	err = sysfs_create_group(&s->kobj, &slab_attr_group);
5152 5153 5154
	if (err) {
		kobject_del(&s->kobj);
		kobject_put(&s->kobj);
C
Christoph Lameter 已提交
5155
		return err;
5156
	}
C
Christoph Lameter 已提交
5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167
	kobject_uevent(&s->kobj, KOBJ_ADD);
	if (!unmergeable) {
		/* Setup first alias */
		sysfs_slab_alias(s, s->name);
		kfree(name);
	}
	return 0;
}

static void sysfs_slab_remove(struct kmem_cache *s)
{
5168
	if (slab_state < FULL)
5169 5170 5171 5172 5173 5174
		/*
		 * Sysfs has not been setup yet so no need to remove the
		 * cache from sysfs.
		 */
		return;

C
Christoph Lameter 已提交
5175 5176
	kobject_uevent(&s->kobj, KOBJ_REMOVE);
	kobject_del(&s->kobj);
C
Christoph Lameter 已提交
5177
	kobject_put(&s->kobj);
C
Christoph Lameter 已提交
5178 5179 5180 5181
}

/*
 * Need to buffer aliases during bootup until sysfs becomes
N
Nick Andrew 已提交
5182
 * available lest we lose that information.
C
Christoph Lameter 已提交
5183 5184 5185 5186 5187 5188 5189
 */
struct saved_alias {
	struct kmem_cache *s;
	const char *name;
	struct saved_alias *next;
};

A
Adrian Bunk 已提交
5190
static struct saved_alias *alias_list;
C
Christoph Lameter 已提交
5191 5192 5193 5194 5195

static int sysfs_slab_alias(struct kmem_cache *s, const char *name)
{
	struct saved_alias *al;

5196
	if (slab_state == FULL) {
C
Christoph Lameter 已提交
5197 5198 5199
		/*
		 * If we have a leftover link then remove it.
		 */
5200 5201
		sysfs_remove_link(&slab_kset->kobj, name);
		return sysfs_create_link(&slab_kset->kobj, &s->kobj, name);
C
Christoph Lameter 已提交
5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216
	}

	al = kmalloc(sizeof(struct saved_alias), GFP_KERNEL);
	if (!al)
		return -ENOMEM;

	al->s = s;
	al->name = name;
	al->next = alias_list;
	alias_list = al;
	return 0;
}

static int __init slab_sysfs_init(void)
{
5217
	struct kmem_cache *s;
C
Christoph Lameter 已提交
5218 5219
	int err;

5220
	mutex_lock(&slab_mutex);
5221

5222
	slab_kset = kset_create_and_add("slab", &slab_uevent_ops, kernel_kobj);
5223
	if (!slab_kset) {
5224
		mutex_unlock(&slab_mutex);
C
Christoph Lameter 已提交
5225 5226 5227 5228
		printk(KERN_ERR "Cannot register slab subsystem.\n");
		return -ENOSYS;
	}

5229
	slab_state = FULL;
5230

5231
	list_for_each_entry(s, &slab_caches, list) {
5232
		err = sysfs_slab_add(s);
5233 5234 5235
		if (err)
			printk(KERN_ERR "SLUB: Unable to add boot slab %s"
						" to sysfs\n", s->name);
5236
	}
C
Christoph Lameter 已提交
5237 5238 5239 5240 5241 5242

	while (alias_list) {
		struct saved_alias *al = alias_list;

		alias_list = alias_list->next;
		err = sysfs_slab_alias(al->s, al->name);
5243 5244
		if (err)
			printk(KERN_ERR "SLUB: Unable to add boot slab alias"
5245
					" %s to sysfs\n", al->name);
C
Christoph Lameter 已提交
5246 5247 5248
		kfree(al);
	}

5249
	mutex_unlock(&slab_mutex);
C
Christoph Lameter 已提交
5250 5251 5252 5253 5254
	resiliency_test();
	return 0;
}

__initcall(slab_sysfs_init);
5255
#endif /* CONFIG_SYSFS */
P
Pekka J Enberg 已提交
5256 5257 5258 5259

/*
 * The /proc/slabinfo ABI
 */
5260
#ifdef CONFIG_SLABINFO
5261
void get_slabinfo(struct kmem_cache *s, struct slabinfo *sinfo)
P
Pekka J Enberg 已提交
5262 5263 5264
{
	unsigned long nr_partials = 0;
	unsigned long nr_slabs = 0;
5265 5266
	unsigned long nr_objs = 0;
	unsigned long nr_free = 0;
P
Pekka J Enberg 已提交
5267 5268 5269 5270 5271 5272 5273 5274 5275 5276
	int node;

	for_each_online_node(node) {
		struct kmem_cache_node *n = get_node(s, node);

		if (!n)
			continue;

		nr_partials += n->nr_partial;
		nr_slabs += atomic_long_read(&n->nr_slabs);
5277 5278
		nr_objs += atomic_long_read(&n->total_objects);
		nr_free += count_partial(n, count_free);
P
Pekka J Enberg 已提交
5279 5280
	}

5281 5282 5283 5284 5285 5286
	sinfo->active_objs = nr_objs - nr_free;
	sinfo->num_objs = nr_objs;
	sinfo->active_slabs = nr_slabs;
	sinfo->num_slabs = nr_slabs;
	sinfo->objects_per_slab = oo_objects(s->oo);
	sinfo->cache_order = oo_order(s->oo);
P
Pekka J Enberg 已提交
5287 5288
}

5289
void slabinfo_show_stats(struct seq_file *m, struct kmem_cache *s)
5290 5291 5292
{
}

5293 5294
ssize_t slabinfo_write(struct file *file, const char __user *buffer,
		       size_t count, loff_t *ppos)
5295
{
5296
	return -EIO;
5297
}
5298
#endif /* CONFIG_SLABINFO */