Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * SLUB: A slab allocator that limits cache line use instead of queuing
4 : : * objects in per cpu and per node lists.
5 : : *
6 : : * The allocator synchronizes using per slab locks or atomic operatios
7 : : * and only uses a centralized lock to manage a pool of partial slabs.
8 : : *
9 : : * (C) 2007 SGI, Christoph Lameter
10 : : * (C) 2011 Linux Foundation, Christoph Lameter
11 : : */
12 : :
13 : : #include <linux/mm.h>
14 : : #include <linux/swap.h> /* struct reclaim_state */
15 : : #include <linux/module.h>
16 : : #include <linux/bit_spinlock.h>
17 : : #include <linux/interrupt.h>
18 : : #include <linux/bitops.h>
19 : : #include <linux/slab.h>
20 : : #include "slab.h"
21 : : #include <linux/proc_fs.h>
22 : : #include <linux/seq_file.h>
23 : : #include <linux/kasan.h>
24 : : #include <linux/cpu.h>
25 : : #include <linux/cpuset.h>
26 : : #include <linux/mempolicy.h>
27 : : #include <linux/ctype.h>
28 : : #include <linux/debugobjects.h>
29 : : #include <linux/kallsyms.h>
30 : : #include <linux/memory.h>
31 : : #include <linux/math64.h>
32 : : #include <linux/fault-inject.h>
33 : : #include <linux/stacktrace.h>
34 : : #include <linux/prefetch.h>
35 : : #include <linux/memcontrol.h>
36 : : #include <linux/random.h>
37 : :
38 : : #include <trace/events/kmem.h>
39 : :
40 : : #include "internal.h"
41 : :
42 : : /*
43 : : * Lock order:
44 : : * 1. slab_mutex (Global Mutex)
45 : : * 2. node->list_lock
46 : : * 3. slab_lock(page) (Only on some arches and for debugging)
47 : : *
48 : : * slab_mutex
49 : : *
50 : : * The role of the slab_mutex is to protect the list of all the slabs
51 : : * and to synchronize major metadata changes to slab cache structures.
52 : : *
53 : : * The slab_lock is only used for debugging and on arches that do not
54 : : * have the ability to do a cmpxchg_double. It only protects:
55 : : * A. page->freelist -> List of object free in a page
56 : : * B. page->inuse -> Number of objects in use
57 : : * C. page->objects -> Number of objects in page
58 : : * D. page->frozen -> frozen state
59 : : *
60 : : * If a slab is frozen then it is exempt from list management. It is not
61 : : * on any list except per cpu partial list. The processor that froze the
62 : : * slab is the one who can perform list operations on the page. Other
63 : : * processors may put objects onto the freelist but the processor that
64 : : * froze the slab is the only one that can retrieve the objects from the
65 : : * page's freelist.
66 : : *
67 : : * The list_lock protects the partial and full list on each node and
68 : : * the partial slab counter. If taken then no new slabs may be added or
69 : : * removed from the lists nor make the number of partial slabs be modified.
70 : : * (Note that the total number of slabs is an atomic value that may be
71 : : * modified without taking the list lock).
72 : : *
73 : : * The list_lock is a centralized lock and thus we avoid taking it as
74 : : * much as possible. As long as SLUB does not have to handle partial
75 : : * slabs, operations can continue without any centralized lock. F.e.
76 : : * allocating a long series of objects that fill up slabs does not require
77 : : * the list lock.
78 : : * Interrupts are disabled during allocation and deallocation in order to
79 : : * make the slab allocator safe to use in the context of an irq. In addition
80 : : * interrupts are disabled to ensure that the processor does not change
81 : : * while handling per_cpu slabs, due to kernel preemption.
82 : : *
83 : : * SLUB assigns one slab for allocation to each processor.
84 : : * Allocations only occur from these slabs called cpu slabs.
85 : : *
86 : : * Slabs with free elements are kept on a partial list and during regular
87 : : * operations no list for full slabs is used. If an object in a full slab is
88 : : * freed then the slab will show up again on the partial lists.
89 : : * We track full slabs for debugging purposes though because otherwise we
90 : : * cannot scan all objects.
91 : : *
92 : : * Slabs are freed when they become empty. Teardown and setup is
93 : : * minimal so we rely on the page allocators per cpu caches for
94 : : * fast frees and allocs.
95 : : *
96 : : * page->frozen The slab is frozen and exempt from list processing.
97 : : * This means that the slab is dedicated to a purpose
98 : : * such as satisfying allocations for a specific
99 : : * processor. Objects may be freed in the slab while
100 : : * it is frozen but slab_free will then skip the usual
101 : : * list operations. It is up to the processor holding
102 : : * the slab to integrate the slab into the slab lists
103 : : * when the slab is no longer needed.
104 : : *
105 : : * One use of this flag is to mark slabs that are
106 : : * used for allocations. Then such a slab becomes a cpu
107 : : * slab. The cpu slab may be equipped with an additional
108 : : * freelist that allows lockless access to
109 : : * free objects in addition to the regular freelist
110 : : * that requires the slab lock.
111 : : *
112 : : * SLAB_DEBUG_FLAGS Slab requires special handling due to debug
113 : : * options set. This moves slab handling out of
114 : : * the fast path and disables lockless freelists.
115 : : */
116 : :
117 : 3923400 : static inline int kmem_cache_debug(struct kmem_cache *s)
118 : : {
119 : : #ifdef CONFIG_SLUB_DEBUG
120 : 3923400 : return unlikely(s->flags & SLAB_DEBUG_FLAGS);
121 : : #else
122 : : return 0;
123 : : #endif
124 : : }
125 : :
126 : 1979957 : void *fixup_red_left(struct kmem_cache *s, void *p)
127 : : {
128 [ - - - - : 1912190 : if (kmem_cache_debug(s) && s->flags & SLAB_RED_ZONE)
- - - - -
- - - - +
- - ]
129 : 0 : p += s->red_left_pad;
130 : :
131 : 1979957 : return p;
132 : : }
133 : :
134 : 156238 : static inline bool kmem_cache_has_cpu_partial(struct kmem_cache *s)
135 : : {
136 : : #ifdef CONFIG_SLUB_CPU_PARTIAL
137 : 156238 : return !kmem_cache_debug(s);
138 : : #else
139 : : return false;
140 : : #endif
141 : : }
142 : :
143 : : /*
144 : : * Issues still to be resolved:
145 : : *
146 : : * - Support PAGE_ALLOC_DEBUG. Should be easy to do.
147 : : *
148 : : * - Variable sizing of the per node arrays
149 : : */
150 : :
151 : : /* Enable to test recovery from slab corruption on boot */
152 : : #undef SLUB_RESILIENCY_TEST
153 : :
154 : : /* Enable to log cmpxchg failures */
155 : : #undef SLUB_DEBUG_CMPXCHG
156 : :
157 : : /*
158 : : * Mininum number of partial slabs. These will be left on the partial
159 : : * lists even if they are empty. kmem_cache_shrink may reclaim them.
160 : : */
161 : : #define MIN_PARTIAL 5
162 : :
163 : : /*
164 : : * Maximum number of desirable partial slabs.
165 : : * The existence of more partial slabs makes kmem_cache_shrink
166 : : * sort the partial list by the number of objects in use.
167 : : */
168 : : #define MAX_PARTIAL 10
169 : :
170 : : #define DEBUG_DEFAULT_FLAGS (SLAB_CONSISTENCY_CHECKS | SLAB_RED_ZONE | \
171 : : SLAB_POISON | SLAB_STORE_USER)
172 : :
173 : : /*
174 : : * These debug flags cannot use CMPXCHG because there might be consistency
175 : : * issues when checking or reading debug information
176 : : */
177 : : #define SLAB_NO_CMPXCHG (SLAB_CONSISTENCY_CHECKS | SLAB_STORE_USER | \
178 : : SLAB_TRACE)
179 : :
180 : :
181 : : /*
182 : : * Debugging flags that require metadata to be stored in the slab. These get
183 : : * disabled when slub_debug=O is used and a cache's min order increases with
184 : : * metadata.
185 : : */
186 : : #define DEBUG_METADATA_FLAGS (SLAB_RED_ZONE | SLAB_POISON | SLAB_STORE_USER)
187 : :
188 : : #define OO_SHIFT 16
189 : : #define OO_MASK ((1 << OO_SHIFT) - 1)
190 : : #define MAX_OBJS_PER_PAGE 32767 /* since page.objects is u15 */
191 : :
192 : : /* Internal SLUB flags */
193 : : /* Poison object */
194 : : #define __OBJECT_POISON ((slab_flags_t __force)0x80000000U)
195 : : /* Use cmpxchg_double */
196 : : #define __CMPXCHG_DOUBLE ((slab_flags_t __force)0x40000000U)
197 : :
198 : : /*
199 : : * Tracking user of a slab.
200 : : */
201 : : #define TRACK_ADDRS_COUNT 16
202 : : struct track {
203 : : unsigned long addr; /* Called from address */
204 : : #ifdef CONFIG_STACKTRACE
205 : : unsigned long addrs[TRACK_ADDRS_COUNT]; /* Called from address */
206 : : #endif
207 : : int cpu; /* Was running on cpu */
208 : : int pid; /* Pid context */
209 : : unsigned long when; /* When did the operation occur */
210 : : };
211 : :
212 : : enum track_item { TRACK_ALLOC, TRACK_FREE };
213 : :
214 : : #ifdef CONFIG_SYSFS
215 : : static int sysfs_slab_add(struct kmem_cache *);
216 : : static int sysfs_slab_alias(struct kmem_cache *, const char *);
217 : : static void memcg_propagate_slab_attrs(struct kmem_cache *s);
218 : : static void sysfs_slab_remove(struct kmem_cache *s);
219 : : #else
220 : : static inline int sysfs_slab_add(struct kmem_cache *s) { return 0; }
221 : : static inline int sysfs_slab_alias(struct kmem_cache *s, const char *p)
222 : : { return 0; }
223 : : static inline void memcg_propagate_slab_attrs(struct kmem_cache *s) { }
224 : : static inline void sysfs_slab_remove(struct kmem_cache *s) { }
225 : : #endif
226 : :
227 : 2157192 : static inline void stat(const struct kmem_cache *s, enum stat_item si)
228 : : {
229 : : #ifdef CONFIG_SLUB_STATS
230 : : /*
231 : : * The rmw is racy on a preemptible kernel but this is acceptable, so
232 : : * avoid this_cpu_add()'s irq-disable overhead.
233 : : */
234 : : raw_cpu_inc(s->cpu_slab->stat[si]);
235 : : #endif
236 : 1990360 : }
237 : :
238 : : /********************************************************************
239 : : * Core slab cache functions
240 : : *******************************************************************/
241 : :
242 : : /*
243 : : * Returns freelist pointer (ptr). With hardening, this is obfuscated
244 : : * with an XOR of the address where the pointer is held and a per-cache
245 : : * random number.
246 : : */
247 : 7298030 : static inline void *freelist_ptr(const struct kmem_cache *s, void *ptr,
248 : : unsigned long ptr_addr)
249 : : {
250 : : #ifdef CONFIG_SLAB_FREELIST_HARDENED
251 : : /*
252 : : * When CONFIG_KASAN_SW_TAGS is enabled, ptr_addr might be tagged.
253 : : * Normally, this doesn't cause any issues, as both set_freepointer()
254 : : * and get_freepointer() are called with a pointer with the same tag.
255 : : * However, there are some issues with CONFIG_SLUB_DEBUG code. For
256 : : * example, when __free_slub() iterates over objects in a cache, it
257 : : * passes untagged pointers to check_object(). check_object() in turns
258 : : * calls get_freepointer() with an untagged pointer, which causes the
259 : : * freepointer to be restored incorrectly.
260 : : */
261 : : return (void *)((unsigned long)ptr ^ s->random ^
262 : : (unsigned long)kasan_reset_tag((void *)ptr_addr));
263 : : #else
264 : 7298030 : return ptr;
265 : : #endif
266 : : }
267 : :
268 : : /* Returns the freelist pointer recorded at location ptr_addr. */
269 : 4158560 : static inline void *freelist_dereference(const struct kmem_cache *s,
270 : : void *ptr_addr)
271 : : {
272 : 4158560 : return freelist_ptr(s, (void *)*(unsigned long *)(ptr_addr),
273 : : (unsigned long)ptr_addr);
274 : : }
275 : :
276 : 4158560 : static inline void *get_freepointer(struct kmem_cache *s, void *object)
277 : : {
278 : 4158560 : return freelist_dereference(s, object + s->offset);
279 : : }
280 : :
281 : 301075 : static void prefetch_freepointer(const struct kmem_cache *s, void *object)
282 : : {
283 : 301075 : prefetch(object + s->offset);
284 : 301075 : }
285 : :
286 : 2078220 : static inline void *get_freepointer_safe(struct kmem_cache *s, void *object)
287 : : {
288 : 2078220 : unsigned long freepointer_addr;
289 : 2078220 : void *p;
290 : :
291 : 2078220 : if (!debug_pagealloc_enabled_static())
292 : 2078220 : return get_freepointer(s, object);
293 : :
294 : : freepointer_addr = (unsigned long)object + s->offset;
295 : : probe_kernel_read(&p, (void **)freepointer_addr, sizeof(p));
296 : : return freelist_ptr(s, p, freepointer_addr);
297 : : }
298 : :
299 : 3139470 : static inline void set_freepointer(struct kmem_cache *s, void *object, void *fp)
300 : : {
301 : 3139470 : unsigned long freeptr_addr = (unsigned long)object + s->offset;
302 : :
303 : : #ifdef CONFIG_SLAB_FREELIST_HARDENED
304 : : BUG_ON(object == fp); /* naive detection of double free or corruption */
305 : : #endif
306 : :
307 : 3139470 : *(void **)freeptr_addr = freelist_ptr(s, fp, freeptr_addr);
308 : 0 : }
309 : :
310 : : /* Loop over all objects in a slab */
311 : : #define for_each_object(__p, __s, __addr, __objects) \
312 : : for (__p = fixup_red_left(__s, __addr); \
313 : : __p < (__addr) + (__objects) * (__s)->size; \
314 : : __p += (__s)->size)
315 : :
316 : : /* Determine object index from a given position */
317 : 0 : static inline unsigned int slab_index(void *p, struct kmem_cache *s, void *addr)
318 : : {
319 : 0 : return (kasan_reset_tag(p) - addr) / s->size;
320 : : }
321 : :
322 : 1983 : static inline unsigned int order_objects(unsigned int order, unsigned int size)
323 : : {
324 : 1983 : return ((unsigned int)PAGE_SIZE << order) / size;
325 : : }
326 : :
327 : 657 : static inline struct kmem_cache_order_objects oo_make(unsigned int order,
328 : : unsigned int size)
329 : : {
330 : 657 : struct kmem_cache_order_objects x = {
331 : 657 : (order << OO_SHIFT) + order_objects(order, size)
332 : : };
333 : :
334 : 657 : return x;
335 : : }
336 : :
337 : 133624 : static inline unsigned int oo_order(struct kmem_cache_order_objects x)
338 : : {
339 : 133624 : return x.x >> OO_SHIFT;
340 : : }
341 : :
342 : 69081 : static inline unsigned int oo_objects(struct kmem_cache_order_objects x)
343 : : {
344 : 69081 : return x.x & OO_MASK;
345 : : }
346 : :
347 : : /*
348 : : * Per slab locking using the pagelock
349 : : */
350 : 0 : static __always_inline void slab_lock(struct page *page)
351 : : {
352 : 0 : VM_BUG_ON_PAGE(PageTail(page), page);
353 : 0 : bit_spin_lock(PG_locked, &page->flags);
354 : : }
355 : :
356 : 0 : static __always_inline void slab_unlock(struct page *page)
357 : : {
358 : 0 : VM_BUG_ON_PAGE(PageTail(page), page);
359 : 0 : __bit_spin_unlock(PG_locked, &page->flags);
360 : : }
361 : :
362 : : /* Interrupts must be disabled (for the fallback code to work right) */
363 : : static inline bool __cmpxchg_double_slab(struct kmem_cache *s, struct page *page,
364 : : void *freelist_old, unsigned long counters_old,
365 : : void *freelist_new, unsigned long counters_new,
366 : : const char *n)
367 : : {
368 : : VM_BUG_ON(!irqs_disabled());
369 : : #if defined(CONFIG_HAVE_CMPXCHG_DOUBLE) && \
370 : : defined(CONFIG_HAVE_ALIGNED_STRUCT_PAGE)
371 : : if (s->flags & __CMPXCHG_DOUBLE) {
372 : : if (cmpxchg_double(&page->freelist, &page->counters,
373 : : freelist_old, counters_old,
374 : : freelist_new, counters_new))
375 : : return true;
376 : : } else
377 : : #endif
378 : : {
379 : : slab_lock(page);
380 : : if (page->freelist == freelist_old &&
381 : : page->counters == counters_old) {
382 : : page->freelist = freelist_new;
383 : : page->counters = counters_new;
384 : : slab_unlock(page);
385 : : return true;
386 : : }
387 : : slab_unlock(page);
388 : : }
389 : :
390 : : cpu_relax();
391 : : stat(s, CMPXCHG_DOUBLE_FAIL);
392 : :
393 : : #ifdef SLUB_DEBUG_CMPXCHG
394 : : pr_info("%s %s: cmpxchg double redo ", n, s->name);
395 : : #endif
396 : :
397 : : return false;
398 : : }
399 : :
400 : : static inline bool cmpxchg_double_slab(struct kmem_cache *s, struct page *page,
401 : : void *freelist_old, unsigned long counters_old,
402 : : void *freelist_new, unsigned long counters_new,
403 : : const char *n)
404 : : {
405 : : #if defined(CONFIG_HAVE_CMPXCHG_DOUBLE) && \
406 : : defined(CONFIG_HAVE_ALIGNED_STRUCT_PAGE)
407 : : if (s->flags & __CMPXCHG_DOUBLE) {
408 : : if (cmpxchg_double(&page->freelist, &page->counters,
409 : : freelist_old, counters_old,
410 : : freelist_new, counters_new))
411 : : return true;
412 : : } else
413 : : #endif
414 : : {
415 : : unsigned long flags;
416 : :
417 : : local_irq_save(flags);
418 : : slab_lock(page);
419 : : if (page->freelist == freelist_old &&
420 : : page->counters == counters_old) {
421 : : page->freelist = freelist_new;
422 : : page->counters = counters_new;
423 : : slab_unlock(page);
424 : : local_irq_restore(flags);
425 : : return true;
426 : : }
427 : : slab_unlock(page);
428 : : local_irq_restore(flags);
429 : : }
430 : :
431 : : cpu_relax();
432 : : stat(s, CMPXCHG_DOUBLE_FAIL);
433 : :
434 : : #ifdef SLUB_DEBUG_CMPXCHG
435 : : pr_info("%s %s: cmpxchg double redo ", n, s->name);
436 : : #endif
437 : :
438 : : return false;
439 : : }
440 : :
441 : : #ifdef CONFIG_SLUB_DEBUG
442 : : static unsigned long object_map[BITS_TO_LONGS(MAX_OBJS_PER_PAGE)];
443 : : static DEFINE_SPINLOCK(object_map_lock);
444 : :
445 : : /*
446 : : * Determine a map of object in use on a page.
447 : : *
448 : : * Node listlock must be held to guarantee that the page does
449 : : * not vanish from under us.
450 : : */
451 : 0 : static unsigned long *get_map(struct kmem_cache *s, struct page *page)
452 : : {
453 : 0 : void *p;
454 : 0 : void *addr = page_address(page);
455 : :
456 : 0 : VM_BUG_ON(!irqs_disabled());
457 : :
458 : 0 : spin_lock(&object_map_lock);
459 : :
460 : 0 : bitmap_zero(object_map, page->objects);
461 : :
462 [ # # ]: 0 : for (p = page->freelist; p; p = get_freepointer(s, p))
463 : 0 : set_bit(slab_index(p, s, addr), object_map);
464 : :
465 : 0 : return object_map;
466 : : }
467 : :
468 : 0 : static void put_map(unsigned long *map)
469 : : {
470 : 0 : VM_BUG_ON(map != object_map);
471 : 0 : lockdep_assert_held(&object_map_lock);
472 : :
473 : 0 : spin_unlock(&object_map_lock);
474 : 0 : }
475 : :
476 : 0 : static inline unsigned int size_from_object(struct kmem_cache *s)
477 : : {
478 : 0 : if (s->flags & SLAB_RED_ZONE)
479 : 0 : return s->size - s->red_left_pad;
480 : :
481 : 0 : return s->size;
482 : : }
483 : :
484 : 0 : static inline void *restore_red_left(struct kmem_cache *s, void *p)
485 : : {
486 : 0 : if (s->flags & SLAB_RED_ZONE)
487 : 0 : p -= s->red_left_pad;
488 : :
489 : 0 : return p;
490 : : }
491 : :
492 : : /*
493 : : * Debug settings:
494 : : */
495 : : #if defined(CONFIG_SLUB_DEBUG_ON)
496 : : static slab_flags_t slub_debug = DEBUG_DEFAULT_FLAGS;
497 : : #else
498 : : static slab_flags_t slub_debug;
499 : : #endif
500 : :
501 : : static char *slub_debug_slabs;
502 : : static int disable_higher_order_debug;
503 : :
504 : : /*
505 : : * slub is about to manipulate internal object metadata. This memory lies
506 : : * outside the range of the allocated object, so accessing it would normally
507 : : * be reported by kasan as a bounds error. metadata_access_enable() is used
508 : : * to tell kasan that these accesses are OK.
509 : : */
510 : 0 : static inline void metadata_access_enable(void)
511 : : {
512 : 0 : kasan_disable_current();
513 : : }
514 : :
515 : 0 : static inline void metadata_access_disable(void)
516 : : {
517 : 0 : kasan_enable_current();
518 : : }
519 : :
520 : : /*
521 : : * Object debugging
522 : : */
523 : :
524 : : /* Verify that a pointer has an address that is valid within a slab page */
525 : 0 : static inline int check_valid_pointer(struct kmem_cache *s,
526 : : struct page *page, void *object)
527 : : {
528 : 0 : void *base;
529 : :
530 [ # # ]: 0 : if (!object)
531 : : return 1;
532 : :
533 [ # # ]: 0 : base = page_address(page);
534 [ # # ]: 0 : object = kasan_reset_tag(object);
535 [ # # ]: 0 : object = restore_red_left(s, object);
536 [ # # # # ]: 0 : if (object < base || object >= base + page->objects * s->size ||
537 [ # # ]: 0 : (object - base) % s->size) {
538 : 0 : return 0;
539 : : }
540 : :
541 : : return 1;
542 : : }
543 : :
544 : 0 : static void print_section(char *level, char *text, u8 *addr,
545 : : unsigned int length)
546 : : {
547 : 0 : metadata_access_enable();
548 : 0 : print_hex_dump(level, text, DUMP_PREFIX_ADDRESS, 16, 1, addr,
549 : : length, 1);
550 : 0 : metadata_access_disable();
551 : 0 : }
552 : :
553 : 0 : static struct track *get_track(struct kmem_cache *s, void *object,
554 : : enum track_item alloc)
555 : : {
556 : 0 : struct track *p;
557 : :
558 : 0 : if (s->offset)
559 : 0 : p = object + s->offset + sizeof(void *);
560 : : else
561 : 0 : p = object + s->inuse;
562 : :
563 : 0 : return p + alloc;
564 : : }
565 : :
566 : 0 : static void set_track(struct kmem_cache *s, void *object,
567 : : enum track_item alloc, unsigned long addr)
568 : : {
569 [ # # ]: 0 : struct track *p = get_track(s, object, alloc);
570 : :
571 [ # # ]: 0 : if (addr) {
572 : : #ifdef CONFIG_STACKTRACE
573 : 0 : unsigned int nr_entries;
574 : :
575 : 0 : metadata_access_enable();
576 : 0 : nr_entries = stack_trace_save(p->addrs, TRACK_ADDRS_COUNT, 3);
577 : 0 : metadata_access_disable();
578 : :
579 [ # # ]: 0 : if (nr_entries < TRACK_ADDRS_COUNT)
580 : 0 : p->addrs[nr_entries] = 0;
581 : : #endif
582 : 0 : p->addr = addr;
583 : 0 : p->cpu = smp_processor_id();
584 : 0 : p->pid = current->pid;
585 : 0 : p->when = jiffies;
586 : : } else {
587 : 0 : memset(p, 0, sizeof(struct track));
588 : : }
589 : 0 : }
590 : :
591 : 3 : static void init_tracking(struct kmem_cache *s, void *object)
592 : : {
593 [ - + ]: 3 : if (!(s->flags & SLAB_STORE_USER))
594 : : return;
595 : :
596 : 0 : set_track(s, object, TRACK_FREE, 0UL);
597 : 0 : set_track(s, object, TRACK_ALLOC, 0UL);
598 : : }
599 : :
600 : 0 : static void print_track(const char *s, struct track *t, unsigned long pr_time)
601 : : {
602 [ # # ]: 0 : if (!t->addr)
603 : : return;
604 : :
605 : 0 : pr_err("INFO: %s in %pS age=%lu cpu=%u pid=%d\n",
606 : : s, (void *)t->addr, pr_time - t->when, t->cpu, t->pid);
607 : : #ifdef CONFIG_STACKTRACE
608 : : {
609 : 0 : int i;
610 [ # # ]: 0 : for (i = 0; i < TRACK_ADDRS_COUNT; i++)
611 [ # # ]: 0 : if (t->addrs[i])
612 : 0 : pr_err("\t%pS\n", (void *)t->addrs[i]);
613 : : else
614 : : break;
615 : : }
616 : : #endif
617 : : }
618 : :
619 : 0 : static void print_tracking(struct kmem_cache *s, void *object)
620 : : {
621 : 0 : unsigned long pr_time = jiffies;
622 [ # # ]: 0 : if (!(s->flags & SLAB_STORE_USER))
623 : : return;
624 : :
625 [ # # ]: 0 : print_track("Allocated", get_track(s, object, TRACK_ALLOC), pr_time);
626 [ # # ]: 0 : print_track("Freed", get_track(s, object, TRACK_FREE), pr_time);
627 : : }
628 : :
629 : 0 : static void print_page_info(struct page *page)
630 : : {
631 : 0 : pr_err("INFO: Slab 0x%p objects=%u used=%u fp=0x%p flags=0x%04lx\n",
632 : : page, page->objects, page->inuse, page->freelist, page->flags);
633 : :
634 : 0 : }
635 : :
636 : 0 : static void slab_bug(struct kmem_cache *s, char *fmt, ...)
637 : : {
638 : 0 : struct va_format vaf;
639 : 0 : va_list args;
640 : :
641 : 0 : va_start(args, fmt);
642 : 0 : vaf.fmt = fmt;
643 : 0 : vaf.va = &args;
644 : 0 : pr_err("=============================================================================\n");
645 : 0 : pr_err("BUG %s (%s): %pV\n", s->name, print_tainted(), &vaf);
646 : 0 : pr_err("-----------------------------------------------------------------------------\n\n");
647 : :
648 : 0 : add_taint(TAINT_BAD_PAGE, LOCKDEP_NOW_UNRELIABLE);
649 : 0 : va_end(args);
650 : 0 : }
651 : :
652 : 0 : static void slab_fix(struct kmem_cache *s, char *fmt, ...)
653 : : {
654 : 0 : struct va_format vaf;
655 : 0 : va_list args;
656 : :
657 : 0 : va_start(args, fmt);
658 : 0 : vaf.fmt = fmt;
659 : 0 : vaf.va = &args;
660 : 0 : pr_err("FIX %s: %pV\n", s->name, &vaf);
661 : 0 : va_end(args);
662 : 0 : }
663 : :
664 : 0 : static void print_trailer(struct kmem_cache *s, struct page *page, u8 *p)
665 : : {
666 : 0 : unsigned int off; /* Offset of last byte */
667 : 0 : u8 *addr = page_address(page);
668 : :
669 : 0 : print_tracking(s, p);
670 : :
671 : 0 : print_page_info(page);
672 : :
673 : 0 : pr_err("INFO: Object 0x%p @offset=%tu fp=0x%p\n\n",
674 : : p, p - addr, get_freepointer(s, p));
675 : :
676 [ # # ]: 0 : if (s->flags & SLAB_RED_ZONE)
677 : 0 : print_section(KERN_ERR, "Redzone ", p - s->red_left_pad,
678 : : s->red_left_pad);
679 [ # # ]: 0 : else if (p > addr + 16)
680 : 0 : print_section(KERN_ERR, "Bytes b4 ", p - 16, 16);
681 : :
682 : 0 : print_section(KERN_ERR, "Object ", p,
683 : 0 : min_t(unsigned int, s->object_size, PAGE_SIZE));
684 [ # # ]: 0 : if (s->flags & SLAB_RED_ZONE)
685 : 0 : print_section(KERN_ERR, "Redzone ", p + s->object_size,
686 : 0 : s->inuse - s->object_size);
687 : :
688 [ # # ]: 0 : if (s->offset)
689 : 0 : off = s->offset + sizeof(void *);
690 : : else
691 : 0 : off = s->inuse;
692 : :
693 [ # # ]: 0 : if (s->flags & SLAB_STORE_USER)
694 : 0 : off += 2 * sizeof(struct track);
695 : :
696 : 0 : off += kasan_metadata_size(s);
697 : :
698 [ # # # # ]: 0 : if (off != size_from_object(s))
699 : : /* Beginning of the filler is the free pointer */
700 : 0 : print_section(KERN_ERR, "Padding ", p + off,
701 : : size_from_object(s) - off);
702 : :
703 : 0 : dump_stack();
704 : 0 : }
705 : :
706 : 0 : void object_err(struct kmem_cache *s, struct page *page,
707 : : u8 *object, char *reason)
708 : : {
709 : 0 : slab_bug(s, "%s", reason);
710 : 0 : print_trailer(s, page, object);
711 : 0 : }
712 : :
713 : 0 : static __printf(3, 4) void slab_err(struct kmem_cache *s, struct page *page,
714 : : const char *fmt, ...)
715 : : {
716 : 0 : va_list args;
717 : 0 : char buf[100];
718 : :
719 : 0 : va_start(args, fmt);
720 : 0 : vsnprintf(buf, sizeof(buf), fmt, args);
721 : 0 : va_end(args);
722 : 0 : slab_bug(s, "%s", buf);
723 : 0 : print_page_info(page);
724 : 0 : dump_stack();
725 : 0 : }
726 : :
727 : 3 : static void init_object(struct kmem_cache *s, void *object, u8 val)
728 : : {
729 : 3 : u8 *p = object;
730 : :
731 [ - + ]: 3 : if (s->flags & SLAB_RED_ZONE)
732 : 0 : memset(p - s->red_left_pad, val, s->red_left_pad);
733 : :
734 [ - + ]: 3 : if (s->flags & __OBJECT_POISON) {
735 : 0 : memset(p, POISON_FREE, s->object_size - 1);
736 : 0 : p[s->object_size - 1] = POISON_END;
737 : : }
738 : :
739 [ - + ]: 3 : if (s->flags & SLAB_RED_ZONE)
740 : 0 : memset(p + s->object_size, val, s->inuse - s->object_size);
741 : 3 : }
742 : :
743 : 0 : static void restore_bytes(struct kmem_cache *s, char *message, u8 data,
744 : : void *from, void *to)
745 : : {
746 : 0 : slab_fix(s, "Restoring 0x%p-0x%p=0x%x\n", from, to - 1, data);
747 : 0 : memset(from, data, to - from);
748 : 0 : }
749 : :
750 : 0 : static int check_bytes_and_report(struct kmem_cache *s, struct page *page,
751 : : u8 *object, char *what,
752 : : u8 *start, unsigned int value, unsigned int bytes)
753 : : {
754 : 0 : u8 *fault;
755 : 0 : u8 *end;
756 : 0 : u8 *addr = page_address(page);
757 : :
758 : 0 : metadata_access_enable();
759 : 0 : fault = memchr_inv(start, value, bytes);
760 : 0 : metadata_access_disable();
761 [ # # ]: 0 : if (!fault)
762 : : return 1;
763 : :
764 : 0 : end = start + bytes;
765 [ # # # # ]: 0 : while (end > fault && end[-1] == value)
766 : 0 : end--;
767 : :
768 : 0 : slab_bug(s, "%s overwritten", what);
769 : 0 : pr_err("INFO: 0x%p-0x%p @offset=%tu. First byte 0x%x instead of 0x%x\n",
770 : : fault, end - 1, fault - addr,
771 : : fault[0], value);
772 : 0 : print_trailer(s, page, object);
773 : :
774 : 0 : restore_bytes(s, what, value, fault, end);
775 : 0 : return 0;
776 : : }
777 : :
778 : : /*
779 : : * Object layout:
780 : : *
781 : : * object address
782 : : * Bytes of the object to be managed.
783 : : * If the freepointer may overlay the object then the free
784 : : * pointer is the first word of the object.
785 : : *
786 : : * Poisoning uses 0x6b (POISON_FREE) and the last byte is
787 : : * 0xa5 (POISON_END)
788 : : *
789 : : * object + s->object_size
790 : : * Padding to reach word boundary. This is also used for Redzoning.
791 : : * Padding is extended by another word if Redzoning is enabled and
792 : : * object_size == inuse.
793 : : *
794 : : * We fill with 0xbb (RED_INACTIVE) for inactive objects and with
795 : : * 0xcc (RED_ACTIVE) for objects in use.
796 : : *
797 : : * object + s->inuse
798 : : * Meta data starts here.
799 : : *
800 : : * A. Free pointer (if we cannot overwrite object on free)
801 : : * B. Tracking data for SLAB_STORE_USER
802 : : * C. Padding to reach required alignment boundary or at mininum
803 : : * one word if debugging is on to be able to detect writes
804 : : * before the word boundary.
805 : : *
806 : : * Padding is done using 0x5a (POISON_INUSE)
807 : : *
808 : : * object + s->size
809 : : * Nothing is used beyond s->size.
810 : : *
811 : : * If slabcaches are merged then the object_size and inuse boundaries are mostly
812 : : * ignored. And therefore no slab options that rely on these boundaries
813 : : * may be used with merged slabcaches.
814 : : */
815 : :
816 : 0 : static int check_pad_bytes(struct kmem_cache *s, struct page *page, u8 *p)
817 : : {
818 : 0 : unsigned long off = s->inuse; /* The end of info */
819 : :
820 [ # # ]: 0 : if (s->offset)
821 : : /* Freepointer is placed after the object. */
822 : 0 : off += sizeof(void *);
823 : :
824 [ # # ]: 0 : if (s->flags & SLAB_STORE_USER)
825 : : /* We also have user information there */
826 : 0 : off += 2 * sizeof(struct track);
827 : :
828 : 0 : off += kasan_metadata_size(s);
829 : :
830 [ # # # # ]: 0 : if (size_from_object(s) == off)
831 : : return 1;
832 : :
833 : 0 : return check_bytes_and_report(s, page, p, "Object padding",
834 : : p + off, POISON_INUSE, size_from_object(s) - off);
835 : : }
836 : :
837 : : /* Check the pad bytes at the end of a slab page */
838 : 0 : static int slab_pad_check(struct kmem_cache *s, struct page *page)
839 : : {
840 : 0 : u8 *start;
841 : 0 : u8 *fault;
842 : 0 : u8 *end;
843 : 0 : u8 *pad;
844 : 0 : int length;
845 : 0 : int remainder;
846 : :
847 [ # # ]: 0 : if (!(s->flags & SLAB_POISON))
848 : : return 1;
849 : :
850 : 0 : start = page_address(page);
851 : 0 : length = page_size(page);
852 : 0 : end = start + length;
853 : 0 : remainder = length % s->size;
854 [ # # ]: 0 : if (!remainder)
855 : : return 1;
856 : :
857 : 0 : pad = end - remainder;
858 : 0 : metadata_access_enable();
859 : 0 : fault = memchr_inv(pad, POISON_INUSE, remainder);
860 : 0 : metadata_access_disable();
861 [ # # ]: 0 : if (!fault)
862 : : return 1;
863 [ # # # # ]: 0 : while (end > fault && end[-1] == POISON_INUSE)
864 : 0 : end--;
865 : :
866 : 0 : slab_err(s, page, "Padding overwritten. 0x%p-0x%p @offset=%tu",
867 : : fault, end - 1, fault - start);
868 : 0 : print_section(KERN_ERR, "Padding ", pad, remainder);
869 : :
870 : 0 : restore_bytes(s, "slab padding", POISON_INUSE, fault, end);
871 : 0 : return 0;
872 : : }
873 : :
874 : 0 : static int check_object(struct kmem_cache *s, struct page *page,
875 : : void *object, u8 val)
876 : : {
877 : 0 : u8 *p = object;
878 : 0 : u8 *endobject = object + s->object_size;
879 : :
880 [ # # ]: 0 : if (s->flags & SLAB_RED_ZONE) {
881 [ # # ]: 0 : if (!check_bytes_and_report(s, page, object, "Redzone",
882 : 0 : object - s->red_left_pad, val, s->red_left_pad))
883 : : return 0;
884 : :
885 [ # # ]: 0 : if (!check_bytes_and_report(s, page, object, "Redzone",
886 : 0 : endobject, val, s->inuse - s->object_size))
887 : : return 0;
888 : : } else {
889 [ # # # # ]: 0 : if ((s->flags & SLAB_POISON) && s->object_size < s->inuse) {
890 : 0 : check_bytes_and_report(s, page, p, "Alignment padding",
891 : : endobject, POISON_INUSE,
892 : : s->inuse - s->object_size);
893 : : }
894 : : }
895 : :
896 [ # # ]: 0 : if (s->flags & SLAB_POISON) {
897 [ # # # # : 0 : if (val != SLUB_RED_ACTIVE && (s->flags & __OBJECT_POISON) &&
# # ]
898 : 0 : (!check_bytes_and_report(s, page, p, "Poison", p,
899 [ # # ]: 0 : POISON_FREE, s->object_size - 1) ||
900 : 0 : !check_bytes_and_report(s, page, p, "Poison",
901 : 0 : p + s->object_size - 1, POISON_END, 1)))
902 : 0 : return 0;
903 : : /*
904 : : * check_pad_bytes cleans up on its own.
905 : : */
906 : 0 : check_pad_bytes(s, page, p);
907 : : }
908 : :
909 [ # # # # ]: 0 : if (!s->offset && val == SLUB_RED_ACTIVE)
910 : : /*
911 : : * Object and freepointer overlap. Cannot check
912 : : * freepointer while object is allocated.
913 : : */
914 : : return 1;
915 : :
916 : : /* Check free pointer validity */
917 [ # # ]: 0 : if (!check_valid_pointer(s, page, get_freepointer(s, p))) {
918 : 0 : object_err(s, page, p, "Freepointer corrupt");
919 : : /*
920 : : * No choice but to zap it and thus lose the remainder
921 : : * of the free objects in this slab. May cause
922 : : * another error because the object count is now wrong.
923 : : */
924 : 0 : set_freepointer(s, p, NULL);
925 : 0 : return 0;
926 : : }
927 : : return 1;
928 : : }
929 : :
930 : 0 : static int check_slab(struct kmem_cache *s, struct page *page)
931 : : {
932 : 0 : int maxobj;
933 : :
934 : 0 : VM_BUG_ON(!irqs_disabled());
935 : :
936 [ # # # # ]: 0 : if (!PageSlab(page)) {
937 : 0 : slab_err(s, page, "Not a valid slab page");
938 : 0 : return 0;
939 : : }
940 : :
941 : 0 : maxobj = order_objects(compound_order(page), s->size);
942 [ # # ]: 0 : if (page->objects > maxobj) {
943 : 0 : slab_err(s, page, "objects %u > max %u",
944 : : page->objects, maxobj);
945 : 0 : return 0;
946 : : }
947 [ # # ]: 0 : if (page->inuse > page->objects) {
948 : 0 : slab_err(s, page, "inuse %u > max %u",
949 : : page->inuse, page->objects);
950 : 0 : return 0;
951 : : }
952 : : /* Slab_pad_check fixes things up after itself */
953 : 0 : slab_pad_check(s, page);
954 : 0 : return 1;
955 : : }
956 : :
957 : : /*
958 : : * Determine if a certain object on a page is on the freelist. Must hold the
959 : : * slab lock to guarantee that the chains are in a consistent state.
960 : : */
961 : 0 : static int on_freelist(struct kmem_cache *s, struct page *page, void *search)
962 : : {
963 : 0 : int nr = 0;
964 : 0 : void *fp;
965 : 0 : void *object = NULL;
966 : 0 : int max_objects;
967 : :
968 : 0 : fp = page->freelist;
969 [ # # # # ]: 0 : while (fp && nr <= page->objects) {
970 [ # # ]: 0 : if (fp == search)
971 : : return 1;
972 [ # # ]: 0 : if (!check_valid_pointer(s, page, fp)) {
973 [ # # ]: 0 : if (object) {
974 : 0 : object_err(s, page, object,
975 : : "Freechain corrupt");
976 : 0 : set_freepointer(s, object, NULL);
977 : : } else {
978 : 0 : slab_err(s, page, "Freepointer corrupt");
979 : 0 : page->freelist = NULL;
980 : 0 : page->inuse = page->objects;
981 : 0 : slab_fix(s, "Freelist cleared");
982 : 0 : return 0;
983 : : }
984 : : break;
985 : : }
986 : 0 : object = fp;
987 : 0 : fp = get_freepointer(s, object);
988 : 0 : nr++;
989 : : }
990 : :
991 : 0 : max_objects = order_objects(compound_order(page), s->size);
992 : 0 : if (max_objects > MAX_OBJS_PER_PAGE)
993 : : max_objects = MAX_OBJS_PER_PAGE;
994 : :
995 [ # # ]: 0 : if (page->objects != max_objects) {
996 : 0 : slab_err(s, page, "Wrong number of objects. Found %d but should be %d",
997 : : page->objects, max_objects);
998 : 0 : page->objects = max_objects;
999 : 0 : slab_fix(s, "Number of objects adjusted.");
1000 : : }
1001 [ # # ]: 0 : if (page->inuse != page->objects - nr) {
1002 : 0 : slab_err(s, page, "Wrong object count. Counter is %d but counted were %d",
1003 : : page->inuse, page->objects - nr);
1004 : 0 : page->inuse = page->objects - nr;
1005 : 0 : slab_fix(s, "Object count adjusted.");
1006 : : }
1007 : 0 : return search == NULL;
1008 : : }
1009 : :
1010 : 0 : static void trace(struct kmem_cache *s, struct page *page, void *object,
1011 : : int alloc)
1012 : : {
1013 [ # # ]: 0 : if (s->flags & SLAB_TRACE) {
1014 [ # # ]: 0 : pr_info("TRACE %s %s 0x%p inuse=%d fp=0x%p\n",
1015 : : s->name,
1016 : : alloc ? "alloc" : "free",
1017 : : object, page->inuse,
1018 : : page->freelist);
1019 : :
1020 [ # # ]: 0 : if (!alloc)
1021 : 0 : print_section(KERN_INFO, "Object ", (void *)object,
1022 : : s->object_size);
1023 : :
1024 : 0 : dump_stack();
1025 : : }
1026 : 0 : }
1027 : :
1028 : : /*
1029 : : * Tracking of fully allocated slabs for debugging purposes.
1030 : : */
1031 : : static void add_full(struct kmem_cache *s,
1032 : : struct kmem_cache_node *n, struct page *page)
1033 : : {
1034 : : if (!(s->flags & SLAB_STORE_USER))
1035 : : return;
1036 : :
1037 : : lockdep_assert_held(&n->list_lock);
1038 : : list_add(&page->slab_list, &n->full);
1039 : : }
1040 : :
1041 : 0 : static void remove_full(struct kmem_cache *s, struct kmem_cache_node *n, struct page *page)
1042 : : {
1043 : 0 : if (!(s->flags & SLAB_STORE_USER))
1044 : : return;
1045 : :
1046 : 0 : lockdep_assert_held(&n->list_lock);
1047 : 0 : list_del(&page->slab_list);
1048 : : }
1049 : :
1050 : : /* Tracking of the number of slabs for debugging purposes */
1051 : 12 : static inline unsigned long slabs_node(struct kmem_cache *s, int node)
1052 : : {
1053 [ # # # # ]: 0 : struct kmem_cache_node *n = get_node(s, node);
1054 : :
1055 [ + + - - : 12 : return atomic_long_read(&n->nr_slabs);
- - ]
1056 : : }
1057 : :
1058 : 0 : static inline unsigned long node_nr_slabs(struct kmem_cache_node *n)
1059 : : {
1060 : 0 : return atomic_long_read(&n->nr_slabs);
1061 : : }
1062 : :
1063 : 67770 : static inline void inc_slabs_node(struct kmem_cache *s, int node, int objects)
1064 : : {
1065 [ + + ]: 67767 : struct kmem_cache_node *n = get_node(s, node);
1066 : :
1067 : : /*
1068 : : * May be called early in order to allocate a slab for the
1069 : : * kmem_cache_node structure. Solve the chicken-egg
1070 : : * dilemma by deferring the increment of the count during
1071 : : * bootstrap (see early_kmem_cache_node_alloc).
1072 : : */
1073 [ + - + + ]: 67770 : if (likely(n)) {
1074 : 67767 : atomic_long_inc(&n->nr_slabs);
1075 : 67767 : atomic_long_add(objects, &n->total_objects);
1076 : : }
1077 : : }
1078 : 44830 : static inline void dec_slabs_node(struct kmem_cache *s, int node, int objects)
1079 : : {
1080 : 44830 : struct kmem_cache_node *n = get_node(s, node);
1081 : :
1082 : 44830 : atomic_long_dec(&n->nr_slabs);
1083 : 44830 : atomic_long_sub(objects, &n->total_objects);
1084 : : }
1085 : :
1086 : : /* Object debug checks for alloc/free paths */
1087 : : static void setup_object_debug(struct kmem_cache *s, struct page *page,
1088 : : void *object)
1089 : : {
1090 : : if (!(s->flags & (SLAB_STORE_USER|SLAB_RED_ZONE|__OBJECT_POISON)))
1091 : : return;
1092 : :
1093 : : init_object(s, object, SLUB_RED_INACTIVE);
1094 : : init_tracking(s, object);
1095 : : }
1096 : :
1097 : : static
1098 : : void setup_page_debug(struct kmem_cache *s, struct page *page, void *addr)
1099 : : {
1100 : : if (!(s->flags & SLAB_POISON))
1101 : : return;
1102 : :
1103 : : metadata_access_enable();
1104 : : memset(addr, POISON_INUSE, page_size(page));
1105 : : metadata_access_disable();
1106 : : }
1107 : :
1108 : 0 : static inline int alloc_consistency_checks(struct kmem_cache *s,
1109 : : struct page *page, void *object)
1110 : : {
1111 [ # # ]: 0 : if (!check_slab(s, page))
1112 : : return 0;
1113 : :
1114 [ # # ]: 0 : if (!check_valid_pointer(s, page, object)) {
1115 : 0 : object_err(s, page, object, "Freelist Pointer check fails");
1116 : 0 : return 0;
1117 : : }
1118 : :
1119 [ # # ]: 0 : if (!check_object(s, page, object, SLUB_RED_INACTIVE))
1120 : 0 : return 0;
1121 : :
1122 : : return 1;
1123 : : }
1124 : :
1125 : 0 : static noinline int alloc_debug_processing(struct kmem_cache *s,
1126 : : struct page *page,
1127 : : void *object, unsigned long addr)
1128 : : {
1129 [ # # ]: 0 : if (s->flags & SLAB_CONSISTENCY_CHECKS) {
1130 [ # # ]: 0 : if (!alloc_consistency_checks(s, page, object))
1131 : 0 : goto bad;
1132 : : }
1133 : :
1134 : : /* Success perform special debug activities for allocs */
1135 [ # # ]: 0 : if (s->flags & SLAB_STORE_USER)
1136 : 0 : set_track(s, object, TRACK_ALLOC, addr);
1137 : 0 : trace(s, page, object, 1);
1138 : 0 : init_object(s, object, SLUB_RED_ACTIVE);
1139 : 0 : return 1;
1140 : :
1141 : : bad:
1142 [ # # # # ]: 0 : if (PageSlab(page)) {
1143 : : /*
1144 : : * If this is a slab page then lets do the best we can
1145 : : * to avoid issues in the future. Marking all objects
1146 : : * as used avoids touching the remaining objects.
1147 : : */
1148 : 0 : slab_fix(s, "Marking all objects used");
1149 : 0 : page->inuse = page->objects;
1150 : 0 : page->freelist = NULL;
1151 : : }
1152 : : return 0;
1153 : : }
1154 : :
1155 : : static inline int free_consistency_checks(struct kmem_cache *s,
1156 : : struct page *page, void *object, unsigned long addr)
1157 : : {
1158 : : if (!check_valid_pointer(s, page, object)) {
1159 : : slab_err(s, page, "Invalid object pointer 0x%p", object);
1160 : : return 0;
1161 : : }
1162 : :
1163 : : if (on_freelist(s, page, object)) {
1164 : : object_err(s, page, object, "Object already free");
1165 : : return 0;
1166 : : }
1167 : :
1168 : : if (!check_object(s, page, object, SLUB_RED_ACTIVE))
1169 : : return 0;
1170 : :
1171 : : if (unlikely(s != page->slab_cache)) {
1172 : : if (!PageSlab(page)) {
1173 : : slab_err(s, page, "Attempt to free object(0x%p) outside of slab",
1174 : : object);
1175 : : } else if (!page->slab_cache) {
1176 : : pr_err("SLUB <none>: no slab for object 0x%p.\n",
1177 : : object);
1178 : : dump_stack();
1179 : : } else
1180 : : object_err(s, page, object,
1181 : : "page slab pointer corrupt.");
1182 : : return 0;
1183 : : }
1184 : : return 1;
1185 : : }
1186 : :
1187 : : /* Supports checking bulk free of a constructed freelist */
1188 : 0 : static noinline int free_debug_processing(
1189 : : struct kmem_cache *s, struct page *page,
1190 : : void *head, void *tail, int bulk_cnt,
1191 : : unsigned long addr)
1192 : : {
1193 : 0 : struct kmem_cache_node *n = get_node(s, page_to_nid(page));
1194 : 0 : void *object = head;
1195 : 0 : int cnt = 0;
1196 : 0 : unsigned long uninitialized_var(flags);
1197 : 0 : int ret = 0;
1198 : :
1199 : 0 : spin_lock_irqsave(&n->list_lock, flags);
1200 : 0 : slab_lock(page);
1201 : :
1202 [ # # ]: 0 : if (s->flags & SLAB_CONSISTENCY_CHECKS) {
1203 [ # # ]: 0 : if (!check_slab(s, page))
1204 : 0 : goto out;
1205 : : }
1206 : :
1207 : 0 : next_object:
1208 : 0 : cnt++;
1209 : :
1210 [ # # ]: 0 : if (s->flags & SLAB_CONSISTENCY_CHECKS) {
1211 [ # # ]: 0 : if (!free_consistency_checks(s, page, object, addr))
1212 : 0 : goto out;
1213 : : }
1214 : :
1215 [ # # ]: 0 : if (s->flags & SLAB_STORE_USER)
1216 : 0 : set_track(s, object, TRACK_FREE, addr);
1217 : 0 : trace(s, page, object, 0);
1218 : : /* Freepointer not overwritten by init_object(), SLAB_POISON moved it */
1219 : 0 : init_object(s, object, SLUB_RED_INACTIVE);
1220 : :
1221 : : /* Reached end of constructed freelist yet? */
1222 [ # # ]: 0 : if (object != tail) {
1223 : 0 : object = get_freepointer(s, object);
1224 : 0 : goto next_object;
1225 : : }
1226 : : ret = 1;
1227 : :
1228 : 0 : out:
1229 [ # # ]: 0 : if (cnt != bulk_cnt)
1230 : 0 : slab_err(s, page, "Bulk freelist count(%d) invalid(%d)\n",
1231 : : bulk_cnt, cnt);
1232 : :
1233 : 0 : slab_unlock(page);
1234 : 0 : spin_unlock_irqrestore(&n->list_lock, flags);
1235 [ # # ]: 0 : if (!ret)
1236 : 0 : slab_fix(s, "Object at 0x%p not freed", object);
1237 : 0 : return ret;
1238 : : }
1239 : :
1240 : 0 : static int __init setup_slub_debug(char *str)
1241 : : {
1242 : 0 : slub_debug = DEBUG_DEFAULT_FLAGS;
1243 [ # # # # ]: 0 : if (*str++ != '=' || !*str)
1244 : : /*
1245 : : * No options specified. Switch on full debugging.
1246 : : */
1247 : 0 : goto out;
1248 : :
1249 [ # # ]: 0 : if (*str == ',')
1250 : : /*
1251 : : * No options but restriction on slabs. This means full
1252 : : * debugging for slabs matching a pattern.
1253 : : */
1254 : 0 : goto check_slabs;
1255 : :
1256 : 0 : slub_debug = 0;
1257 [ # # ]: 0 : if (*str == '-')
1258 : : /*
1259 : : * Switch off all debugging measures.
1260 : : */
1261 : 0 : goto out;
1262 : :
1263 : : /*
1264 : : * Determine which debug features should be switched on
1265 : : */
1266 [ # # ]: 0 : for (; *str && *str != ','; str++) {
1267 [ # # # # : 0 : switch (tolower(*str)) {
# # # # #
# ]
1268 : 0 : case 'f':
1269 : 0 : slub_debug |= SLAB_CONSISTENCY_CHECKS;
1270 : 0 : break;
1271 : 0 : case 'z':
1272 : 0 : slub_debug |= SLAB_RED_ZONE;
1273 : 0 : break;
1274 : 0 : case 'p':
1275 : 0 : slub_debug |= SLAB_POISON;
1276 : 0 : break;
1277 : 0 : case 'u':
1278 : 0 : slub_debug |= SLAB_STORE_USER;
1279 : 0 : break;
1280 : 0 : case 't':
1281 : 0 : slub_debug |= SLAB_TRACE;
1282 : 0 : break;
1283 : : case 'a':
1284 : : slub_debug |= SLAB_FAILSLAB;
1285 : : break;
1286 : 0 : case 'o':
1287 : : /*
1288 : : * Avoid enabling debugging on caches if its minimum
1289 : : * order would increase as a result.
1290 : : */
1291 : 0 : disable_higher_order_debug = 1;
1292 : 0 : break;
1293 : 0 : default:
1294 : 0 : pr_err("slub_debug option '%c' unknown. skipped\n",
1295 : : *str);
1296 : : }
1297 : : }
1298 : :
1299 : 0 : check_slabs:
1300 [ # # ]: 0 : if (*str == ',')
1301 : 0 : slub_debug_slabs = str + 1;
1302 : 0 : out:
1303 [ # # # # ]: 0 : if ((static_branch_unlikely(&init_on_alloc) ||
1304 [ # # # # ]: 0 : static_branch_unlikely(&init_on_free)) &&
1305 [ # # ]: 0 : (slub_debug & SLAB_POISON))
1306 : 0 : pr_info("mem auto-init: SLAB_POISON will take precedence over init_on_alloc/init_on_free\n");
1307 : 0 : return 1;
1308 : : }
1309 : :
1310 : : __setup("slub_debug", setup_slub_debug);
1311 : :
1312 : : /*
1313 : : * kmem_cache_flags - apply debugging options to the cache
1314 : : * @object_size: the size of an object without meta data
1315 : : * @flags: flags to set
1316 : : * @name: name of the cache
1317 : : * @ctor: constructor function
1318 : : *
1319 : : * Debug option(s) are applied to @flags. In addition to the debug
1320 : : * option(s), if a slab name (or multiple) is specified i.e.
1321 : : * slub_debug=<Debug-Options>,<slab name1>,<slab name2> ...
1322 : : * then only the select slabs will receive the debug option(s).
1323 : : */
1324 : 1104 : slab_flags_t kmem_cache_flags(unsigned int object_size,
1325 : : slab_flags_t flags, const char *name,
1326 : : void (*ctor)(void *))
1327 : : {
1328 : 1104 : char *iter;
1329 : 1104 : size_t len;
1330 : :
1331 : : /* If slub_debug = 0, it folds into the if conditional. */
1332 [ + - ]: 1104 : if (!slub_debug_slabs)
1333 : 1104 : return flags | slub_debug;
1334 : :
1335 : 0 : len = strlen(name);
1336 : 0 : iter = slub_debug_slabs;
1337 [ # # ]: 0 : while (*iter) {
1338 : 0 : char *end, *glob;
1339 : 0 : size_t cmplen;
1340 : :
1341 : 0 : end = strchrnul(iter, ',');
1342 : :
1343 : 0 : glob = strnchr(iter, end - iter, '*');
1344 [ # # ]: 0 : if (glob)
1345 : 0 : cmplen = glob - iter;
1346 : : else
1347 : 0 : cmplen = max_t(size_t, len, (end - iter));
1348 : :
1349 [ # # ]: 0 : if (!strncmp(name, iter, cmplen)) {
1350 : 0 : flags |= slub_debug;
1351 : 0 : break;
1352 : : }
1353 : :
1354 [ # # ]: 0 : if (!*end)
1355 : : break;
1356 : 0 : iter = end + 1;
1357 : : }
1358 : :
1359 : : return flags;
1360 : : }
1361 : : #else /* !CONFIG_SLUB_DEBUG */
1362 : : static inline void setup_object_debug(struct kmem_cache *s,
1363 : : struct page *page, void *object) {}
1364 : : static inline
1365 : : void setup_page_debug(struct kmem_cache *s, struct page *page, void *addr) {}
1366 : :
1367 : : static inline int alloc_debug_processing(struct kmem_cache *s,
1368 : : struct page *page, void *object, unsigned long addr) { return 0; }
1369 : :
1370 : : static inline int free_debug_processing(
1371 : : struct kmem_cache *s, struct page *page,
1372 : : void *head, void *tail, int bulk_cnt,
1373 : : unsigned long addr) { return 0; }
1374 : :
1375 : : static inline int slab_pad_check(struct kmem_cache *s, struct page *page)
1376 : : { return 1; }
1377 : : static inline int check_object(struct kmem_cache *s, struct page *page,
1378 : : void *object, u8 val) { return 1; }
1379 : : static inline void add_full(struct kmem_cache *s, struct kmem_cache_node *n,
1380 : : struct page *page) {}
1381 : : static inline void remove_full(struct kmem_cache *s, struct kmem_cache_node *n,
1382 : : struct page *page) {}
1383 : : slab_flags_t kmem_cache_flags(unsigned int object_size,
1384 : : slab_flags_t flags, const char *name,
1385 : : void (*ctor)(void *))
1386 : : {
1387 : : return flags;
1388 : : }
1389 : : #define slub_debug 0
1390 : :
1391 : : #define disable_higher_order_debug 0
1392 : :
1393 : : static inline unsigned long slabs_node(struct kmem_cache *s, int node)
1394 : : { return 0; }
1395 : : static inline unsigned long node_nr_slabs(struct kmem_cache_node *n)
1396 : : { return 0; }
1397 : : static inline void inc_slabs_node(struct kmem_cache *s, int node,
1398 : : int objects) {}
1399 : : static inline void dec_slabs_node(struct kmem_cache *s, int node,
1400 : : int objects) {}
1401 : :
1402 : : #endif /* CONFIG_SLUB_DEBUG */
1403 : :
1404 : : /*
1405 : : * Hooks for other subsystems that check memory allocations. In a typical
1406 : : * production configuration these hooks all should produce no code at all.
1407 : : */
1408 : 9 : static inline void *kmalloc_large_node_hook(void *ptr, size_t size, gfp_t flags)
1409 : : {
1410 : 9 : ptr = kasan_kmalloc_large(ptr, size, flags);
1411 : : /* As ptr might get tagged, call kmemleak hook after KASAN. */
1412 : 9 : kmemleak_alloc(ptr, size, 1, flags);
1413 : 9 : return ptr;
1414 : : }
1415 : :
1416 : 45 : static __always_inline void kfree_hook(void *x)
1417 : : {
1418 : 45 : kmemleak_free(x);
1419 : 45 : kasan_kfree_large(x, _RET_IP_);
1420 : : }
1421 : :
1422 : 1910999 : static __always_inline bool slab_free_hook(struct kmem_cache *s, void *x)
1423 : : {
1424 : 1910999 : kmemleak_free_recursive(x, s->flags);
1425 : :
1426 : : /*
1427 : : * Trouble is that we may no longer disable interrupts in the fast path
1428 : : * So in order to make the debug calls that expect irqs to be
1429 : : * disabled we need to disable interrupts temporarily.
1430 : : */
1431 : : #ifdef CONFIG_LOCKDEP
1432 : : {
1433 : : unsigned long flags;
1434 : :
1435 : : local_irq_save(flags);
1436 : : debug_check_no_locks_freed(x, s->object_size);
1437 : : local_irq_restore(flags);
1438 : : }
1439 : : #endif
1440 : 1910999 : if (!(s->flags & SLAB_DEBUG_OBJECTS))
1441 : 1910999 : debug_check_no_obj_freed(x, s->object_size);
1442 : :
1443 : : /* KASAN might put x into memory quarantine, delaying its reuse */
1444 : 1910999 : return kasan_slab_free(s, x, _RET_IP_);
1445 : : }
1446 : :
1447 : 1910999 : static inline bool slab_free_freelist_hook(struct kmem_cache *s,
1448 : : void **head, void **tail)
1449 : : {
1450 : :
1451 : 1910999 : void *object;
1452 : 1910999 : void *next = *head;
1453 [ + - ]: 1910999 : void *old_tail = *tail ? *tail : *head;
1454 : 1910999 : int rsize;
1455 : :
1456 : : /* Head and tail of the reconstructed freelist */
1457 : 1910999 : *head = NULL;
1458 : 1910999 : *tail = NULL;
1459 : :
1460 : 1910999 : do {
1461 : 1910999 : object = next;
1462 : 1910999 : next = get_freepointer(s, object);
1463 : :
1464 [ + - - - ]: 1910999 : if (slab_want_init_on_free(s)) {
1465 : : /*
1466 : : * Clear the object and the metadata, but don't touch
1467 : : * the redzone.
1468 : : */
1469 : 0 : memset(object, 0, s->object_size);
1470 : 0 : rsize = (s->flags & SLAB_RED_ZONE) ? s->red_left_pad
1471 [ # # ]: 0 : : 0;
1472 : 0 : memset((char *)object + s->inuse, 0,
1473 : : s->size - s->inuse - rsize);
1474 : :
1475 : : }
1476 : : /* If object's reuse doesn't have to be delayed */
1477 [ + + ]: 3822000 : if (!slab_free_hook(s, object)) {
1478 : : /* Move object to the new freelist */
1479 : 73554 : set_freepointer(s, object, *head);
1480 : 73554 : *head = object;
1481 [ + - ]: 73554 : if (!*tail)
1482 : 73554 : *tail = object;
1483 : : }
1484 [ - + ]: 1910999 : } while (object != old_tail);
1485 : :
1486 [ + - ]: 1910999 : if (*head == *tail)
1487 : 1910999 : *tail = NULL;
1488 : :
1489 : 1910999 : return *head != NULL;
1490 : : }
1491 : :
1492 : : static void *setup_object(struct kmem_cache *s, struct page *page,
1493 : : void *object)
1494 : : {
1495 : : setup_object_debug(s, page, object);
1496 : : object = kasan_init_slab_obj(s, object);
1497 : : if (unlikely(s->ctor)) {
1498 : : kasan_unpoison_object_data(s, object);
1499 : : s->ctor(object);
1500 : : kasan_poison_object_data(s, object);
1501 : : }
1502 : : return object;
1503 : : }
1504 : :
1505 : : /*
1506 : : * Slab allocation and freeing
1507 : : */
1508 : 67767 : static inline struct page *alloc_slab_page(struct kmem_cache *s,
1509 : : gfp_t flags, int node, struct kmem_cache_order_objects oo)
1510 : : {
1511 : 67767 : struct page *page;
1512 : 67767 : unsigned int order = oo_order(oo);
1513 : :
1514 [ + + ]: 67767 : if (node == NUMA_NO_NODE)
1515 : 67670 : page = alloc_pages(flags, order);
1516 : : else
1517 : 97 : page = __alloc_pages_node(node, flags, order);
1518 : :
1519 [ + - + + ]: 67767 : if (page && charge_slab_page(page, flags, order, s)) {
1520 : : __free_pages(page, order);
1521 : : page = NULL;
1522 : : }
1523 : :
1524 : 67767 : return page;
1525 : : }
1526 : :
1527 : : #ifdef CONFIG_SLAB_FREELIST_RANDOM
1528 : : /* Pre-initialize the random sequence cache */
1529 : : static int init_cache_random_seq(struct kmem_cache *s)
1530 : : {
1531 : : unsigned int count = oo_objects(s->oo);
1532 : : int err;
1533 : :
1534 : : /* Bailout if already initialised */
1535 : : if (s->random_seq)
1536 : : return 0;
1537 : :
1538 : : err = cache_random_seq_create(s, count, GFP_KERNEL);
1539 : : if (err) {
1540 : : pr_err("SLUB: Unable to initialize free list for %s\n",
1541 : : s->name);
1542 : : return err;
1543 : : }
1544 : :
1545 : : /* Transform to an offset on the set of pages */
1546 : : if (s->random_seq) {
1547 : : unsigned int i;
1548 : :
1549 : : for (i = 0; i < count; i++)
1550 : : s->random_seq[i] *= s->size;
1551 : : }
1552 : : return 0;
1553 : : }
1554 : :
1555 : : /* Initialize each random sequence freelist per cache */
1556 : : static void __init init_freelist_randomization(void)
1557 : : {
1558 : : struct kmem_cache *s;
1559 : :
1560 : : mutex_lock(&slab_mutex);
1561 : :
1562 : : list_for_each_entry(s, &slab_caches, list)
1563 : : init_cache_random_seq(s);
1564 : :
1565 : : mutex_unlock(&slab_mutex);
1566 : : }
1567 : :
1568 : : /* Get the next entry on the pre-computed freelist randomized */
1569 : : static void *next_freelist_entry(struct kmem_cache *s, struct page *page,
1570 : : unsigned long *pos, void *start,
1571 : : unsigned long page_limit,
1572 : : unsigned long freelist_count)
1573 : : {
1574 : : unsigned int idx;
1575 : :
1576 : : /*
1577 : : * If the target page allocation failed, the number of objects on the
1578 : : * page might be smaller than the usual size defined by the cache.
1579 : : */
1580 : : do {
1581 : : idx = s->random_seq[*pos];
1582 : : *pos += 1;
1583 : : if (*pos >= freelist_count)
1584 : : *pos = 0;
1585 : : } while (unlikely(idx >= page_limit));
1586 : :
1587 : : return (char *)start + idx;
1588 : : }
1589 : :
1590 : : /* Shuffle the single linked freelist based on a random pre-computed sequence */
1591 : : static bool shuffle_freelist(struct kmem_cache *s, struct page *page)
1592 : : {
1593 : : void *start;
1594 : : void *cur;
1595 : : void *next;
1596 : : unsigned long idx, pos, page_limit, freelist_count;
1597 : :
1598 : : if (page->objects < 2 || !s->random_seq)
1599 : : return false;
1600 : :
1601 : : freelist_count = oo_objects(s->oo);
1602 : : pos = get_random_int() % freelist_count;
1603 : :
1604 : : page_limit = page->objects * s->size;
1605 : : start = fixup_red_left(s, page_address(page));
1606 : :
1607 : : /* First entry is used as the base of the freelist */
1608 : : cur = next_freelist_entry(s, page, &pos, start, page_limit,
1609 : : freelist_count);
1610 : : cur = setup_object(s, page, cur);
1611 : : page->freelist = cur;
1612 : :
1613 : : for (idx = 1; idx < page->objects; idx++) {
1614 : : next = next_freelist_entry(s, page, &pos, start, page_limit,
1615 : : freelist_count);
1616 : : next = setup_object(s, page, next);
1617 : : set_freepointer(s, cur, next);
1618 : : cur = next;
1619 : : }
1620 : : set_freepointer(s, cur, NULL);
1621 : :
1622 : : return true;
1623 : : }
1624 : : #else
1625 : : static inline int init_cache_random_seq(struct kmem_cache *s)
1626 : : {
1627 : : return 0;
1628 : : }
1629 : 3 : static inline void init_freelist_randomization(void) { }
1630 : 67767 : static inline bool shuffle_freelist(struct kmem_cache *s, struct page *page)
1631 : : {
1632 : 67767 : return false;
1633 : : }
1634 : : #endif /* CONFIG_SLAB_FREELIST_RANDOM */
1635 : :
1636 : 67767 : static struct page *allocate_slab(struct kmem_cache *s, gfp_t flags, int node)
1637 : : {
1638 : 67767 : struct page *page;
1639 : 67767 : struct kmem_cache_order_objects oo = s->oo;
1640 : 67767 : gfp_t alloc_gfp;
1641 : 67767 : void *start, *p, *next;
1642 : 67767 : int idx;
1643 : 67767 : bool shuffle;
1644 : :
1645 : 67767 : flags &= gfp_allowed_mask;
1646 : :
1647 [ + + ]: 67767 : if (gfpflags_allow_blocking(flags))
1648 : 65857 : local_irq_enable();
1649 : :
1650 : 67767 : flags |= s->allocflags;
1651 : :
1652 : : /*
1653 : : * Let the initial higher-order allocation fail under memory pressure
1654 : : * so we fall-back to the minimum order allocation.
1655 : : */
1656 : 67767 : alloc_gfp = (flags | __GFP_NOWARN | __GFP_NORETRY) & ~__GFP_NOFAIL;
1657 [ + + + + ]: 67767 : if ((alloc_gfp & __GFP_DIRECT_RECLAIM) && oo_order(oo) > oo_order(s->min))
1658 : 26206 : alloc_gfp = (alloc_gfp | __GFP_NOMEMALLOC) & ~(__GFP_RECLAIM|__GFP_NOFAIL);
1659 : :
1660 : 67767 : page = alloc_slab_page(s, alloc_gfp, node, oo);
1661 [ - + ]: 67767 : if (unlikely(!page)) {
1662 : 0 : oo = s->min;
1663 : 0 : alloc_gfp = flags;
1664 : : /*
1665 : : * Allocation may have failed due to fragmentation.
1666 : : * Try a lower order alloc if possible
1667 : : */
1668 : 0 : page = alloc_slab_page(s, alloc_gfp, node, oo);
1669 [ # # ]: 0 : if (unlikely(!page))
1670 : 0 : goto out;
1671 : : stat(s, ORDER_FALLBACK);
1672 : : }
1673 : :
1674 : 67767 : page->objects = oo_objects(oo);
1675 : :
1676 : 67767 : page->slab_cache = s;
1677 [ - + ]: 67767 : __SetPageSlab(page);
1678 [ - + ]: 67767 : if (page_is_pfmemalloc(page))
1679 : 0 : SetPageSlabPfmemalloc(page);
1680 : :
1681 : 67767 : kasan_poison_slab(page);
1682 : :
1683 : 67767 : start = page_address(page);
1684 : :
1685 : 67767 : setup_page_debug(s, page, start);
1686 : :
1687 : 67767 : shuffle = shuffle_freelist(s, page);
1688 : :
1689 : 67767 : if (!shuffle) {
1690 [ - + ]: 67767 : start = fixup_red_left(s, start);
1691 : 67767 : start = setup_object(s, page, start);
1692 : 67767 : page->freelist = start;
1693 [ + + ]: 1304544 : for (idx = 0, p = start; idx < page->objects - 1; idx++) {
1694 : 1236777 : next = p + s->size;
1695 : 1236777 : next = setup_object(s, page, next);
1696 : 1236777 : set_freepointer(s, p, next);
1697 : 1236777 : p = next;
1698 : : }
1699 : 67767 : set_freepointer(s, p, NULL);
1700 : : }
1701 : :
1702 : 67767 : page->inuse = page->objects;
1703 : 67767 : page->frozen = 1;
1704 : :
1705 : 67767 : out:
1706 [ + + ]: 67767 : if (gfpflags_allow_blocking(flags))
1707 : 65857 : local_irq_disable();
1708 [ + - ]: 67767 : if (!page)
1709 : : return NULL;
1710 : :
1711 [ + + ]: 67767 : inc_slabs_node(s, page_to_nid(page), page->objects);
1712 : :
1713 : : return page;
1714 : : }
1715 : :
1716 : 67767 : static struct page *new_slab(struct kmem_cache *s, gfp_t flags, int node)
1717 : : {
1718 [ - + ]: 67767 : if (unlikely(flags & GFP_SLAB_BUG_MASK)) {
1719 : 0 : gfp_t invalid_mask = flags & GFP_SLAB_BUG_MASK;
1720 : 0 : flags &= ~GFP_SLAB_BUG_MASK;
1721 : 0 : pr_warn("Unexpected gfp: %#x (%pGg). Fixing up to gfp: %#x (%pGg). Fix your code!\n",
1722 : : invalid_mask, &invalid_mask, flags, &flags);
1723 : 0 : dump_stack();
1724 : : }
1725 : :
1726 : 67767 : return allocate_slab(s,
1727 : : flags & (GFP_RECLAIM_MASK | GFP_CONSTRAINT_MASK), node);
1728 : : }
1729 : :
1730 : 44830 : static void __free_slab(struct kmem_cache *s, struct page *page)
1731 : : {
1732 : 44830 : int order = compound_order(page);
1733 : 44830 : int pages = 1 << order;
1734 : :
1735 [ - + ]: 44830 : if (s->flags & SLAB_CONSISTENCY_CHECKS) {
1736 : 0 : void *p;
1737 : :
1738 : 0 : slab_pad_check(s, page);
1739 [ # # # # ]: 0 : for_each_object(p, s, page_address(page),
1740 : : page->objects)
1741 : 0 : check_object(s, page, p, SLUB_RED_INACTIVE);
1742 : : }
1743 : :
1744 : 44830 : __ClearPageSlabPfmemalloc(page);
1745 [ - + ]: 44830 : __ClearPageSlab(page);
1746 : :
1747 : 44830 : page->mapping = NULL;
1748 [ - + ]: 44830 : if (current->reclaim_state)
1749 : 0 : current->reclaim_state->reclaimed_slab += pages;
1750 [ + + ]: 44830 : uncharge_slab_page(page, order, s);
1751 : 44830 : __free_pages(page, order);
1752 : 44830 : }
1753 : :
1754 : 0 : static void rcu_free_slab(struct rcu_head *h)
1755 : : {
1756 : 0 : struct page *page = container_of(h, struct page, rcu_head);
1757 : :
1758 : 0 : __free_slab(page->slab_cache, page);
1759 : 0 : }
1760 : :
1761 : 44830 : static void free_slab(struct kmem_cache *s, struct page *page)
1762 : : {
1763 [ - + ]: 44830 : if (unlikely(s->flags & SLAB_TYPESAFE_BY_RCU)) {
1764 : 0 : call_rcu(&page->rcu_head, rcu_free_slab);
1765 : : } else
1766 : 44830 : __free_slab(s, page);
1767 : 44830 : }
1768 : :
1769 : 44830 : static void discard_slab(struct kmem_cache *s, struct page *page)
1770 : : {
1771 : 44830 : dec_slabs_node(s, page_to_nid(page), page->objects);
1772 : 44830 : free_slab(s, page);
1773 : 44830 : }
1774 : :
1775 : : /*
1776 : : * Management of partially allocated slabs.
1777 : : */
1778 : : static inline void
1779 : 3 : __add_partial(struct kmem_cache_node *n, struct page *page, int tail)
1780 : : {
1781 : 3 : n->nr_partial++;
1782 : 3 : if (tail == DEACTIVATE_TO_TAIL)
1783 : 0 : list_add_tail(&page->slab_list, &n->partial);
1784 : : else
1785 : 3 : list_add(&page->slab_list, &n->partial);
1786 : : }
1787 : :
1788 : 0 : static inline void add_partial(struct kmem_cache_node *n,
1789 : : struct page *page, int tail)
1790 : : {
1791 : 0 : lockdep_assert_held(&n->list_lock);
1792 : 0 : __add_partial(n, page, tail);
1793 : : }
1794 : :
1795 : 58035 : static inline void remove_partial(struct kmem_cache_node *n,
1796 : : struct page *page)
1797 : : {
1798 : 58035 : lockdep_assert_held(&n->list_lock);
1799 : 58035 : list_del(&page->slab_list);
1800 : 58035 : n->nr_partial--;
1801 : 6080 : }
1802 : :
1803 : : /*
1804 : : * Remove slab from the partial list, freeze it and
1805 : : * return the pointer to the freelist.
1806 : : *
1807 : : * Returns a list of objects or NULL if it fails.
1808 : : */
1809 : 51955 : static inline void *acquire_slab(struct kmem_cache *s,
1810 : : struct kmem_cache_node *n, struct page *page,
1811 : : int mode, int *objects)
1812 : : {
1813 : 51955 : void *freelist;
1814 : 51955 : unsigned long counters;
1815 : 51955 : struct page new;
1816 : :
1817 : 51955 : lockdep_assert_held(&n->list_lock);
1818 : :
1819 : : /*
1820 : : * Zap the freelist and set the frozen bit.
1821 : : * The old freelist is the list of objects for the
1822 : : * per cpu allocation list.
1823 : : */
1824 : 51955 : freelist = page->freelist;
1825 : 51955 : counters = page->counters;
1826 : 51955 : new.counters = counters;
1827 : 51955 : *objects = new.objects - new.inuse;
1828 [ + + ]: 51955 : if (mode) {
1829 : 36731 : new.inuse = page->objects;
1830 : 36731 : new.freelist = NULL;
1831 : : } else {
1832 : : new.freelist = freelist;
1833 : : }
1834 : :
1835 : 51955 : VM_BUG_ON(new.frozen);
1836 : 51955 : new.frozen = 1;
1837 : :
1838 [ + - ]: 51955 : if (!__cmpxchg_double_slab(s, page,
1839 : : freelist, counters,
1840 : : new.freelist, new.counters,
1841 : : "acquire_slab"))
1842 : : return NULL;
1843 : :
1844 [ - + ]: 51955 : remove_partial(n, page);
1845 [ - + ]: 51955 : WARN_ON(!freelist);
1846 : : return freelist;
1847 : : }
1848 : :
1849 : : static void put_cpu_partial(struct kmem_cache *s, struct page *page, int drain);
1850 : : static inline bool pfmemalloc_match(struct page *page, gfp_t gfpflags);
1851 : :
1852 : : /*
1853 : : * Try to allocate a partial slab from a specific node.
1854 : : */
1855 : : static void *get_partial_node(struct kmem_cache *s, struct kmem_cache_node *n,
1856 : : struct kmem_cache_cpu *c, gfp_t flags)
1857 : : {
1858 : : struct page *page, *page2;
1859 : : void *object = NULL;
1860 : : unsigned int available = 0;
1861 : : int objects;
1862 : :
1863 : : /*
1864 : : * Racy check. If we mistakenly see no partial slabs then we
1865 : : * just allocate an empty slab. If we mistakenly try to get a
1866 : : * partial slab and there is none available then get_partials()
1867 : : * will return NULL.
1868 : : */
1869 : : if (!n || !n->nr_partial)
1870 : : return NULL;
1871 : :
1872 : : spin_lock(&n->list_lock);
1873 : : list_for_each_entry_safe(page, page2, &n->partial, slab_list) {
1874 : : void *t;
1875 : :
1876 : : if (!pfmemalloc_match(page, flags))
1877 : : continue;
1878 : :
1879 : : t = acquire_slab(s, n, page, object == NULL, &objects);
1880 : : if (!t)
1881 : : break;
1882 : :
1883 : : available += objects;
1884 : : if (!object) {
1885 : : c->page = page;
1886 : : stat(s, ALLOC_FROM_PARTIAL);
1887 : : object = t;
1888 : : } else {
1889 : : put_cpu_partial(s, page, 0);
1890 : : stat(s, CPU_PARTIAL_NODE);
1891 : : }
1892 : : if (!kmem_cache_has_cpu_partial(s)
1893 : : || available > slub_cpu_partial(s) / 2)
1894 : : break;
1895 : :
1896 : : }
1897 : : spin_unlock(&n->list_lock);
1898 : : return object;
1899 : : }
1900 : :
1901 : : /*
1902 : : * Get a page from somewhere. Search in increasing NUMA distances.
1903 : : */
1904 : 67667 : static void *get_any_partial(struct kmem_cache *s, gfp_t flags,
1905 : : struct kmem_cache_cpu *c)
1906 : : {
1907 : : #ifdef CONFIG_NUMA
1908 : 67667 : struct zonelist *zonelist;
1909 : 67667 : struct zoneref *z;
1910 : 67667 : struct zone *zone;
1911 [ + - ]: 67667 : enum zone_type high_zoneidx = gfp_zone(flags);
1912 : 67667 : void *object;
1913 : 67667 : unsigned int cpuset_mems_cookie;
1914 : :
1915 : : /*
1916 : : * The defrag ratio allows a configuration of the tradeoffs between
1917 : : * inter node defragmentation and node local allocations. A lower
1918 : : * defrag_ratio increases the tendency to do local allocations
1919 : : * instead of attempting to obtain partial slabs from other nodes.
1920 : : *
1921 : : * If the defrag_ratio is set to 0 then kmalloc() always
1922 : : * returns node local objects. If the ratio is higher then kmalloc()
1923 : : * may return off node objects because partial slabs are obtained
1924 : : * from other nodes and filled up.
1925 : : *
1926 : : * If /sys/kernel/slab/xx/remote_node_defrag_ratio is set to 100
1927 : : * (which makes defrag_ratio = 1000) then every (well almost)
1928 : : * allocation will first attempt to defrag slab caches on other nodes.
1929 : : * This means scanning over all nodes to look for partial slabs which
1930 : : * may be expensive if we do it every time we are trying to find a slab
1931 : : * with available objects.
1932 : : */
1933 [ + - ]: 67667 : if (!s->remote_node_defrag_ratio ||
1934 [ + + ]: 67667 : get_cycles() % 1024 > s->remote_node_defrag_ratio)
1935 : : return NULL;
1936 : :
1937 : 66172 : do {
1938 : 66172 : cpuset_mems_cookie = read_mems_allowed_begin();
1939 [ - + ]: 66172 : zonelist = node_zonelist(mempolicy_slab_node(), flags);
1940 [ + + - + : 198516 : for_each_zone_zonelist(zone, z, zonelist, high_zoneidx) {
+ + ]
1941 : 132341 : struct kmem_cache_node *n;
1942 : :
1943 [ + - ]: 132341 : n = get_node(s, zone_to_nid(zone));
1944 : :
1945 [ + - + - ]: 132341 : if (n && cpuset_zone_allowed(zone, flags) &&
1946 [ - + ]: 132341 : n->nr_partial > s->min_partial) {
1947 : 0 : object = get_partial_node(s, n, c, flags);
1948 [ # # ]: 0 : if (object) {
1949 : : /*
1950 : : * Don't check read_mems_allowed_retry()
1951 : : * here - if mems_allowed was updated in
1952 : : * parallel, that was a harmless race
1953 : : * between allocation and the cpuset
1954 : : * update
1955 : : */
1956 : 0 : return object;
1957 : : }
1958 : : }
1959 : : }
1960 [ + - - - ]: 66172 : } while (read_mems_allowed_retry(cpuset_mems_cookie));
1961 : : #endif /* CONFIG_NUMA */
1962 : : return NULL;
1963 : : }
1964 : :
1965 : : /*
1966 : : * Get a partial page, lock it and return it.
1967 : : */
1968 : 104492 : static void *get_partial(struct kmem_cache *s, gfp_t flags, int node,
1969 : : struct kmem_cache_cpu *c)
1970 : : {
1971 : 104492 : void *object;
1972 : 104492 : int searchnode = node;
1973 : :
1974 [ + + ]: 104492 : if (node == NUMA_NO_NODE)
1975 : 104392 : searchnode = numa_mem_id();
1976 : :
1977 : 104492 : object = get_partial_node(s, get_node(s, searchnode), c, flags);
1978 [ + + ]: 104492 : if (object || node != NUMA_NO_NODE)
1979 : : return object;
1980 : :
1981 : 67667 : return get_any_partial(s, flags, c);
1982 : : }
1983 : :
1984 : : #ifdef CONFIG_PREEMPTION
1985 : : /*
1986 : : * Calculate the next globally unique transaction for disambiguiation
1987 : : * during cmpxchg. The transactions start with the cpu number and are then
1988 : : * incremented by CONFIG_NR_CPUS.
1989 : : */
1990 : : #define TID_STEP roundup_pow_of_two(CONFIG_NR_CPUS)
1991 : : #else
1992 : : /*
1993 : : * No preemption supported therefore also no need to check for
1994 : : * different cpus.
1995 : : */
1996 : : #define TID_STEP 1
1997 : : #endif
1998 : :
1999 : 2326065 : static inline unsigned long next_tid(unsigned long tid)
2000 : : {
2001 : 2326065 : return tid + TID_STEP;
2002 : : }
2003 : :
2004 : : #ifdef SLUB_DEBUG_CMPXCHG
2005 : : static inline unsigned int tid_to_cpu(unsigned long tid)
2006 : : {
2007 : : return tid % TID_STEP;
2008 : : }
2009 : :
2010 : : static inline unsigned long tid_to_event(unsigned long tid)
2011 : : {
2012 : : return tid / TID_STEP;
2013 : : }
2014 : : #endif
2015 : :
2016 : : static inline unsigned int init_tid(int cpu)
2017 : : {
2018 : : return cpu;
2019 : : }
2020 : :
2021 : : static inline void note_cmpxchg_failure(const char *n,
2022 : : const struct kmem_cache *s, unsigned long tid)
2023 : : {
2024 : : #ifdef SLUB_DEBUG_CMPXCHG
2025 : : unsigned long actual_tid = __this_cpu_read(s->cpu_slab->tid);
2026 : :
2027 : : pr_info("%s %s: cmpxchg redo ", n, s->name);
2028 : :
2029 : : #ifdef CONFIG_PREEMPTION
2030 : : if (tid_to_cpu(tid) != tid_to_cpu(actual_tid))
2031 : : pr_warn("due to cpu change %d -> %d\n",
2032 : : tid_to_cpu(tid), tid_to_cpu(actual_tid));
2033 : : else
2034 : : #endif
2035 : : if (tid_to_event(tid) != tid_to_event(actual_tid))
2036 : : pr_warn("due to cpu running other code. Event %ld->%ld\n",
2037 : : tid_to_event(tid), tid_to_event(actual_tid));
2038 : : else
2039 : : pr_warn("for unknown reason: actual=%lx was=%lx target=%lx\n",
2040 : : actual_tid, tid, next_tid(tid));
2041 : : #endif
2042 : : stat(s, CMPXCHG_DOUBLE_CPU_FAIL);
2043 : : }
2044 : :
2045 : : static void init_kmem_cache_cpus(struct kmem_cache *s)
2046 : : {
2047 : : int cpu;
2048 : :
2049 : : for_each_possible_cpu(cpu)
2050 : : per_cpu_ptr(s->cpu_slab, cpu)->tid = init_tid(cpu);
2051 : : }
2052 : :
2053 : : /*
2054 : : * Remove the cpu slab
2055 : : */
2056 : : static void deactivate_slab(struct kmem_cache *s, struct page *page,
2057 : : void *freelist, struct kmem_cache_cpu *c)
2058 : : {
2059 : : enum slab_modes { M_NONE, M_PARTIAL, M_FULL, M_FREE };
2060 : : struct kmem_cache_node *n = get_node(s, page_to_nid(page));
2061 : : int lock = 0;
2062 : : enum slab_modes l = M_NONE, m = M_NONE;
2063 : : void *nextfree;
2064 : : int tail = DEACTIVATE_TO_HEAD;
2065 : : struct page new;
2066 : : struct page old;
2067 : :
2068 : : if (page->freelist) {
2069 : : stat(s, DEACTIVATE_REMOTE_FREES);
2070 : : tail = DEACTIVATE_TO_TAIL;
2071 : : }
2072 : :
2073 : : /*
2074 : : * Stage one: Free all available per cpu objects back
2075 : : * to the page freelist while it is still frozen. Leave the
2076 : : * last one.
2077 : : *
2078 : : * There is no need to take the list->lock because the page
2079 : : * is still frozen.
2080 : : */
2081 : : while (freelist && (nextfree = get_freepointer(s, freelist))) {
2082 : : void *prior;
2083 : : unsigned long counters;
2084 : :
2085 : : do {
2086 : : prior = page->freelist;
2087 : : counters = page->counters;
2088 : : set_freepointer(s, freelist, prior);
2089 : : new.counters = counters;
2090 : : new.inuse--;
2091 : : VM_BUG_ON(!new.frozen);
2092 : :
2093 : : } while (!__cmpxchg_double_slab(s, page,
2094 : : prior, counters,
2095 : : freelist, new.counters,
2096 : : "drain percpu freelist"));
2097 : :
2098 : : freelist = nextfree;
2099 : : }
2100 : :
2101 : : /*
2102 : : * Stage two: Ensure that the page is unfrozen while the
2103 : : * list presence reflects the actual number of objects
2104 : : * during unfreeze.
2105 : : *
2106 : : * We setup the list membership and then perform a cmpxchg
2107 : : * with the count. If there is a mismatch then the page
2108 : : * is not unfrozen but the page is on the wrong list.
2109 : : *
2110 : : * Then we restart the process which may have to remove
2111 : : * the page from the list that we just put it on again
2112 : : * because the number of objects in the slab may have
2113 : : * changed.
2114 : : */
2115 : : redo:
2116 : :
2117 : : old.freelist = page->freelist;
2118 : : old.counters = page->counters;
2119 : : VM_BUG_ON(!old.frozen);
2120 : :
2121 : : /* Determine target state of the slab */
2122 : : new.counters = old.counters;
2123 : : if (freelist) {
2124 : : new.inuse--;
2125 : : set_freepointer(s, freelist, old.freelist);
2126 : : new.freelist = freelist;
2127 : : } else
2128 : : new.freelist = old.freelist;
2129 : :
2130 : : new.frozen = 0;
2131 : :
2132 : : if (!new.inuse && n->nr_partial >= s->min_partial)
2133 : : m = M_FREE;
2134 : : else if (new.freelist) {
2135 : : m = M_PARTIAL;
2136 : : if (!lock) {
2137 : : lock = 1;
2138 : : /*
2139 : : * Taking the spinlock removes the possibility
2140 : : * that acquire_slab() will see a slab page that
2141 : : * is frozen
2142 : : */
2143 : : spin_lock(&n->list_lock);
2144 : : }
2145 : : } else {
2146 : : m = M_FULL;
2147 : : if (kmem_cache_debug(s) && !lock) {
2148 : : lock = 1;
2149 : : /*
2150 : : * This also ensures that the scanning of full
2151 : : * slabs from diagnostic functions will not see
2152 : : * any frozen slabs.
2153 : : */
2154 : : spin_lock(&n->list_lock);
2155 : : }
2156 : : }
2157 : :
2158 : : if (l != m) {
2159 : : if (l == M_PARTIAL)
2160 : : remove_partial(n, page);
2161 : : else if (l == M_FULL)
2162 : : remove_full(s, n, page);
2163 : :
2164 : : if (m == M_PARTIAL)
2165 : : add_partial(n, page, tail);
2166 : : else if (m == M_FULL)
2167 : : add_full(s, n, page);
2168 : : }
2169 : :
2170 : : l = m;
2171 : : if (!__cmpxchg_double_slab(s, page,
2172 : : old.freelist, old.counters,
2173 : : new.freelist, new.counters,
2174 : : "unfreezing slab"))
2175 : : goto redo;
2176 : :
2177 : : if (lock)
2178 : : spin_unlock(&n->list_lock);
2179 : :
2180 : : if (m == M_PARTIAL)
2181 : : stat(s, tail);
2182 : : else if (m == M_FULL)
2183 : : stat(s, DEACTIVATE_FULL);
2184 : : else if (m == M_FREE) {
2185 : : stat(s, DEACTIVATE_EMPTY);
2186 : : discard_slab(s, page);
2187 : : stat(s, FREE_SLAB);
2188 : : }
2189 : :
2190 : : c->page = NULL;
2191 : : c->freelist = NULL;
2192 : : }
2193 : :
2194 : : /*
2195 : : * Unfreeze all the cpu partial slabs.
2196 : : *
2197 : : * This function must be called with interrupts disabled
2198 : : * for the cpu using c (or some other guarantee must be there
2199 : : * to guarantee no concurrent accesses).
2200 : : */
2201 : : static void unfreeze_partials(struct kmem_cache *s,
2202 : : struct kmem_cache_cpu *c)
2203 : : {
2204 : : #ifdef CONFIG_SLUB_CPU_PARTIAL
2205 : : struct kmem_cache_node *n = NULL, *n2 = NULL;
2206 : : struct page *page, *discard_page = NULL;
2207 : :
2208 : : while ((page = c->partial)) {
2209 : : struct page new;
2210 : : struct page old;
2211 : :
2212 : : c->partial = page->next;
2213 : :
2214 : : n2 = get_node(s, page_to_nid(page));
2215 : : if (n != n2) {
2216 : : if (n)
2217 : : spin_unlock(&n->list_lock);
2218 : :
2219 : : n = n2;
2220 : : spin_lock(&n->list_lock);
2221 : : }
2222 : :
2223 : : do {
2224 : :
2225 : : old.freelist = page->freelist;
2226 : : old.counters = page->counters;
2227 : : VM_BUG_ON(!old.frozen);
2228 : :
2229 : : new.counters = old.counters;
2230 : : new.freelist = old.freelist;
2231 : :
2232 : : new.frozen = 0;
2233 : :
2234 : : } while (!__cmpxchg_double_slab(s, page,
2235 : : old.freelist, old.counters,
2236 : : new.freelist, new.counters,
2237 : : "unfreezing slab"));
2238 : :
2239 : : if (unlikely(!new.inuse && n->nr_partial >= s->min_partial)) {
2240 : : page->next = discard_page;
2241 : : discard_page = page;
2242 : : } else {
2243 : : add_partial(n, page, DEACTIVATE_TO_TAIL);
2244 : : stat(s, FREE_ADD_PARTIAL);
2245 : : }
2246 : : }
2247 : :
2248 : : if (n)
2249 : : spin_unlock(&n->list_lock);
2250 : :
2251 : : while (discard_page) {
2252 : : page = discard_page;
2253 : : discard_page = discard_page->next;
2254 : :
2255 : : stat(s, DEACTIVATE_EMPTY);
2256 : : discard_slab(s, page);
2257 : : stat(s, FREE_SLAB);
2258 : : }
2259 : : #endif /* CONFIG_SLUB_CPU_PARTIAL */
2260 : : }
2261 : :
2262 : : /*
2263 : : * Put a page that was just frozen (in __slab_free|get_partial_node) into a
2264 : : * partial page slot if available.
2265 : : *
2266 : : * If we did not find a slot then simply move all the partials to the
2267 : : * per node partial list.
2268 : : */
2269 : 164500 : static void put_cpu_partial(struct kmem_cache *s, struct page *page, int drain)
2270 : : {
2271 : : #ifdef CONFIG_SLUB_CPU_PARTIAL
2272 : 164500 : struct page *oldpage;
2273 : 164500 : int pages;
2274 : 164500 : int pobjects;
2275 : :
2276 : 164500 : preempt_disable();
2277 : 164500 : do {
2278 : 164500 : pages = 0;
2279 : 164500 : pobjects = 0;
2280 : 164500 : oldpage = this_cpu_read(s->cpu_slab->partial);
2281 : :
2282 [ + + ]: 164500 : if (oldpage) {
2283 : 146130 : pobjects = oldpage->pobjects;
2284 : 146130 : pages = oldpage->pages;
2285 [ + + + + ]: 146130 : if (drain && pobjects > s->cpu_partial) {
2286 : 17555 : unsigned long flags;
2287 : : /*
2288 : : * partial array is full. Move the existing
2289 : : * set to the per node partial list.
2290 : : */
2291 : 17555 : local_irq_save(flags);
2292 : 17555 : unfreeze_partials(s, this_cpu_ptr(s->cpu_slab));
2293 : 17555 : local_irq_restore(flags);
2294 : 17555 : oldpage = NULL;
2295 : 17555 : pobjects = 0;
2296 : 17555 : pages = 0;
2297 : 17555 : stat(s, CPU_PARTIAL_DRAIN);
2298 : : }
2299 : : }
2300 : :
2301 : 164500 : pages++;
2302 : 164500 : pobjects += page->objects - page->inuse;
2303 : :
2304 : 164500 : page->pages = pages;
2305 : 164500 : page->pobjects = pobjects;
2306 : 164500 : page->next = oldpage;
2307 : :
2308 : 164500 : } while (this_cpu_cmpxchg(s->cpu_slab->partial, oldpage, page)
2309 [ - + ]: 164500 : != oldpage);
2310 [ - + ]: 164500 : if (unlikely(!s->cpu_partial)) {
2311 : 0 : unsigned long flags;
2312 : :
2313 : 0 : local_irq_save(flags);
2314 : 0 : unfreeze_partials(s, this_cpu_ptr(s->cpu_slab));
2315 : 0 : local_irq_restore(flags);
2316 : : }
2317 : 164500 : preempt_enable();
2318 : : #endif /* CONFIG_SLUB_CPU_PARTIAL */
2319 : 164500 : }
2320 : :
2321 : 18 : static inline void flush_slab(struct kmem_cache *s, struct kmem_cache_cpu *c)
2322 : : {
2323 : 18 : stat(s, CPUSLAB_FLUSH);
2324 : 18 : deactivate_slab(s, c->page, c->freelist, c);
2325 : :
2326 : 18 : c->tid = next_tid(c->tid);
2327 : 18 : }
2328 : :
2329 : : /*
2330 : : * Flush cpu slab.
2331 : : *
2332 : : * Called from IPI handler with interrupts disabled.
2333 : : */
2334 : 18 : static inline void __flush_cpu_slab(struct kmem_cache *s, int cpu)
2335 : : {
2336 : 18 : struct kmem_cache_cpu *c = per_cpu_ptr(s->cpu_slab, cpu);
2337 : :
2338 [ + - ]: 18 : if (c->page)
2339 : 18 : flush_slab(s, c);
2340 : :
2341 : 18 : unfreeze_partials(s, c);
2342 : 18 : }
2343 : :
2344 : 12 : static void flush_cpu_slab(void *d)
2345 : : {
2346 : 12 : struct kmem_cache *s = d;
2347 : :
2348 : 12 : __flush_cpu_slab(s, smp_processor_id());
2349 : 12 : }
2350 : :
2351 : 12 : static bool has_cpu_slab(int cpu, void *info)
2352 : : {
2353 : 12 : struct kmem_cache *s = info;
2354 : 12 : struct kmem_cache_cpu *c = per_cpu_ptr(s->cpu_slab, cpu);
2355 : :
2356 [ - + - - ]: 12 : return c->page || slub_percpu_partial(c);
2357 : : }
2358 : :
2359 : 12 : static void flush_all(struct kmem_cache *s)
2360 : : {
2361 : 12 : on_each_cpu_cond(has_cpu_slab, flush_cpu_slab, s, 1);
2362 : : }
2363 : :
2364 : : /*
2365 : : * Use the cpu notifier to insure that the cpu slabs are flushed when
2366 : : * necessary.
2367 : : */
2368 : 0 : static int slub_cpu_dead(unsigned int cpu)
2369 : : {
2370 : 0 : struct kmem_cache *s;
2371 : 0 : unsigned long flags;
2372 : :
2373 : 0 : mutex_lock(&slab_mutex);
2374 [ # # ]: 0 : list_for_each_entry(s, &slab_caches, list) {
2375 : 0 : local_irq_save(flags);
2376 : 0 : __flush_cpu_slab(s, cpu);
2377 : 0 : local_irq_restore(flags);
2378 : : }
2379 : 0 : mutex_unlock(&slab_mutex);
2380 : 0 : return 0;
2381 : : }
2382 : :
2383 : : /*
2384 : : * Check if the objects in a per cpu structure fit numa
2385 : : * locality expectations.
2386 : : */
2387 : 2311844 : static inline int node_match(struct page *page, int node)
2388 : : {
2389 : : #ifdef CONFIG_NUMA
2390 [ - + - - : 128734 : if (node != NUMA_NO_NODE && page_to_nid(page) != node)
+ + - + +
+ - + + +
- + - + ]
2391 : 0 : return 0;
2392 : : #endif
2393 : : return 1;
2394 : : }
2395 : :
2396 : : #ifdef CONFIG_SLUB_DEBUG
2397 : 0 : static int count_free(struct page *page)
2398 : : {
2399 : 0 : return page->objects - page->inuse;
2400 : : }
2401 : :
2402 : 0 : static inline unsigned long node_nr_objs(struct kmem_cache_node *n)
2403 : : {
2404 : 0 : return atomic_long_read(&n->total_objects);
2405 : : }
2406 : : #endif /* CONFIG_SLUB_DEBUG */
2407 : :
2408 : : #if defined(CONFIG_SLUB_DEBUG) || defined(CONFIG_SYSFS)
2409 : 0 : static unsigned long count_partial(struct kmem_cache_node *n,
2410 : : int (*get_count)(struct page *))
2411 : : {
2412 : 0 : unsigned long flags;
2413 : 0 : unsigned long x = 0;
2414 : 0 : struct page *page;
2415 : :
2416 : 0 : spin_lock_irqsave(&n->list_lock, flags);
2417 [ # # ]: 0 : list_for_each_entry(page, &n->partial, slab_list)
2418 : 0 : x += get_count(page);
2419 : 0 : spin_unlock_irqrestore(&n->list_lock, flags);
2420 : 0 : return x;
2421 : : }
2422 : : #endif /* CONFIG_SLUB_DEBUG || CONFIG_SYSFS */
2423 : :
2424 : : static noinline void
2425 : 0 : slab_out_of_memory(struct kmem_cache *s, gfp_t gfpflags, int nid)
2426 : : {
2427 : : #ifdef CONFIG_SLUB_DEBUG
2428 : 0 : static DEFINE_RATELIMIT_STATE(slub_oom_rs, DEFAULT_RATELIMIT_INTERVAL,
2429 : : DEFAULT_RATELIMIT_BURST);
2430 : 0 : int node;
2431 : 0 : struct kmem_cache_node *n;
2432 : :
2433 [ # # # # ]: 0 : if ((gfpflags & __GFP_NOWARN) || !__ratelimit(&slub_oom_rs))
2434 : 0 : return;
2435 : :
2436 : 0 : pr_warn("SLUB: Unable to allocate memory on node %d, gfp=%#x(%pGg)\n",
2437 : : nid, gfpflags, &gfpflags);
2438 : 0 : pr_warn(" cache: %s, object size: %u, buffer size: %u, default order: %u, min order: %u\n",
2439 : : s->name, s->object_size, s->size, oo_order(s->oo),
2440 : : oo_order(s->min));
2441 : :
2442 [ # # ]: 0 : if (oo_order(s->min) > get_order(s->object_size))
2443 : 0 : pr_warn(" %s debugging increased min order, use slub_debug=O to disable.\n",
2444 : : s->name);
2445 : :
2446 [ # # # # ]: 0 : for_each_kmem_cache_node(s, node, n) {
2447 : 0 : unsigned long nr_slabs;
2448 : 0 : unsigned long nr_objs;
2449 : 0 : unsigned long nr_free;
2450 : :
2451 : 0 : nr_free = count_partial(n, count_free);
2452 : 0 : nr_slabs = node_nr_slabs(n);
2453 : 0 : nr_objs = node_nr_objs(n);
2454 : :
2455 : 0 : pr_warn(" node %d: slabs: %ld, objs: %ld, free: %ld\n",
2456 : : node, nr_slabs, nr_objs, nr_free);
2457 : : }
2458 : : #endif
2459 : : }
2460 : :
2461 : 104490 : static inline void *new_slab_objects(struct kmem_cache *s, gfp_t flags,
2462 : : int node, struct kmem_cache_cpu **pc)
2463 : : {
2464 : 104490 : void *freelist;
2465 : 104490 : struct kmem_cache_cpu *c = *pc;
2466 : 104490 : struct page *page;
2467 : :
2468 [ + + + - : 208980 : WARN_ON_ONCE(s->ctor && (flags & __GFP_ZERO));
- + ]
2469 : :
2470 : 104490 : freelist = get_partial(s, flags, node, c);
2471 : :
2472 [ + + ]: 104490 : if (freelist)
2473 : : return freelist;
2474 : :
2475 : 67761 : page = new_slab(s, flags, node);
2476 [ + - ]: 67761 : if (page) {
2477 : 67761 : c = raw_cpu_ptr(s->cpu_slab);
2478 [ - + ]: 67761 : if (c->page)
2479 : 0 : flush_slab(s, c);
2480 : :
2481 : : /*
2482 : : * No other reference to the page yet so we can
2483 : : * muck around with it freely without cmpxchg
2484 : : */
2485 : 67761 : freelist = page->freelist;
2486 : 67761 : page->freelist = NULL;
2487 : :
2488 : 67761 : stat(s, ALLOC_SLAB);
2489 : 67761 : c->page = page;
2490 : 67761 : *pc = c;
2491 : : }
2492 : :
2493 : : return freelist;
2494 : : }
2495 : :
2496 : 390224 : static inline bool pfmemalloc_match(struct page *page, gfp_t gfpflags)
2497 : : {
2498 [ - + ]: 780448 : if (unlikely(PageSlabPfmemalloc(page)))
2499 : 0 : return gfp_pfmemalloc_allowed(gfpflags);
2500 : :
2501 : : return true;
2502 : : }
2503 : :
2504 : : /*
2505 : : * Check the page->freelist of a page and either transfer the freelist to the
2506 : : * per cpu freelist or deactivate the page.
2507 : : *
2508 : : * The page is still frozen if the return value is not NULL.
2509 : : *
2510 : : * If this function returns NULL then the page has been unfrozen.
2511 : : *
2512 : : * This function must be called with interrupt disabled.
2513 : : */
2514 : 233783 : static inline void *get_freelist(struct kmem_cache *s, struct page *page)
2515 : : {
2516 : 233783 : struct page new;
2517 : 233783 : unsigned long counters;
2518 : 233783 : void *freelist;
2519 : :
2520 : 233783 : do {
2521 : 233783 : freelist = page->freelist;
2522 : 233783 : counters = page->counters;
2523 : :
2524 : 233783 : new.counters = counters;
2525 : 233783 : VM_BUG_ON(!new.frozen);
2526 : :
2527 : 233783 : new.inuse = page->objects;
2528 : 233783 : new.frozen = freelist != NULL;
2529 : :
2530 : 233783 : } while (!__cmpxchg_double_slab(s, page,
2531 : : freelist, counters,
2532 : : NULL, new.counters,
2533 [ - + ]: 233783 : "get_freelist"));
2534 : :
2535 : 233783 : return freelist;
2536 : : }
2537 : :
2538 : : /*
2539 : : * Slow path. The lockless freelist is empty or we need to perform
2540 : : * debugging duties.
2541 : : *
2542 : : * Processing is still very fast if new objects have been freed to the
2543 : : * regular freelist. In that case we simply take over the regular freelist
2544 : : * as the lockless freelist and zap the regular freelist.
2545 : : *
2546 : : * If that is not working then we fall back to the partial lists. We take the
2547 : : * first element of the freelist as the object to allocate now and move the
2548 : : * rest of the freelist to the lockless freelist.
2549 : : *
2550 : : * And if we were unable to get a new slab from the partial slab lists then
2551 : : * we need to allocate a new slab. This is the slowest path since it involves
2552 : : * a call to the page allocator and the setup of a new slab.
2553 : : *
2554 : : * Version of __slab_alloc to use when we know that interrupts are
2555 : : * already disabled (which is the case for bulk allocation).
2556 : : */
2557 : 169333 : static void *___slab_alloc(struct kmem_cache *s, gfp_t gfpflags, int node,
2558 : : unsigned long addr, struct kmem_cache_cpu *c)
2559 : : {
2560 : 169333 : void *freelist;
2561 : 169333 : struct page *page;
2562 : :
2563 : 169333 : page = c->page;
2564 [ + + ]: 169333 : if (!page) {
2565 : : /*
2566 : : * if the node is not online or has no normal memory, just
2567 : : * ignore the node constraint
2568 : : */
2569 [ + + - + ]: 405 : if (unlikely(node != NUMA_NO_NODE &&
2570 : : !node_state(node, N_NORMAL_MEMORY)))
2571 : 0 : node = NUMA_NO_NODE;
2572 : 393 : goto new_slab;
2573 : : }
2574 : 168940 : redo:
2575 : :
2576 [ + + - + ]: 467566 : if (unlikely(!node_match(page, node))) {
2577 : : /*
2578 : : * same as above but node_match() being false already
2579 : : * implies node != NUMA_NO_NODE
2580 : : */
2581 [ # # # # ]: 0 : if (!node_state(node, N_NORMAL_MEMORY)) {
2582 : 0 : node = NUMA_NO_NODE;
2583 : 0 : goto redo;
2584 : : } else {
2585 : 0 : stat(s, ALLOC_NODE_MISMATCH);
2586 : 0 : deactivate_slab(s, page, c->freelist, c);
2587 : 0 : goto new_slab;
2588 : : }
2589 : : }
2590 : :
2591 : : /*
2592 : : * By rights, we should be searching for a slab page that was
2593 : : * PFMEMALLOC but right now, we are losing the pfmemalloc
2594 : : * information when the page leaves the per-cpu allocator
2595 : : */
2596 [ - + ]: 233783 : if (unlikely(!pfmemalloc_match(page, gfpflags))) {
2597 : 0 : deactivate_slab(s, page, c->freelist, c);
2598 : 0 : goto new_slab;
2599 : : }
2600 : :
2601 : : /* must check again c->freelist in case of cpu migration or IRQ */
2602 : 233783 : freelist = c->freelist;
2603 [ - + ]: 233783 : if (freelist)
2604 : 0 : goto load_freelist;
2605 : :
2606 : 233783 : freelist = get_freelist(s, page);
2607 : :
2608 [ + + ]: 233783 : if (!freelist) {
2609 : 168940 : c->page = NULL;
2610 : 168940 : stat(s, DEACTIVATE_BYPASS);
2611 : 168940 : goto new_slab;
2612 : : }
2613 : :
2614 : : stat(s, ALLOC_REFILL);
2615 : :
2616 : 169333 : load_freelist:
2617 : : /*
2618 : : * freelist is pointing to the list of objects to be used.
2619 : : * page is pointing to the page from which the objects are obtained.
2620 : : * That page must be frozen for per cpu allocations to work.
2621 : : */
2622 : 169333 : VM_BUG_ON(!c->page->frozen);
2623 : 169333 : c->freelist = get_freepointer(s, freelist);
2624 : 169333 : c->tid = next_tid(c->tid);
2625 : 169333 : return freelist;
2626 : :
2627 : : new_slab:
2628 : :
2629 [ + + ]: 169333 : if (slub_percpu_partial(c)) {
2630 : 64843 : page = c->page = slub_percpu_partial(c);
2631 : 64843 : slub_set_percpu_partial(c, page);
2632 : 64843 : stat(s, CPU_PARTIAL_ALLOC);
2633 : 64843 : goto redo;
2634 : : }
2635 : :
2636 : 104490 : freelist = new_slab_objects(s, gfpflags, node, &c);
2637 : :
2638 [ - + ]: 104490 : if (unlikely(!freelist)) {
2639 : 0 : slab_out_of_memory(s, gfpflags, node);
2640 : 0 : return NULL;
2641 : : }
2642 : :
2643 : 104490 : page = c->page;
2644 [ + - + - ]: 104490 : if (likely(!kmem_cache_debug(s) && pfmemalloc_match(page, gfpflags)))
2645 : 104490 : goto load_freelist;
2646 : :
2647 : : /* Only entered in the debug case */
2648 [ # # # # ]: 0 : if (kmem_cache_debug(s) &&
2649 : 0 : !alloc_debug_processing(s, page, freelist, addr))
2650 : 0 : goto new_slab; /* Slab failed checks. Next slab needed */
2651 : :
2652 : 0 : deactivate_slab(s, page, get_freepointer(s, freelist), c);
2653 : 0 : return freelist;
2654 : : }
2655 : :
2656 : : /*
2657 : : * Another one that disabled interrupt and compensates for possible
2658 : : * cpu changes by refetching the per cpu area pointer.
2659 : : */
2660 : 169333 : static void *__slab_alloc(struct kmem_cache *s, gfp_t gfpflags, int node,
2661 : : unsigned long addr, struct kmem_cache_cpu *c)
2662 : : {
2663 : 169333 : void *p;
2664 : 169333 : unsigned long flags;
2665 : :
2666 : 166045 : local_irq_save(flags);
2667 : : #ifdef CONFIG_PREEMPTION
2668 : : /*
2669 : : * We may have been preempted and rescheduled on a different
2670 : : * cpu before disabling interrupts. Need to reload cpu area
2671 : : * pointer.
2672 : : */
2673 : : c = this_cpu_ptr(s->cpu_slab);
2674 : : #endif
2675 : :
2676 : 169333 : p = ___slab_alloc(s, gfpflags, node, addr, c);
2677 : 169333 : local_irq_restore(flags);
2678 : 169333 : return p;
2679 : : }
2680 : :
2681 : : /*
2682 : : * If the object has been wiped upon free, make sure it's fully initialized by
2683 : : * zeroing out freelist pointer.
2684 : : */
2685 : 2247390 : static __always_inline void maybe_wipe_obj_freeptr(struct kmem_cache *s,
2686 : : void *obj)
2687 : : {
2688 [ - + - - : 2247390 : if (unlikely(slab_want_init_on_free(s)) && obj)
- + - - -
+ - - - +
- - - - -
- - - - -
- + - - -
+ - - - +
- - - + -
- ]
2689 : 0 : memset((void *)((char *)obj + s->offset), 0, sizeof(void *));
2690 : : }
2691 : :
2692 : : /*
2693 : : * Inlined fastpath so that allocation functions (kmalloc, kmem_cache_alloc)
2694 : : * have the fastpath folded into their functions. So no function call
2695 : : * overhead for requests that can be satisfied on the fastpath.
2696 : : *
2697 : : * The fastpath works by first checking if the lockless freelist can be used.
2698 : : * If not then __slab_alloc is called for slow processing.
2699 : : *
2700 : : * Otherwise we can simply pick the next object from the lockless free list.
2701 : : */
2702 : 2247390 : static __always_inline void *slab_alloc_node(struct kmem_cache *s,
2703 : : gfp_t gfpflags, int node, unsigned long addr)
2704 : : {
2705 : 2247390 : void *object;
2706 : 2247390 : struct kmem_cache_cpu *c;
2707 : 2247390 : struct page *page;
2708 : 2247390 : unsigned long tid;
2709 : :
2710 : 2247390 : s = slab_pre_alloc_hook(s, gfpflags);
2711 [ + - + - : 2247390 : if (!s)
+ - + - +
- + - + -
+ - ]
2712 : : return NULL;
2713 : 2247390 : redo:
2714 : : /*
2715 : : * Must read kmem_cache cpu data via this cpu ptr. Preemption is
2716 : : * enabled. We may switch back and forth between cpus while
2717 : : * reading from one cpu area. That does not matter as long
2718 : : * as we end up on the original cpu again when doing the cmpxchg.
2719 : : *
2720 : : * We should guarantee that tid and kmem_cache are retrieved on
2721 : : * the same cpu. It could be different if CONFIG_PREEMPTION so we need
2722 : : * to check if it is matched or not.
2723 : : */
2724 : 2247390 : do {
2725 : 2247390 : tid = this_cpu_read(s->cpu_slab->tid);
2726 : 2247390 : c = raw_cpu_ptr(s->cpu_slab);
2727 : 2247390 : } while (IS_ENABLED(CONFIG_PREEMPTION) &&
2728 : : unlikely(tid != READ_ONCE(c->tid)));
2729 : :
2730 : : /*
2731 : : * Irqless object alloc/free algorithm used here depends on sequence
2732 : : * of fetching cpu_slab's data. tid should be fetched before anything
2733 : : * on c to guarantee that object and page associated with previous tid
2734 : : * won't be used with current tid. If we fetch tid first, object and
2735 : : * page could be one associated with next tid and our alloc/free
2736 : : * request will be failed. In this case, we will retry. So, no problem.
2737 : : */
2738 : 2247390 : barrier();
2739 : :
2740 : : /*
2741 : : * The transaction ids are globally unique per cpu and per operation on
2742 : : * a per cpu queue. Thus they can be guarantee that the cmpxchg_double
2743 : : * occurs on the right processor and that there was no operation on the
2744 : : * linked list in between.
2745 : : */
2746 : :
2747 : 2247390 : object = c->freelist;
2748 : 2247390 : page = c->page;
2749 [ + + - + : 2376036 : if (unlikely(!object || !node_match(page, node))) {
+ + + + -
+ + + + +
- + + + -
+ + + +
+ ]
2750 : 169329 : object = __slab_alloc(s, gfpflags, node, addr, c);
2751 : 169329 : stat(s, ALLOC_SLOWPATH);
2752 : : } else {
2753 : 2078061 : void *next_object = get_freepointer_safe(s, object);
2754 : :
2755 : : /*
2756 : : * The cmpxchg will only match if there was no additional
2757 : : * operation and if we are on the right processor.
2758 : : *
2759 : : * The cmpxchg does the following atomically (without lock
2760 : : * semantics!)
2761 : : * 1. Relocate first pointer to the current per cpu area.
2762 : : * 2. Verify that tid and freelist have not been changed
2763 : : * 3. If they were not changed replace tid and freelist
2764 : : *
2765 : : * Since this is without lock semantics the protection is only
2766 : : * against code executing on this cpu *not* from access by
2767 : : * other cpus.
2768 : : */
2769 [ - + - + : 2078061 : if (unlikely(!this_cpu_cmpxchg_double(
- + - + -
+ - + - +
- + ]
2770 : : s->cpu_slab->freelist, s->cpu_slab->tid,
2771 : : object, tid,
2772 : : next_object, next_tid(tid)))) {
2773 : :
2774 : 0 : note_cmpxchg_failure("slab_alloc", s, tid);
2775 : 0 : goto redo;
2776 : : }
2777 : 301075 : prefetch_freepointer(s, next_object);
2778 : 1776986 : stat(s, ALLOC_FASTPATH);
2779 : : }
2780 : :
2781 [ + - + - : 2247390 : maybe_wipe_obj_freeptr(s, object);
+ - + - +
- + - + -
+ - ]
2782 : :
2783 [ + + + - : 2247390 : if (unlikely(slab_want_init_on_alloc(gfpflags, s)) && object)
- + - - +
+ + - + +
+ - + + +
- + + + -
+ + + - +
+ + - ]
2784 : 1122160 : memset(object, 0, s->object_size);
2785 : :
2786 : 2247390 : slab_post_alloc_hook(s, gfpflags, 1, &object);
2787 : :
2788 : 2247390 : return object;
2789 : : }
2790 : :
2791 : 2110186 : static __always_inline void *slab_alloc(struct kmem_cache *s,
2792 : : gfp_t gfpflags, unsigned long addr)
2793 : : {
2794 : 2110186 : return slab_alloc_node(s, gfpflags, NUMA_NO_NODE, addr);
2795 : : }
2796 : :
2797 : 1875019 : void *kmem_cache_alloc(struct kmem_cache *s, gfp_t gfpflags)
2798 : : {
2799 : 1875019 : void *ret = slab_alloc(s, gfpflags, _RET_IP_);
2800 : :
2801 : 1875019 : trace_kmem_cache_alloc(_RET_IP_, ret, s->object_size,
2802 : 1875019 : s->size, gfpflags);
2803 : :
2804 : 1875019 : return ret;
2805 : : }
2806 : : EXPORT_SYMBOL(kmem_cache_alloc);
2807 : :
2808 : : #ifdef CONFIG_TRACING
2809 : 70246 : void *kmem_cache_alloc_trace(struct kmem_cache *s, gfp_t gfpflags, size_t size)
2810 : : {
2811 : 70246 : void *ret = slab_alloc(s, gfpflags, _RET_IP_);
2812 : 70246 : trace_kmalloc(_RET_IP_, ret, size, s->size, gfpflags);
2813 : 70246 : ret = kasan_kmalloc(s, ret, size, gfpflags);
2814 : 70246 : return ret;
2815 : : }
2816 : : EXPORT_SYMBOL(kmem_cache_alloc_trace);
2817 : : #endif
2818 : :
2819 : : #ifdef CONFIG_NUMA
2820 : 48741 : void *kmem_cache_alloc_node(struct kmem_cache *s, gfp_t gfpflags, int node)
2821 : : {
2822 : 48741 : void *ret = slab_alloc_node(s, gfpflags, node, _RET_IP_);
2823 : :
2824 : 48741 : trace_kmem_cache_alloc_node(_RET_IP_, ret,
2825 : 48741 : s->object_size, s->size, gfpflags, node);
2826 : :
2827 : 48741 : return ret;
2828 : : }
2829 : : EXPORT_SYMBOL(kmem_cache_alloc_node);
2830 : :
2831 : : #ifdef CONFIG_TRACING
2832 : 37113 : void *kmem_cache_alloc_node_trace(struct kmem_cache *s,
2833 : : gfp_t gfpflags,
2834 : : int node, size_t size)
2835 : : {
2836 : 37113 : void *ret = slab_alloc_node(s, gfpflags, node, _RET_IP_);
2837 : :
2838 : 37113 : trace_kmalloc_node(_RET_IP_, ret,
2839 : 37113 : size, s->size, gfpflags, node);
2840 : :
2841 : 37113 : ret = kasan_kmalloc(s, ret, size, gfpflags);
2842 : 37113 : return ret;
2843 : : }
2844 : : EXPORT_SYMBOL(kmem_cache_alloc_node_trace);
2845 : : #endif
2846 : : #endif /* CONFIG_NUMA */
2847 : :
2848 : : /*
2849 : : * Slow path handling. This may still be called frequently since objects
2850 : : * have a longer lifetime than the cpu slabs in most processing loads.
2851 : : *
2852 : : * So we still attempt to reduce cache line usage. Just take the slab
2853 : : * lock and free the item. If there is no additional partial page
2854 : : * handling required then we can return immediately.
2855 : : */
2856 : 1682718 : static void __slab_free(struct kmem_cache *s, struct page *page,
2857 : : void *head, void *tail, int cnt,
2858 : : unsigned long addr)
2859 : :
2860 : : {
2861 : 1682718 : void *prior;
2862 : 1682718 : int was_frozen;
2863 : 1682718 : struct page new;
2864 : 1682718 : unsigned long counters;
2865 : 1682718 : struct kmem_cache_node *n = NULL;
2866 : 1682718 : unsigned long uninitialized_var(flags);
2867 : :
2868 : 1682718 : stat(s, FREE_SLOWPATH);
2869 : :
2870 [ - + - - ]: 1682718 : if (kmem_cache_debug(s) &&
2871 : 0 : !free_debug_processing(s, page, head, tail, cnt, addr))
2872 : 1676638 : return;
2873 : :
2874 : 1682718 : do {
2875 [ - + ]: 1682718 : if (unlikely(n)) {
2876 : 0 : spin_unlock_irqrestore(&n->list_lock, flags);
2877 : 0 : n = NULL;
2878 : : }
2879 : 1682718 : prior = page->freelist;
2880 : 1682718 : counters = page->counters;
2881 : 1682718 : set_freepointer(s, tail, prior);
2882 : 1682718 : new.counters = counters;
2883 : 1682718 : was_frozen = new.frozen;
2884 : 1682718 : new.inuse -= cnt;
2885 [ + + + + : 1682718 : if ((!new.inuse || !prior) && !was_frozen) {
+ + ]
2886 : :
2887 [ + - + + ]: 155469 : if (kmem_cache_has_cpu_partial(s) && !prior) {
2888 : :
2889 : : /*
2890 : : * Slab was on no list before and will be
2891 : : * partially empty
2892 : : * We can defer the list move and instead
2893 : : * freeze it.
2894 : : */
2895 : 149277 : new.frozen = 1;
2896 : :
2897 : : } else { /* Needs to be taken off a list */
2898 : :
2899 : 6192 : n = get_node(s, page_to_nid(page));
2900 : : /*
2901 : : * Speculatively acquire the list_lock.
2902 : : * If the cmpxchg does not succeed then we may
2903 : : * drop the list_lock without any processing.
2904 : : *
2905 : : * Otherwise the list_lock will synchronize with
2906 : : * other processors updating the list of slabs.
2907 : : */
2908 : 6192 : spin_lock_irqsave(&n->list_lock, flags);
2909 : :
2910 : : }
2911 : : }
2912 : :
2913 : 1682718 : } while (!cmpxchg_double_slab(s, page,
2914 : : prior, counters,
2915 : : head, new.counters,
2916 [ - + ]: 1682718 : "__slab_free"));
2917 : :
2918 [ + + ]: 1682718 : if (likely(!n)) {
2919 : :
2920 : : /*
2921 : : * If we just froze the page then put it onto the
2922 : : * per cpu partial list.
2923 : : */
2924 [ + + + + ]: 1676526 : if (new.frozen && !was_frozen) {
2925 : 149277 : put_cpu_partial(s, page, 1);
2926 : 149277 : stat(s, CPU_PARTIAL_FREE);
2927 : : }
2928 : : /*
2929 : : * The list lock was not taken therefore no list
2930 : : * activity can be necessary.
2931 : : */
2932 : 1676526 : if (was_frozen)
2933 : : stat(s, FREE_FROZEN);
2934 : 1676526 : return;
2935 : : }
2936 : :
2937 [ + - + + ]: 6192 : if (unlikely(!new.inuse && n->nr_partial >= s->min_partial))
2938 : 6080 : goto slab_empty;
2939 : :
2940 : : /*
2941 : : * Objects left in the slab. If it was not on the partial list before
2942 : : * then add it.
2943 : : */
2944 [ - + - - ]: 112 : if (!kmem_cache_has_cpu_partial(s) && unlikely(!prior)) {
2945 [ # # ]: 0 : remove_full(s, n, page);
2946 : 0 : add_partial(n, page, DEACTIVATE_TO_TAIL);
2947 : : stat(s, FREE_ADD_PARTIAL);
2948 : : }
2949 : 112 : spin_unlock_irqrestore(&n->list_lock, flags);
2950 : : return;
2951 : :
2952 : : slab_empty:
2953 [ + - ]: 6080 : if (prior) {
2954 : : /*
2955 : : * Slab on the partial list.
2956 : : */
2957 : 6080 : remove_partial(n, page);
2958 : : stat(s, FREE_REMOVE_PARTIAL);
2959 : : } else {
2960 : : /* Slab must be on the full list */
2961 [ # # ]: 0 : remove_full(s, n, page);
2962 : : }
2963 : :
2964 : 6080 : spin_unlock_irqrestore(&n->list_lock, flags);
2965 : 6080 : stat(s, FREE_SLAB);
2966 : 6080 : discard_slab(s, page);
2967 : : }
2968 : :
2969 : : /*
2970 : : * Fastpath with forced inlining to produce a kfree and kmem_cache_free that
2971 : : * can perform fastpath freeing without additional function calls.
2972 : : *
2973 : : * The fastpath is only possible if we are freeing to the current cpu slab
2974 : : * of this processor. This typically the case if we have just allocated
2975 : : * the item before.
2976 : : *
2977 : : * If fastpath is not possible then fall back to __slab_free where we deal
2978 : : * with all sorts of special processing.
2979 : : *
2980 : : * Bulk free of a freelist with several objects (all pointing to the
2981 : : * same page) possible by specifying head and tail ptr, plus objects
2982 : : * count (cnt). Bulk free indicated by tail pointer being set.
2983 : : */
2984 : 1761371 : static __always_inline void do_slab_free(struct kmem_cache *s,
2985 : : struct page *page, void *head, void *tail,
2986 : : int cnt, unsigned long addr)
2987 : : {
2988 : 1687817 : void *tail_obj = tail ? : head;
2989 : 1761371 : struct kmem_cache_cpu *c;
2990 : 1761371 : unsigned long tid;
2991 : 1761371 : redo:
2992 : : /*
2993 : : * Determine the currently cpus per cpu slab.
2994 : : * The cpu may change afterward. However that does not matter since
2995 : : * data is retrieved via this pointer. If we are on the same cpu
2996 : : * during the cmpxchg then the free will succeed.
2997 : : */
2998 : 1761371 : do {
2999 : 1761371 : tid = this_cpu_read(s->cpu_slab->tid);
3000 : 1761371 : c = raw_cpu_ptr(s->cpu_slab);
3001 : 1761371 : } while (IS_ENABLED(CONFIG_PREEMPTION) &&
3002 : : unlikely(tid != READ_ONCE(c->tid)));
3003 : :
3004 : : /* Same with comment on barrier() in slab_alloc_node() */
3005 : 1761371 : barrier();
3006 : :
3007 [ - - - - : 1761371 : if (likely(page == c->page)) {
+ + + + ]
3008 : 78653 : void **freelist = READ_ONCE(c->freelist);
3009 : :
3010 : 78653 : set_freepointer(s, tail_obj, freelist);
3011 : :
3012 [ - - - - : 78653 : if (unlikely(!this_cpu_cmpxchg_double(
- + - + ]
3013 : : s->cpu_slab->freelist, s->cpu_slab->tid,
3014 : : freelist, tid,
3015 : : head, next_tid(tid)))) {
3016 : :
3017 : 0 : note_cmpxchg_failure("slab_free", s, tid);
3018 : 0 : goto redo;
3019 : : }
3020 : : stat(s, FREE_FASTPATH);
3021 : : } else
3022 : 1682718 : __slab_free(s, page, head, tail_obj, cnt, addr);
3023 : :
3024 : : }
3025 : :
3026 : 1910999 : static __always_inline void slab_free(struct kmem_cache *s, struct page *page,
3027 : : void *head, void *tail, int cnt,
3028 : : unsigned long addr)
3029 : : {
3030 : : /*
3031 : : * With KASAN enabled slab_free_freelist_hook modifies the freelist
3032 : : * to remove objects, whose reuse must be delayed.
3033 : : */
3034 [ - + - - : 1910999 : if (slab_free_freelist_hook(s, &head, &tail))
+ + ]
3035 [ - - - - : 73554 : do_slab_free(s, page, head, tail, cnt, addr);
+ - ]
3036 : : }
3037 : :
3038 : : #ifdef CONFIG_KASAN_GENERIC
3039 : 1687817 : void ___cache_free(struct kmem_cache *cache, void *x, unsigned long addr)
3040 : : {
3041 [ + - ]: 1687817 : do_slab_free(cache, virt_to_head_page(x), x, NULL, 1, addr);
3042 : 1687817 : }
3043 : : #endif
3044 : :
3045 : 1646385 : void kmem_cache_free(struct kmem_cache *s, void *x)
3046 : : {
3047 : 1646385 : s = cache_from_obj(s, x);
3048 [ + - ]: 1646385 : if (!s)
3049 : : return;
3050 [ + - ]: 1646385 : slab_free(s, virt_to_head_page(x), x, NULL, 1, _RET_IP_);
3051 : 1646385 : trace_kmem_cache_free(_RET_IP_, x);
3052 : : }
3053 : : EXPORT_SYMBOL(kmem_cache_free);
3054 : :
3055 : : struct detached_freelist {
3056 : : struct page *page;
3057 : : void *tail;
3058 : : void *freelist;
3059 : : int cnt;
3060 : : struct kmem_cache *s;
3061 : : };
3062 : :
3063 : : /*
3064 : : * This function progressively scans the array with free objects (with
3065 : : * a limited look ahead) and extract objects belonging to the same
3066 : : * page. It builds a detached freelist directly within the given
3067 : : * page/objects. This can happen without any need for
3068 : : * synchronization, because the objects are owned by running process.
3069 : : * The freelist is build up as a single linked list in the objects.
3070 : : * The idea is, that this detached freelist can then be bulk
3071 : : * transferred to the real freelist(s), but only requiring a single
3072 : : * synchronization primitive. Look ahead in the array is limited due
3073 : : * to performance reasons.
3074 : : */
3075 : : static inline
3076 : 0 : int build_detached_freelist(struct kmem_cache *s, size_t size,
3077 : : void **p, struct detached_freelist *df)
3078 : : {
3079 : 0 : size_t first_skipped_index = 0;
3080 : 0 : int lookahead = 3;
3081 : 0 : void *object;
3082 : 0 : struct page *page;
3083 : :
3084 : : /* Always re-init detached_freelist */
3085 : 0 : df->page = NULL;
3086 : :
3087 : 0 : do {
3088 : 0 : object = p[--size];
3089 : : /* Do we need !ZERO_OR_NULL_PTR(object) here? (for kfree) */
3090 [ # # ]: 0 : } while (!object && size);
3091 : :
3092 [ # # ]: 0 : if (!object)
3093 : : return 0;
3094 : :
3095 [ # # ]: 0 : page = virt_to_head_page(object);
3096 [ # # ]: 0 : if (!s) {
3097 : : /* Handle kalloc'ed objects */
3098 [ # # # # ]: 0 : if (unlikely(!PageSlab(page))) {
3099 [ # # # # ]: 0 : BUG_ON(!PageCompound(page));
3100 : 0 : kfree_hook(object);
3101 : 0 : __free_pages(page, compound_order(page));
3102 : 0 : p[size] = NULL; /* mark object processed */
3103 : 0 : return size;
3104 : : }
3105 : : /* Derive kmem_cache from object */
3106 : 0 : df->s = page->slab_cache;
3107 : : } else {
3108 : 0 : df->s = cache_from_obj(s, object); /* Support for memcg */
3109 : : }
3110 : :
3111 : : /* Start new detached freelist */
3112 : 0 : df->page = page;
3113 : 0 : set_freepointer(df->s, object, NULL);
3114 : 0 : df->tail = object;
3115 : 0 : df->freelist = object;
3116 : 0 : p[size] = NULL; /* mark object processed */
3117 : 0 : df->cnt = 1;
3118 : :
3119 [ # # ]: 0 : while (size) {
3120 : 0 : object = p[--size];
3121 [ # # ]: 0 : if (!object)
3122 : 0 : continue; /* Skip processed objects */
3123 : :
3124 : : /* df->page is always set at this point */
3125 [ # # # # ]: 0 : if (df->page == virt_to_head_page(object)) {
3126 : : /* Opportunity build freelist */
3127 : 0 : set_freepointer(df->s, object, df->freelist);
3128 : 0 : df->freelist = object;
3129 : 0 : df->cnt++;
3130 : 0 : p[size] = NULL; /* mark object processed */
3131 : :
3132 : 0 : continue;
3133 : : }
3134 : :
3135 : : /* Limit look ahead search */
3136 [ # # ]: 0 : if (!--lookahead)
3137 : : break;
3138 : :
3139 [ # # ]: 0 : if (!first_skipped_index)
3140 : 0 : first_skipped_index = size + 1;
3141 : : }
3142 : :
3143 : 0 : return first_skipped_index;
3144 : : }
3145 : :
3146 : : /* Note that interrupts must be enabled when calling this function. */
3147 : 0 : void kmem_cache_free_bulk(struct kmem_cache *s, size_t size, void **p)
3148 : : {
3149 [ # # # # ]: 0 : if (WARN_ON(!size))
3150 : : return;
3151 : :
3152 : 0 : do {
3153 : 0 : struct detached_freelist df;
3154 : :
3155 : 0 : size = build_detached_freelist(s, size, p, &df);
3156 [ # # ]: 0 : if (!df.page)
3157 : 0 : continue;
3158 : :
3159 : 0 : slab_free(df.s, df.page, df.freelist, df.tail, df.cnt,_RET_IP_);
3160 [ # # ]: 0 : } while (likely(size));
3161 : : }
3162 : : EXPORT_SYMBOL(kmem_cache_free_bulk);
3163 : :
3164 : : /* Note that interrupts must be enabled when calling this function. */
3165 : 0 : int kmem_cache_alloc_bulk(struct kmem_cache *s, gfp_t flags, size_t size,
3166 : : void **p)
3167 : : {
3168 : 0 : struct kmem_cache_cpu *c;
3169 : 0 : int i;
3170 : :
3171 : : /* memcg and kmem_cache debug support */
3172 : 0 : s = slab_pre_alloc_hook(s, flags);
3173 [ # # ]: 0 : if (unlikely(!s))
3174 : : return false;
3175 : : /*
3176 : : * Drain objects in the per cpu slab, while disabling local
3177 : : * IRQs, which protects against PREEMPT and interrupts
3178 : : * handlers invoking normal fastpath.
3179 : : */
3180 : 0 : local_irq_disable();
3181 : 0 : c = this_cpu_ptr(s->cpu_slab);
3182 : :
3183 [ # # ]: 0 : for (i = 0; i < size; i++) {
3184 : 0 : void *object = c->freelist;
3185 : :
3186 [ # # ]: 0 : if (unlikely(!object)) {
3187 : : /*
3188 : : * We may have removed an object from c->freelist using
3189 : : * the fastpath in the previous iteration; in that case,
3190 : : * c->tid has not been bumped yet.
3191 : : * Since ___slab_alloc() may reenable interrupts while
3192 : : * allocating memory, we should bump c->tid now.
3193 : : */
3194 : 0 : c->tid = next_tid(c->tid);
3195 : :
3196 : : /*
3197 : : * Invoking slow path likely have side-effect
3198 : : * of re-populating per CPU c->freelist
3199 : : */
3200 : 0 : p[i] = ___slab_alloc(s, flags, NUMA_NO_NODE,
3201 : 0 : _RET_IP_, c);
3202 [ # # ]: 0 : if (unlikely(!p[i]))
3203 : 0 : goto error;
3204 : :
3205 : 0 : c = this_cpu_ptr(s->cpu_slab);
3206 [ # # ]: 0 : maybe_wipe_obj_freeptr(s, p[i]);
3207 : :
3208 : 0 : continue; /* goto for-loop */
3209 : : }
3210 : 0 : c->freelist = get_freepointer(s, object);
3211 : 0 : p[i] = object;
3212 [ # # ]: 0 : maybe_wipe_obj_freeptr(s, p[i]);
3213 : : }
3214 : 0 : c->tid = next_tid(c->tid);
3215 : 0 : local_irq_enable();
3216 : :
3217 : : /* Clear memory outside IRQ disabled fastpath loop */
3218 [ # # ]: 0 : if (unlikely(slab_want_init_on_alloc(flags, s))) {
3219 : : int j;
3220 : :
3221 [ # # ]: 0 : for (j = 0; j < i; j++)
3222 : 0 : memset(p[j], 0, s->object_size);
3223 : : }
3224 : :
3225 : : /* memcg and kmem_cache debug support */
3226 : 0 : slab_post_alloc_hook(s, flags, size, p);
3227 : 0 : return i;
3228 : : error:
3229 : 0 : local_irq_enable();
3230 : 0 : slab_post_alloc_hook(s, flags, i, p);
3231 : 0 : __kmem_cache_free_bulk(s, i, p);
3232 : 0 : return 0;
3233 : : }
3234 : : EXPORT_SYMBOL(kmem_cache_alloc_bulk);
3235 : :
3236 : :
3237 : : /*
3238 : : * Object placement in a slab is made very easy because we always start at
3239 : : * offset 0. If we tune the size of the object to the alignment then we can
3240 : : * get the required alignment by putting one properly sized object after
3241 : : * another.
3242 : : *
3243 : : * Notice that the allocation order determines the sizes of the per cpu
3244 : : * caches. Each processor has always one slab available for allocations.
3245 : : * Increasing the allocation order reduces the number of times that slabs
3246 : : * must be moved on and off the partial lists and is therefore a factor in
3247 : : * locking overhead.
3248 : : */
3249 : :
3250 : : /*
3251 : : * Mininum / Maximum order of slab pages. This influences locking overhead
3252 : : * and slab fragmentation. A higher order reduces the number of partial slabs
3253 : : * and increases the number of allocations possible without having to
3254 : : * take the list_lock.
3255 : : */
3256 : : static unsigned int slub_min_order;
3257 : : static unsigned int slub_max_order = PAGE_ALLOC_COSTLY_ORDER;
3258 : : static unsigned int slub_min_objects;
3259 : :
3260 : : /*
3261 : : * Calculate the order of allocation given an slab object size.
3262 : : *
3263 : : * The order of allocation has significant impact on performance and other
3264 : : * system components. Generally order 0 allocations should be preferred since
3265 : : * order 0 does not cause fragmentation in the page allocator. Larger objects
3266 : : * be problematic to put into order 0 slabs because there may be too much
3267 : : * unused space left. We go to a higher order if more than 1/16th of the slab
3268 : : * would be wasted.
3269 : : *
3270 : : * In order to reach satisfactory performance we must ensure that a minimum
3271 : : * number of objects is in one slab. Otherwise we may generate too much
3272 : : * activity on the partial lists which requires taking the list_lock. This is
3273 : : * less a concern for large slabs though which are rarely used.
3274 : : *
3275 : : * slub_max_order specifies the order where we begin to stop considering the
3276 : : * number of objects in a slab as critical. If we reach slub_max_order then
3277 : : * we try to keep the page order as low as possible. So we accept more waste
3278 : : * of space in favor of a small page order.
3279 : : *
3280 : : * Higher order allocations also allow the placement of more objects in a
3281 : : * slab and thereby reduce object handling overhead. If the user has
3282 : : * requested a higher mininum order then we start with that one instead of
3283 : : * the smallest order which will fit the object.
3284 : : */
3285 : 669 : static inline unsigned int slab_order(unsigned int size,
3286 : : unsigned int min_objects, unsigned int max_order,
3287 : : unsigned int fract_leftover)
3288 : : {
3289 : 669 : unsigned int min_order = slub_min_order;
3290 : 669 : unsigned int order;
3291 : :
3292 [ - + ]: 669 : if (order_objects(min_order, size) > MAX_OBJS_PER_PAGE)
3293 : 0 : return get_order(size * MAX_OBJS_PER_PAGE) - 1;
3294 : :
3295 : 669 : for (order = max(min_order, (unsigned int)get_order(min_objects * size));
3296 [ + + ]: 711 : order <= max_order; order++) {
3297 : :
3298 : 699 : unsigned int slab_size = (unsigned int)PAGE_SIZE << order;
3299 : 699 : unsigned int rem;
3300 : :
3301 : 699 : rem = slab_size % size;
3302 : :
3303 [ + + ]: 699 : if (rem <= slab_size / fract_leftover)
3304 : : break;
3305 : : }
3306 : :
3307 : : return order;
3308 : : }
3309 : :
3310 : 657 : static inline int calculate_order(unsigned int size)
3311 : : {
3312 : 657 : unsigned int order;
3313 : 657 : unsigned int min_objects;
3314 : 657 : unsigned int max_objects;
3315 : :
3316 : : /*
3317 : : * Attempt to find best configuration for a slab. This
3318 : : * works by first attempting to generate a layout with
3319 : : * the best configuration and backing off gradually.
3320 : : *
3321 : : * First we increase the acceptable waste in a slab. Then
3322 : : * we reduce the minimum objects required in a slab.
3323 : : */
3324 : 657 : min_objects = slub_min_objects;
3325 [ + - ]: 657 : if (!min_objects)
3326 : 657 : min_objects = 4 * (fls(nr_cpu_ids) + 1);
3327 : 657 : max_objects = order_objects(slub_max_order, size);
3328 : 657 : min_objects = min(min_objects, max_objects);
3329 : :
3330 [ + - ]: 657 : while (min_objects > 1) {
3331 : : unsigned int fraction;
3332 : :
3333 : : fraction = 16;
3334 [ + - ]: 669 : while (fraction >= 4) {
3335 : 669 : order = slab_order(size, min_objects,
3336 : : slub_max_order, fraction);
3337 [ + + ]: 669 : if (order <= slub_max_order)
3338 : 657 : return order;
3339 : 12 : fraction /= 2;
3340 : : }
3341 : 0 : min_objects--;
3342 : : }
3343 : :
3344 : : /*
3345 : : * We were unable to place multiple objects in a slab. Now
3346 : : * lets see if we can place a single object there.
3347 : : */
3348 : 0 : order = slab_order(size, 1, slub_max_order, 1);
3349 [ # # ]: 0 : if (order <= slub_max_order)
3350 : 0 : return order;
3351 : :
3352 : : /*
3353 : : * Doh this slab cannot be placed using slub_max_order.
3354 : : */
3355 : 0 : order = slab_order(size, 1, MAX_ORDER, 1);
3356 [ # # ]: 0 : if (order < MAX_ORDER)
3357 : 0 : return order;
3358 : : return -ENOSYS;
3359 : : }
3360 : :
3361 : : static void
3362 : 657 : init_kmem_cache_node(struct kmem_cache_node *n)
3363 : : {
3364 : 657 : n->nr_partial = 0;
3365 : 657 : spin_lock_init(&n->list_lock);
3366 [ + - ]: 657 : INIT_LIST_HEAD(&n->partial);
3367 : : #ifdef CONFIG_SLUB_DEBUG
3368 [ + - ]: 657 : atomic_long_set(&n->nr_slabs, 0);
3369 : 657 : atomic_long_set(&n->total_objects, 0);
3370 : 657 : INIT_LIST_HEAD(&n->full);
3371 : : #endif
3372 : : }
3373 : :
3374 : 657 : static inline int alloc_kmem_cache_cpus(struct kmem_cache *s)
3375 : : {
3376 : 657 : BUILD_BUG_ON(PERCPU_DYNAMIC_EARLY_SIZE <
3377 : : KMALLOC_SHIFT_HIGH * sizeof(struct kmem_cache_cpu));
3378 : :
3379 : : /*
3380 : : * Must align to double word boundary for the double cmpxchg
3381 : : * instructions to work; see __pcpu_double_call_return_bool().
3382 : : */
3383 : 657 : s->cpu_slab = __alloc_percpu(sizeof(struct kmem_cache_cpu),
3384 : : 2 * sizeof(void *));
3385 : :
3386 [ + - ]: 657 : if (!s->cpu_slab)
3387 : : return 0;
3388 : :
3389 : 657 : init_kmem_cache_cpus(s);
3390 : :
3391 : 657 : return 1;
3392 : : }
3393 : :
3394 : : static struct kmem_cache *kmem_cache_node;
3395 : :
3396 : : /*
3397 : : * No kmalloc_node yet so do it by hand. We know that this is the first
3398 : : * slab on the node for this slabcache. There are no concurrent accesses
3399 : : * possible.
3400 : : *
3401 : : * Note that this function only works on the kmem_cache_node
3402 : : * when allocating for the kmem_cache_node. This is used for bootstrapping
3403 : : * memory on a fresh node that has no slab structures yet.
3404 : : */
3405 : 3 : static void early_kmem_cache_node_alloc(int node)
3406 : : {
3407 : 3 : struct page *page;
3408 : 3 : struct kmem_cache_node *n;
3409 : :
3410 [ - + ]: 3 : BUG_ON(kmem_cache_node->size < sizeof(struct kmem_cache_node));
3411 : :
3412 : 3 : page = new_slab(kmem_cache_node, GFP_NOWAIT, node);
3413 : :
3414 [ - + ]: 3 : BUG_ON(!page);
3415 [ - + ]: 3 : if (page_to_nid(page) != node) {
3416 : 0 : pr_err("SLUB: Unable to allocate memory from node %d\n", node);
3417 : 0 : pr_err("SLUB: Allocating a useless per node structure in order to be able to continue\n");
3418 : : }
3419 : :
3420 : 3 : n = page->freelist;
3421 [ - + ]: 3 : BUG_ON(!n);
3422 : : #ifdef CONFIG_SLUB_DEBUG
3423 : 3 : init_object(kmem_cache_node, n, SLUB_RED_ACTIVE);
3424 : 3 : init_tracking(kmem_cache_node, n);
3425 : : #endif
3426 : 3 : n = kasan_kmalloc(kmem_cache_node, n, sizeof(struct kmem_cache_node),
3427 : : GFP_KERNEL);
3428 : 3 : page->freelist = get_freepointer(kmem_cache_node, n);
3429 : 3 : page->inuse = 1;
3430 : 3 : page->frozen = 0;
3431 : 3 : kmem_cache_node->node[node] = n;
3432 [ + - ]: 3 : init_kmem_cache_node(n);
3433 [ + - ]: 3 : inc_slabs_node(kmem_cache_node, node, page->objects);
3434 : :
3435 : : /*
3436 : : * No locks need to be taken here as it has just been
3437 : : * initialized and there is no concurrent access.
3438 : : */
3439 : 3 : __add_partial(n, page, DEACTIVATE_TO_HEAD);
3440 : 3 : }
3441 : :
3442 : 0 : static void free_kmem_cache_nodes(struct kmem_cache *s)
3443 : : {
3444 : 0 : int node;
3445 : 0 : struct kmem_cache_node *n;
3446 : :
3447 [ # # # # ]: 0 : for_each_kmem_cache_node(s, node, n) {
3448 : 0 : s->node[node] = NULL;
3449 : 0 : kmem_cache_free(kmem_cache_node, n);
3450 : : }
3451 : 0 : }
3452 : :
3453 : 0 : void __kmem_cache_release(struct kmem_cache *s)
3454 : : {
3455 : 0 : cache_random_seq_destroy(s);
3456 : 0 : free_percpu(s->cpu_slab);
3457 : 0 : free_kmem_cache_nodes(s);
3458 : 0 : }
3459 : :
3460 : 657 : static int init_kmem_cache_nodes(struct kmem_cache *s)
3461 : : {
3462 : 657 : int node;
3463 : :
3464 [ + + ]: 2628 : for_each_node_state(node, N_NORMAL_MEMORY) {
3465 : 657 : struct kmem_cache_node *n;
3466 : :
3467 [ + + ]: 657 : if (slab_state == DOWN) {
3468 : 3 : early_kmem_cache_node_alloc(node);
3469 : 3 : continue;
3470 : : }
3471 : 654 : n = kmem_cache_alloc_node(kmem_cache_node,
3472 : : GFP_KERNEL, node);
3473 : :
3474 [ - + ]: 654 : if (!n) {
3475 : 0 : free_kmem_cache_nodes(s);
3476 : 0 : return 0;
3477 : : }
3478 : :
3479 : 654 : init_kmem_cache_node(n);
3480 : 654 : s->node[node] = n;
3481 : : }
3482 : : return 1;
3483 : : }
3484 : :
3485 : 657 : static void set_min_partial(struct kmem_cache *s, unsigned long min)
3486 : : {
3487 : 657 : if (min < MIN_PARTIAL)
3488 : : min = MIN_PARTIAL;
3489 : : else if (min > MAX_PARTIAL)
3490 : : min = MAX_PARTIAL;
3491 : 657 : s->min_partial = min;
3492 : : }
3493 : :
3494 : 657 : static void set_cpu_partial(struct kmem_cache *s)
3495 : : {
3496 : : #ifdef CONFIG_SLUB_CPU_PARTIAL
3497 : : /*
3498 : : * cpu_partial determined the maximum number of objects kept in the
3499 : : * per cpu partial lists of a processor.
3500 : : *
3501 : : * Per cpu partial lists mainly contain slabs that just have one
3502 : : * object freed. If they are used for allocation then they can be
3503 : : * filled up again with minimal effort. The slab will never hit the
3504 : : * per node partial lists and therefore no locking will be required.
3505 : : *
3506 : : * This setting also determines
3507 : : *
3508 : : * A) The number of objects from per cpu partial slabs dumped to the
3509 : : * per node list when we reach the limit.
3510 : : * B) The number of objects in cpu partial slabs to extract from the
3511 : : * per node list when we run out of per cpu objects. We only fetch
3512 : : * 50% to keep some capacity around for frees.
3513 : : */
3514 : 657 : if (!kmem_cache_has_cpu_partial(s))
3515 : 0 : s->cpu_partial = 0;
3516 [ + + ]: 657 : else if (s->size >= PAGE_SIZE)
3517 : 36 : s->cpu_partial = 2;
3518 [ + + ]: 621 : else if (s->size >= 1024)
3519 : 102 : s->cpu_partial = 6;
3520 [ + + ]: 519 : else if (s->size >= 256)
3521 : 213 : s->cpu_partial = 13;
3522 : : else
3523 : 306 : s->cpu_partial = 30;
3524 : : #endif
3525 : : }
3526 : :
3527 : : /*
3528 : : * calculate_sizes() determines the order and the distribution of data within
3529 : : * a slab object.
3530 : : */
3531 : 657 : static int calculate_sizes(struct kmem_cache *s, int forced_order)
3532 : : {
3533 : 657 : slab_flags_t flags = s->flags;
3534 : 657 : unsigned int size = s->object_size;
3535 : 657 : unsigned int order;
3536 : :
3537 : : /*
3538 : : * Round up object size to the next word boundary. We can only
3539 : : * place the free pointer at word boundaries and this determines
3540 : : * the possible location of the free pointer.
3541 : : */
3542 : 657 : size = ALIGN(size, sizeof(void *));
3543 : :
3544 : : #ifdef CONFIG_SLUB_DEBUG
3545 : : /*
3546 : : * Determine if we can poison the object itself. If the user of
3547 : : * the slab may touch the object after free or before allocation
3548 : : * then we should never poison the object itself.
3549 : : */
3550 [ - + ]: 657 : if ((flags & SLAB_POISON) && !(flags & SLAB_TYPESAFE_BY_RCU) &&
3551 [ # # ]: 0 : !s->ctor)
3552 : 0 : s->flags |= __OBJECT_POISON;
3553 : : else
3554 : 657 : s->flags &= ~__OBJECT_POISON;
3555 : :
3556 : :
3557 : : /*
3558 : : * If we are Redzoning then check if there is some space between the
3559 : : * end of the object and the free pointer. If not then add an
3560 : : * additional word to have some bytes to store Redzone information.
3561 : : */
3562 [ - + - - ]: 657 : if ((flags & SLAB_RED_ZONE) && size == s->object_size)
3563 : 0 : size += sizeof(void *);
3564 : : #endif
3565 : :
3566 : : /*
3567 : : * With that we have determined the number of bytes in actual use
3568 : : * by the object. This is the potential offset to the free pointer.
3569 : : */
3570 : 657 : s->inuse = size;
3571 : :
3572 [ + + ]: 657 : if (((flags & (SLAB_TYPESAFE_BY_RCU | SLAB_POISON)) ||
3573 [ + + ]: 618 : s->ctor)) {
3574 : : /*
3575 : : * Relocate free pointer after the object if it is not
3576 : : * permitted to overwrite the first word of the object on
3577 : : * kmem_cache_free.
3578 : : *
3579 : : * This is the case if we do RCU, have a constructor or
3580 : : * destructor or are poisoning the objects.
3581 : : */
3582 : 87 : s->offset = size;
3583 : 87 : size += sizeof(void *);
3584 : : }
3585 : :
3586 : : #ifdef CONFIG_SLUB_DEBUG
3587 [ - + ]: 657 : if (flags & SLAB_STORE_USER)
3588 : : /*
3589 : : * Need to store information about allocs and frees after
3590 : : * the object.
3591 : : */
3592 : 0 : size += 2 * sizeof(struct track);
3593 : : #endif
3594 : :
3595 : 657 : kasan_cache_create(s, &size, &s->flags);
3596 : : #ifdef CONFIG_SLUB_DEBUG
3597 [ - + ]: 657 : if (flags & SLAB_RED_ZONE) {
3598 : : /*
3599 : : * Add some empty padding so that we can catch
3600 : : * overwrites from earlier objects rather than let
3601 : : * tracking information or the free pointer be
3602 : : * corrupted if a user writes before the start
3603 : : * of the object.
3604 : : */
3605 : 0 : size += sizeof(void *);
3606 : :
3607 : 0 : s->red_left_pad = sizeof(void *);
3608 : 0 : s->red_left_pad = ALIGN(s->red_left_pad, s->align);
3609 : 0 : size += s->red_left_pad;
3610 : : }
3611 : : #endif
3612 : :
3613 : : /*
3614 : : * SLUB stores one object immediately after another beginning from
3615 : : * offset 0. In order to align the objects we have to simply size
3616 : : * each object to conform to the alignment.
3617 : : */
3618 : 657 : size = ALIGN(size, s->align);
3619 : 657 : s->size = size;
3620 [ - + ]: 657 : if (forced_order >= 0)
3621 : 0 : order = forced_order;
3622 : : else
3623 : 657 : order = calculate_order(size);
3624 : :
3625 [ + - ]: 657 : if ((int)order < 0)
3626 : : return 0;
3627 : :
3628 : 657 : s->allocflags = 0;
3629 [ + + ]: 657 : if (order)
3630 : 204 : s->allocflags |= __GFP_COMP;
3631 : :
3632 [ + + ]: 657 : if (s->flags & SLAB_CACHE_DMA)
3633 : 39 : s->allocflags |= GFP_DMA;
3634 : :
3635 [ - + ]: 657 : if (s->flags & SLAB_CACHE_DMA32)
3636 : 0 : s->allocflags |= GFP_DMA32;
3637 : :
3638 [ + + ]: 657 : if (s->flags & SLAB_RECLAIM_ACCOUNT)
3639 : 135 : s->allocflags |= __GFP_RECLAIMABLE;
3640 : :
3641 : : /*
3642 : : * Determine the number of objects per slab
3643 : : */
3644 : 657 : s->oo = oo_make(order, size);
3645 : 657 : s->min = oo_make(get_order(size), size);
3646 [ + - ]: 657 : if (oo_objects(s->oo) > oo_objects(s->max))
3647 : 657 : s->max = s->oo;
3648 : :
3649 : 657 : return !!oo_objects(s->oo);
3650 : : }
3651 : :
3652 : 657 : static int kmem_cache_open(struct kmem_cache *s, slab_flags_t flags)
3653 : : {
3654 : 657 : s->flags = kmem_cache_flags(s->size, flags, s->name, s->ctor);
3655 : : #ifdef CONFIG_SLAB_FREELIST_HARDENED
3656 : : s->random = get_random_long();
3657 : : #endif
3658 : :
3659 [ - + ]: 657 : if (!calculate_sizes(s, -1))
3660 : 0 : goto error;
3661 [ - + ]: 657 : if (disable_higher_order_debug) {
3662 : : /*
3663 : : * Disable debugging flags that store metadata if the min slab
3664 : : * order increased.
3665 : : */
3666 [ # # ]: 0 : if (get_order(s->size) > get_order(s->object_size)) {
3667 : 0 : s->flags &= ~DEBUG_METADATA_FLAGS;
3668 : 0 : s->offset = 0;
3669 [ # # ]: 0 : if (!calculate_sizes(s, -1))
3670 : 0 : goto error;
3671 : : }
3672 : : }
3673 : :
3674 : : #if defined(CONFIG_HAVE_CMPXCHG_DOUBLE) && \
3675 : : defined(CONFIG_HAVE_ALIGNED_STRUCT_PAGE)
3676 [ + - + - ]: 657 : if (system_has_cmpxchg_double() && (s->flags & SLAB_NO_CMPXCHG) == 0)
3677 : : /* Enable fast mode */
3678 : 657 : s->flags |= __CMPXCHG_DOUBLE;
3679 : : #endif
3680 : :
3681 : : /*
3682 : : * The larger the object size is, the more pages we want on the partial
3683 : : * list to avoid pounding the page allocator excessively.
3684 : : */
3685 [ - + - - : 657 : set_min_partial(s, ilog2(s->size) / 2);
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - ]
3686 : :
3687 [ - + ]: 657 : set_cpu_partial(s);
3688 : :
3689 : : #ifdef CONFIG_NUMA
3690 : 657 : s->remote_node_defrag_ratio = 1000;
3691 : : #endif
3692 : :
3693 : : /* Initialize the pre-computed randomized freelist if slab is up */
3694 : 657 : if (slab_state >= UP) {
3695 : : if (init_cache_random_seq(s))
3696 : : goto error;
3697 : : }
3698 : :
3699 [ - + ]: 657 : if (!init_kmem_cache_nodes(s))
3700 : 0 : goto error;
3701 : :
3702 [ - + ]: 657 : if (alloc_kmem_cache_cpus(s))
3703 : : return 0;
3704 : :
3705 : 0 : free_kmem_cache_nodes(s);
3706 : : error:
3707 : : return -EINVAL;
3708 : : }
3709 : :
3710 : 0 : static void list_slab_objects(struct kmem_cache *s, struct page *page,
3711 : : const char *text)
3712 : : {
3713 : : #ifdef CONFIG_SLUB_DEBUG
3714 : 0 : void *addr = page_address(page);
3715 : 0 : void *p;
3716 : 0 : unsigned long *map;
3717 : :
3718 : 0 : slab_err(s, page, text, s->name);
3719 : 0 : slab_lock(page);
3720 : :
3721 : 0 : map = get_map(s, page);
3722 [ # # # # ]: 0 : for_each_object(p, s, addr, page->objects) {
3723 : :
3724 [ # # # # ]: 0 : if (!test_bit(slab_index(p, s, addr), map)) {
3725 : 0 : pr_err("INFO: Object 0x%p @offset=%tu\n", p, p - addr);
3726 : 0 : print_tracking(s, p);
3727 : : }
3728 : : }
3729 : 0 : put_map(map);
3730 : :
3731 : 0 : slab_unlock(page);
3732 : : #endif
3733 : 0 : }
3734 : :
3735 : : /*
3736 : : * Attempt to free all partial slabs on a node.
3737 : : * This is called from __kmem_cache_shutdown(). We must take list_lock
3738 : : * because sysfs file might still access partial list after the shutdowning.
3739 : : */
3740 : 0 : static void free_partial(struct kmem_cache *s, struct kmem_cache_node *n)
3741 : : {
3742 : 0 : LIST_HEAD(discard);
3743 : 0 : struct page *page, *h;
3744 : :
3745 [ # # ]: 0 : BUG_ON(irqs_disabled());
3746 : 0 : spin_lock_irq(&n->list_lock);
3747 [ # # ]: 0 : list_for_each_entry_safe(page, h, &n->partial, slab_list) {
3748 [ # # ]: 0 : if (!page->inuse) {
3749 : 0 : remove_partial(n, page);
3750 : 0 : list_add(&page->slab_list, &discard);
3751 : : } else {
3752 : 0 : list_slab_objects(s, page,
3753 : : "Objects remaining in %s on __kmem_cache_shutdown()");
3754 : : }
3755 : : }
3756 : 0 : spin_unlock_irq(&n->list_lock);
3757 : :
3758 [ # # ]: 0 : list_for_each_entry_safe(page, h, &discard, slab_list)
3759 : 0 : discard_slab(s, page);
3760 : 0 : }
3761 : :
3762 : 0 : bool __kmem_cache_empty(struct kmem_cache *s)
3763 : : {
3764 : 0 : int node;
3765 : 0 : struct kmem_cache_node *n;
3766 : :
3767 [ # # # # ]: 0 : for_each_kmem_cache_node(s, node, n)
3768 [ # # # # ]: 0 : if (n->nr_partial || slabs_node(s, node))
3769 : : return false;
3770 : : return true;
3771 : : }
3772 : :
3773 : : /*
3774 : : * Release all resources used by a slab cache.
3775 : : */
3776 : 0 : int __kmem_cache_shutdown(struct kmem_cache *s)
3777 : : {
3778 : 0 : int node;
3779 : 0 : struct kmem_cache_node *n;
3780 : :
3781 : 0 : flush_all(s);
3782 : : /* Attempt to free all objects */
3783 [ # # # # ]: 0 : for_each_kmem_cache_node(s, node, n) {
3784 : 0 : free_partial(s, n);
3785 [ # # # # ]: 0 : if (n->nr_partial || slabs_node(s, node))
3786 : : return 1;
3787 : : }
3788 : 0 : sysfs_slab_remove(s);
3789 : 0 : return 0;
3790 : : }
3791 : :
3792 : : /********************************************************************
3793 : : * Kmalloc subsystem
3794 : : *******************************************************************/
3795 : :
3796 : 0 : static int __init setup_slub_min_order(char *str)
3797 : : {
3798 : 0 : get_option(&str, (int *)&slub_min_order);
3799 : :
3800 : 0 : return 1;
3801 : : }
3802 : :
3803 : : __setup("slub_min_order=", setup_slub_min_order);
3804 : :
3805 : 0 : static int __init setup_slub_max_order(char *str)
3806 : : {
3807 : 0 : get_option(&str, (int *)&slub_max_order);
3808 : 0 : slub_max_order = min(slub_max_order, (unsigned int)MAX_ORDER - 1);
3809 : :
3810 : 0 : return 1;
3811 : : }
3812 : :
3813 : : __setup("slub_max_order=", setup_slub_max_order);
3814 : :
3815 : 0 : static int __init setup_slub_min_objects(char *str)
3816 : : {
3817 : 0 : get_option(&str, (int *)&slub_min_objects);
3818 : :
3819 : 0 : return 1;
3820 : : }
3821 : :
3822 : : __setup("slub_min_objects=", setup_slub_min_objects);
3823 : :
3824 : 121334 : void *__kmalloc(size_t size, gfp_t flags)
3825 : : {
3826 : 121334 : struct kmem_cache *s;
3827 : 121334 : void *ret;
3828 : :
3829 [ + + ]: 121334 : if (unlikely(size > KMALLOC_MAX_CACHE_SIZE))
3830 : 3 : return kmalloc_large(size, flags);
3831 : :
3832 : 121331 : s = kmalloc_slab(size, flags);
3833 : :
3834 [ + - ]: 121331 : if (unlikely(ZERO_OR_NULL_PTR(s)))
3835 : : return s;
3836 : :
3837 : 121331 : ret = slab_alloc(s, flags, _RET_IP_);
3838 : :
3839 : 121331 : trace_kmalloc(_RET_IP_, ret, size, s->size, flags);
3840 : :
3841 : 121331 : ret = kasan_kmalloc(s, ret, size, flags);
3842 : :
3843 : 121331 : return ret;
3844 : : }
3845 : : EXPORT_SYMBOL(__kmalloc);
3846 : :
3847 : : #ifdef CONFIG_NUMA
3848 : 9 : static void *kmalloc_large_node(size_t size, gfp_t flags, int node)
3849 : : {
3850 : 9 : struct page *page;
3851 : 9 : void *ptr = NULL;
3852 : 9 : unsigned int order = get_order(size);
3853 : :
3854 : 9 : flags |= __GFP_COMP;
3855 [ + - ]: 9 : page = alloc_pages_node(node, flags, order);
3856 [ + - ]: 9 : if (page) {
3857 : 9 : ptr = page_address(page);
3858 : 9 : mod_node_page_state(page_pgdat(page), NR_SLAB_UNRECLAIMABLE,
3859 : 9 : 1 << order);
3860 : : }
3861 : :
3862 : 9 : return kmalloc_large_node_hook(ptr, size, flags);
3863 : : }
3864 : :
3865 : 42845 : void *__kmalloc_node(size_t size, gfp_t flags, int node)
3866 : : {
3867 : 42845 : struct kmem_cache *s;
3868 : 42845 : void *ret;
3869 : :
3870 [ + + ]: 42845 : if (unlikely(size > KMALLOC_MAX_CACHE_SIZE)) {
3871 : 9 : ret = kmalloc_large_node(size, flags, node);
3872 : :
3873 : 18 : trace_kmalloc_node(_RET_IP_, ret,
3874 : 9 : size, PAGE_SIZE << get_order(size),
3875 : : flags, node);
3876 : :
3877 : 9 : return ret;
3878 : : }
3879 : :
3880 : 42836 : s = kmalloc_slab(size, flags);
3881 : :
3882 [ + - ]: 42836 : if (unlikely(ZERO_OR_NULL_PTR(s)))
3883 : : return s;
3884 : :
3885 : 42836 : ret = slab_alloc_node(s, flags, node, _RET_IP_);
3886 : :
3887 : 42836 : trace_kmalloc_node(_RET_IP_, ret, size, s->size, flags, node);
3888 : :
3889 : 42836 : ret = kasan_kmalloc(s, ret, size, flags);
3890 : :
3891 : 42836 : return ret;
3892 : : }
3893 : : EXPORT_SYMBOL(__kmalloc_node);
3894 : : #endif /* CONFIG_NUMA */
3895 : :
3896 : : #ifdef CONFIG_HARDENED_USERCOPY
3897 : : /*
3898 : : * Rejects incorrectly sized objects and objects that are to be copied
3899 : : * to/from userspace but do not fall entirely within the containing slab
3900 : : * cache's usercopy region.
3901 : : *
3902 : : * Returns NULL if check passes, otherwise const char * to name of cache
3903 : : * to indicate an error.
3904 : : */
3905 : : void __check_heap_object(const void *ptr, unsigned long n, struct page *page,
3906 : : bool to_user)
3907 : : {
3908 : : struct kmem_cache *s;
3909 : : unsigned int offset;
3910 : : size_t object_size;
3911 : :
3912 : : ptr = kasan_reset_tag(ptr);
3913 : :
3914 : : /* Find object and usable object size. */
3915 : : s = page->slab_cache;
3916 : :
3917 : : /* Reject impossible pointers. */
3918 : : if (ptr < page_address(page))
3919 : : usercopy_abort("SLUB object not in SLUB page?!", NULL,
3920 : : to_user, 0, n);
3921 : :
3922 : : /* Find offset within object. */
3923 : : offset = (ptr - page_address(page)) % s->size;
3924 : :
3925 : : /* Adjust for redzone and reject if within the redzone. */
3926 : : if (kmem_cache_debug(s) && s->flags & SLAB_RED_ZONE) {
3927 : : if (offset < s->red_left_pad)
3928 : : usercopy_abort("SLUB object in left red zone",
3929 : : s->name, to_user, offset, n);
3930 : : offset -= s->red_left_pad;
3931 : : }
3932 : :
3933 : : /* Allow address range falling entirely within usercopy region. */
3934 : : if (offset >= s->useroffset &&
3935 : : offset - s->useroffset <= s->usersize &&
3936 : : n <= s->useroffset - offset + s->usersize)
3937 : : return;
3938 : :
3939 : : /*
3940 : : * If the copy is still within the allocated object, produce
3941 : : * a warning instead of rejecting the copy. This is intended
3942 : : * to be a temporary method to find any missing usercopy
3943 : : * whitelists.
3944 : : */
3945 : : object_size = slab_ksize(s);
3946 : : if (usercopy_fallback &&
3947 : : offset <= object_size && n <= object_size - offset) {
3948 : : usercopy_warn("SLUB object", s->name, to_user, offset, n);
3949 : : return;
3950 : : }
3951 : :
3952 : : usercopy_abort("SLUB object", s->name, to_user, offset, n);
3953 : : }
3954 : : #endif /* CONFIG_HARDENED_USERCOPY */
3955 : :
3956 : 10971 : size_t __ksize(const void *object)
3957 : : {
3958 : 10971 : struct page *page;
3959 : :
3960 [ + - ]: 10971 : if (unlikely(object == ZERO_SIZE_PTR))
3961 : : return 0;
3962 : :
3963 [ + - ]: 10971 : page = virt_to_head_page(object);
3964 : :
3965 [ - + - + ]: 21942 : if (unlikely(!PageSlab(page))) {
3966 [ # # ]: 0 : WARN_ON(!PageCompound(page));
3967 : 0 : return page_size(page);
3968 : : }
3969 : :
3970 [ - + ]: 10971 : return slab_ksize(page->slab_cache);
3971 : : }
3972 : : EXPORT_SYMBOL(__ksize);
3973 : :
3974 : 310157 : void kfree(const void *x)
3975 : : {
3976 : 310157 : struct page *page;
3977 : 310157 : void *object = (void *)x;
3978 : :
3979 : 310157 : trace_kfree(_RET_IP_, x);
3980 : :
3981 [ + + ]: 310157 : if (unlikely(ZERO_OR_NULL_PTR(x)))
3982 : : return;
3983 : :
3984 [ + - ]: 264659 : page = virt_to_head_page(x);
3985 [ - + + + ]: 264659 : if (unlikely(!PageSlab(page))) {
3986 : 45 : unsigned int order = compound_order(page);
3987 : :
3988 [ - + - + ]: 45 : BUG_ON(!PageCompound(page));
3989 : 45 : kfree_hook(object);
3990 : 45 : mod_node_page_state(page_pgdat(page), NR_SLAB_UNRECLAIMABLE,
3991 : 45 : -(1 << order));
3992 : 45 : __free_pages(page, order);
3993 : 45 : return;
3994 : : }
3995 : 529228 : slab_free(page->slab_cache, page, object, NULL, 1, _RET_IP_);
3996 : : }
3997 : : EXPORT_SYMBOL(kfree);
3998 : :
3999 : : #define SHRINK_PROMOTE_MAX 32
4000 : :
4001 : : /*
4002 : : * kmem_cache_shrink discards empty slabs and promotes the slabs filled
4003 : : * up most to the head of the partial lists. New allocations will then
4004 : : * fill those up and thus they can be removed from the partial lists.
4005 : : *
4006 : : * The slabs with the least items are placed last. This results in them
4007 : : * being allocated from last increasing the chance that the last objects
4008 : : * are freed in them.
4009 : : */
4010 : 12 : int __kmem_cache_shrink(struct kmem_cache *s)
4011 : : {
4012 : 12 : int node;
4013 : 12 : int i;
4014 : 12 : struct kmem_cache_node *n;
4015 : 12 : struct page *page;
4016 : 12 : struct page *t;
4017 : 12 : struct list_head discard;
4018 : 12 : struct list_head promote[SHRINK_PROMOTE_MAX];
4019 : 12 : unsigned long flags;
4020 : 12 : int ret = 0;
4021 : :
4022 : 12 : flush_all(s);
4023 [ + - + + ]: 36 : for_each_kmem_cache_node(s, node, n) {
4024 : 12 : INIT_LIST_HEAD(&discard);
4025 [ + + ]: 396 : for (i = 0; i < SHRINK_PROMOTE_MAX; i++)
4026 : 384 : INIT_LIST_HEAD(promote + i);
4027 : :
4028 : 12 : spin_lock_irqsave(&n->list_lock, flags);
4029 : :
4030 : : /*
4031 : : * Build lists of slabs to discard or promote.
4032 : : *
4033 : : * Note that concurrent frees may occur while we hold the
4034 : : * list_lock. page->inuse here is the upper limit.
4035 : : */
4036 [ + + ]: 90 : list_for_each_entry_safe(page, t, &n->partial, slab_list) {
4037 : 78 : int free = page->objects - page->inuse;
4038 : :
4039 : : /* Do not reread page->inuse */
4040 : 78 : barrier();
4041 : :
4042 : : /* We do not keep full slabs on the list */
4043 [ - + ]: 78 : BUG_ON(free <= 0);
4044 : :
4045 [ + + ]: 78 : if (free == page->objects) {
4046 : 45 : list_move(&page->slab_list, &discard);
4047 : 45 : n->nr_partial--;
4048 [ + - ]: 33 : } else if (free <= SHRINK_PROMOTE_MAX)
4049 : 33 : list_move(&page->slab_list, promote + free - 1);
4050 : : }
4051 : :
4052 : : /*
4053 : : * Promote the slabs filled up most to the head of the
4054 : : * partial list.
4055 : : */
4056 [ + + ]: 396 : for (i = SHRINK_PROMOTE_MAX - 1; i >= 0; i--)
4057 [ + + ]: 384 : list_splice(promote + i, &n->partial);
4058 : :
4059 : 12 : spin_unlock_irqrestore(&n->list_lock, flags);
4060 : :
4061 : : /* Release empty slabs */
4062 [ + + ]: 57 : list_for_each_entry_safe(page, t, &discard, slab_list)
4063 : 45 : discard_slab(s, page);
4064 : :
4065 [ + + ]: 12 : if (slabs_node(s, node))
4066 : 3 : ret = 1;
4067 : : }
4068 : :
4069 : 12 : return ret;
4070 : : }
4071 : :
4072 : : #ifdef CONFIG_MEMCG
4073 : : void __kmemcg_cache_deactivate_after_rcu(struct kmem_cache *s)
4074 : : {
4075 : : /*
4076 : : * Called with all the locks held after a sched RCU grace period.
4077 : : * Even if @s becomes empty after shrinking, we can't know that @s
4078 : : * doesn't have allocations already in-flight and thus can't
4079 : : * destroy @s until the associated memcg is released.
4080 : : *
4081 : : * However, let's remove the sysfs files for empty caches here.
4082 : : * Each cache has a lot of interface files which aren't
4083 : : * particularly useful for empty draining caches; otherwise, we can
4084 : : * easily end up with millions of unnecessary sysfs files on
4085 : : * systems which have a lot of memory and transient cgroups.
4086 : : */
4087 : : if (!__kmem_cache_shrink(s))
4088 : : sysfs_slab_remove(s);
4089 : : }
4090 : :
4091 : : void __kmemcg_cache_deactivate(struct kmem_cache *s)
4092 : : {
4093 : : /*
4094 : : * Disable empty slabs caching. Used to avoid pinning offline
4095 : : * memory cgroups by kmem pages that can be freed.
4096 : : */
4097 : : slub_set_cpu_partial(s, 0);
4098 : : s->min_partial = 0;
4099 : : }
4100 : : #endif /* CONFIG_MEMCG */
4101 : :
4102 : : static int slab_mem_going_offline_callback(void *arg)
4103 : : {
4104 : : struct kmem_cache *s;
4105 : :
4106 : : mutex_lock(&slab_mutex);
4107 : : list_for_each_entry(s, &slab_caches, list)
4108 : : __kmem_cache_shrink(s);
4109 : : mutex_unlock(&slab_mutex);
4110 : :
4111 : : return 0;
4112 : : }
4113 : :
4114 : : static void slab_mem_offline_callback(void *arg)
4115 : : {
4116 : : struct kmem_cache_node *n;
4117 : : struct kmem_cache *s;
4118 : : struct memory_notify *marg = arg;
4119 : : int offline_node;
4120 : :
4121 : : offline_node = marg->status_change_nid_normal;
4122 : :
4123 : : /*
4124 : : * If the node still has available memory. we need kmem_cache_node
4125 : : * for it yet.
4126 : : */
4127 : : if (offline_node < 0)
4128 : : return;
4129 : :
4130 : : mutex_lock(&slab_mutex);
4131 : : list_for_each_entry(s, &slab_caches, list) {
4132 : : n = get_node(s, offline_node);
4133 : : if (n) {
4134 : : /*
4135 : : * if n->nr_slabs > 0, slabs still exist on the node
4136 : : * that is going down. We were unable to free them,
4137 : : * and offline_pages() function shouldn't call this
4138 : : * callback. So, we must fail.
4139 : : */
4140 : : BUG_ON(slabs_node(s, offline_node));
4141 : :
4142 : : s->node[offline_node] = NULL;
4143 : : kmem_cache_free(kmem_cache_node, n);
4144 : : }
4145 : : }
4146 : : mutex_unlock(&slab_mutex);
4147 : : }
4148 : :
4149 : : static int slab_mem_going_online_callback(void *arg)
4150 : : {
4151 : : struct kmem_cache_node *n;
4152 : : struct kmem_cache *s;
4153 : : struct memory_notify *marg = arg;
4154 : : int nid = marg->status_change_nid_normal;
4155 : : int ret = 0;
4156 : :
4157 : : /*
4158 : : * If the node's memory is already available, then kmem_cache_node is
4159 : : * already created. Nothing to do.
4160 : : */
4161 : : if (nid < 0)
4162 : : return 0;
4163 : :
4164 : : /*
4165 : : * We are bringing a node online. No memory is available yet. We must
4166 : : * allocate a kmem_cache_node structure in order to bring the node
4167 : : * online.
4168 : : */
4169 : : mutex_lock(&slab_mutex);
4170 : : list_for_each_entry(s, &slab_caches, list) {
4171 : : /*
4172 : : * XXX: kmem_cache_alloc_node will fallback to other nodes
4173 : : * since memory is not yet available from the node that
4174 : : * is brought up.
4175 : : */
4176 : : n = kmem_cache_alloc(kmem_cache_node, GFP_KERNEL);
4177 : : if (!n) {
4178 : : ret = -ENOMEM;
4179 : : goto out;
4180 : : }
4181 : : init_kmem_cache_node(n);
4182 : : s->node[nid] = n;
4183 : : }
4184 : : out:
4185 : : mutex_unlock(&slab_mutex);
4186 : : return ret;
4187 : : }
4188 : :
4189 : : static int slab_memory_callback(struct notifier_block *self,
4190 : : unsigned long action, void *arg)
4191 : : {
4192 : : int ret = 0;
4193 : :
4194 : : switch (action) {
4195 : : case MEM_GOING_ONLINE:
4196 : : ret = slab_mem_going_online_callback(arg);
4197 : : break;
4198 : : case MEM_GOING_OFFLINE:
4199 : : ret = slab_mem_going_offline_callback(arg);
4200 : : break;
4201 : : case MEM_OFFLINE:
4202 : : case MEM_CANCEL_ONLINE:
4203 : : slab_mem_offline_callback(arg);
4204 : : break;
4205 : : case MEM_ONLINE:
4206 : : case MEM_CANCEL_OFFLINE:
4207 : : break;
4208 : : }
4209 : : if (ret)
4210 : : ret = notifier_from_errno(ret);
4211 : : else
4212 : : ret = NOTIFY_OK;
4213 : : return ret;
4214 : : }
4215 : :
4216 : : static struct notifier_block slab_memory_callback_nb = {
4217 : : .notifier_call = slab_memory_callback,
4218 : : .priority = SLAB_CALLBACK_PRI,
4219 : : };
4220 : :
4221 : : /********************************************************************
4222 : : * Basic setup of slabs
4223 : : *******************************************************************/
4224 : :
4225 : : /*
4226 : : * Used for early kmem_cache structures that were allocated using
4227 : : * the page allocator. Allocate them properly then fix up the pointers
4228 : : * that may be pointing to the wrong kmem_cache structure.
4229 : : */
4230 : :
4231 : 6 : static struct kmem_cache * __init bootstrap(struct kmem_cache *static_cache)
4232 : : {
4233 : 6 : int node;
4234 : 6 : struct kmem_cache *s = kmem_cache_zalloc(kmem_cache, GFP_NOWAIT);
4235 : 6 : struct kmem_cache_node *n;
4236 : :
4237 : 6 : memcpy(s, static_cache, kmem_cache->object_size);
4238 : :
4239 : : /*
4240 : : * This runs very early, and only the boot processor is supposed to be
4241 : : * up. Even if it weren't true, IRQs are not up so we couldn't fire
4242 : : * IPIs around.
4243 : : */
4244 : 6 : __flush_cpu_slab(s, smp_processor_id());
4245 [ + - + + ]: 18 : for_each_kmem_cache_node(s, node, n) {
4246 : 6 : struct page *p;
4247 : :
4248 [ + + ]: 12 : list_for_each_entry(p, &n->partial, slab_list)
4249 : 6 : p->slab_cache = s;
4250 : :
4251 : : #ifdef CONFIG_SLUB_DEBUG
4252 [ - + ]: 6 : list_for_each_entry(p, &n->full, slab_list)
4253 : 0 : p->slab_cache = s;
4254 : : #endif
4255 : : }
4256 : 6 : slab_init_memcg_params(s);
4257 : 6 : list_add(&s->list, &slab_caches);
4258 : 6 : memcg_link_cache(s, NULL);
4259 : 6 : return s;
4260 : : }
4261 : :
4262 : 3 : void __init kmem_cache_init(void)
4263 : : {
4264 : 3 : static __initdata struct kmem_cache boot_kmem_cache,
4265 : : boot_kmem_cache_node;
4266 : :
4267 : 3 : if (debug_guardpage_minorder())
4268 : : slub_max_order = 0;
4269 : :
4270 : 3 : kmem_cache_node = &boot_kmem_cache_node;
4271 : 3 : kmem_cache = &boot_kmem_cache;
4272 : :
4273 : 3 : create_boot_cache(kmem_cache_node, "kmem_cache_node",
4274 : : sizeof(struct kmem_cache_node), SLAB_HWCACHE_ALIGN, 0, 0);
4275 : :
4276 : 3 : register_hotmemory_notifier(&slab_memory_callback_nb);
4277 : :
4278 : : /* Able to allocate the per node structures */
4279 : 3 : slab_state = PARTIAL;
4280 : :
4281 : 3 : create_boot_cache(kmem_cache, "kmem_cache",
4282 : : offsetof(struct kmem_cache, node) +
4283 : : nr_node_ids * sizeof(struct kmem_cache_node *),
4284 : : SLAB_HWCACHE_ALIGN, 0, 0);
4285 : :
4286 : 3 : kmem_cache = bootstrap(&boot_kmem_cache);
4287 : 3 : kmem_cache_node = bootstrap(&boot_kmem_cache_node);
4288 : :
4289 : : /* Now we can use the kmem_cache to allocate kmalloc slabs */
4290 : 3 : setup_kmalloc_cache_index_table();
4291 : 3 : create_kmalloc_caches(0);
4292 : :
4293 : : /* Setup random freelists for each cache */
4294 : 3 : init_freelist_randomization();
4295 : :
4296 : 3 : cpuhp_setup_state_nocalls(CPUHP_SLUB_DEAD, "slub:dead", NULL,
4297 : : slub_cpu_dead);
4298 : :
4299 : 3 : pr_info("SLUB: HWalign=%d, Order=%u-%u, MinObjects=%u, CPUs=%u, Nodes=%u\n",
4300 : : cache_line_size(),
4301 : : slub_min_order, slub_max_order, slub_min_objects,
4302 : : nr_cpu_ids, nr_node_ids);
4303 : 3 : }
4304 : :
4305 : 3 : void __init kmem_cache_init_late(void)
4306 : : {
4307 : 3 : }
4308 : :
4309 : : struct kmem_cache *
4310 : 501 : __kmem_cache_alias(const char *name, unsigned int size, unsigned int align,
4311 : : slab_flags_t flags, void (*ctor)(void *))
4312 : : {
4313 : 501 : struct kmem_cache *s, *c;
4314 : :
4315 : 501 : s = find_mergeable(size, align, flags, name, ctor);
4316 [ - + ]: 501 : if (s) {
4317 : 0 : s->refcount++;
4318 : :
4319 : : /*
4320 : : * Adjust the object sizes so that we clear
4321 : : * the complete object on kzalloc.
4322 : : */
4323 : 0 : s->object_size = max(s->object_size, size);
4324 : 0 : s->inuse = max(s->inuse, ALIGN(size, sizeof(void *)));
4325 : :
4326 : 0 : for_each_memcg_cache(c, s) {
4327 : : c->object_size = s->object_size;
4328 : : c->inuse = max(c->inuse, ALIGN(size, sizeof(void *)));
4329 : : }
4330 : :
4331 [ # # ]: 0 : if (sysfs_slab_alias(s, name)) {
4332 : 0 : s->refcount--;
4333 : 0 : s = NULL;
4334 : : }
4335 : : }
4336 : :
4337 : 501 : return s;
4338 : : }
4339 : :
4340 : 657 : int __kmem_cache_create(struct kmem_cache *s, slab_flags_t flags)
4341 : : {
4342 : 657 : int err;
4343 : :
4344 : 657 : err = kmem_cache_open(s, flags);
4345 [ + - ]: 657 : if (err)
4346 : : return err;
4347 : :
4348 : : /* Mutex is not taken during early boot */
4349 [ + + ]: 657 : if (slab_state <= UP)
4350 : : return 0;
4351 : :
4352 : 219 : memcg_propagate_slab_attrs(s);
4353 : 219 : err = sysfs_slab_add(s);
4354 [ - + ]: 219 : if (err)
4355 : 0 : __kmem_cache_release(s);
4356 : :
4357 : : return err;
4358 : : }
4359 : :
4360 : 43590 : void *__kmalloc_track_caller(size_t size, gfp_t gfpflags, unsigned long caller)
4361 : : {
4362 : 43590 : struct kmem_cache *s;
4363 : 43590 : void *ret;
4364 : :
4365 [ - + ]: 43590 : if (unlikely(size > KMALLOC_MAX_CACHE_SIZE))
4366 : 0 : return kmalloc_large(size, gfpflags);
4367 : :
4368 : 43590 : s = kmalloc_slab(size, gfpflags);
4369 : :
4370 [ + - ]: 43590 : if (unlikely(ZERO_OR_NULL_PTR(s)))
4371 : : return s;
4372 : :
4373 : 43590 : ret = slab_alloc(s, gfpflags, caller);
4374 : :
4375 : : /* Honor the call site pointer we received. */
4376 : 43590 : trace_kmalloc(caller, ret, size, s->size, gfpflags);
4377 : :
4378 : 43590 : return ret;
4379 : : }
4380 : :
4381 : : #ifdef CONFIG_NUMA
4382 : 8514 : void *__kmalloc_node_track_caller(size_t size, gfp_t gfpflags,
4383 : : int node, unsigned long caller)
4384 : : {
4385 : 8514 : struct kmem_cache *s;
4386 : 8514 : void *ret;
4387 : :
4388 [ - + ]: 8514 : if (unlikely(size > KMALLOC_MAX_CACHE_SIZE)) {
4389 : 0 : ret = kmalloc_large_node(size, gfpflags, node);
4390 : :
4391 : 0 : trace_kmalloc_node(caller, ret,
4392 : 0 : size, PAGE_SIZE << get_order(size),
4393 : : gfpflags, node);
4394 : :
4395 : 0 : return ret;
4396 : : }
4397 : :
4398 : 8514 : s = kmalloc_slab(size, gfpflags);
4399 : :
4400 [ + - ]: 8514 : if (unlikely(ZERO_OR_NULL_PTR(s)))
4401 : : return s;
4402 : :
4403 : 8514 : ret = slab_alloc_node(s, gfpflags, node, caller);
4404 : :
4405 : : /* Honor the call site pointer we received. */
4406 : 8514 : trace_kmalloc_node(caller, ret, size, s->size, gfpflags, node);
4407 : :
4408 : 8514 : return ret;
4409 : : }
4410 : : #endif
4411 : :
4412 : : #ifdef CONFIG_SYSFS
4413 : 0 : static int count_inuse(struct page *page)
4414 : : {
4415 : 0 : return page->inuse;
4416 : : }
4417 : :
4418 : 0 : static int count_total(struct page *page)
4419 : : {
4420 : 0 : return page->objects;
4421 : : }
4422 : : #endif
4423 : :
4424 : : #ifdef CONFIG_SLUB_DEBUG
4425 : 0 : static void validate_slab(struct kmem_cache *s, struct page *page)
4426 : : {
4427 : 0 : void *p;
4428 : 0 : void *addr = page_address(page);
4429 : 0 : unsigned long *map;
4430 : :
4431 : 0 : slab_lock(page);
4432 : :
4433 [ # # # # ]: 0 : if (!check_slab(s, page) || !on_freelist(s, page, NULL))
4434 : 0 : goto unlock;
4435 : :
4436 : : /* Now we know that a valid freelist exists */
4437 : 0 : map = get_map(s, page);
4438 [ # # # # ]: 0 : for_each_object(p, s, addr, page->objects) {
4439 [ # # # # ]: 0 : u8 val = test_bit(slab_index(p, s, addr), map) ?
4440 : : SLUB_RED_INACTIVE : SLUB_RED_ACTIVE;
4441 : :
4442 [ # # ]: 0 : if (!check_object(s, page, p, val))
4443 : : break;
4444 : : }
4445 : 0 : put_map(map);
4446 : 0 : unlock:
4447 : 0 : slab_unlock(page);
4448 : 0 : }
4449 : :
4450 : 0 : static int validate_slab_node(struct kmem_cache *s,
4451 : : struct kmem_cache_node *n)
4452 : : {
4453 : 0 : unsigned long count = 0;
4454 : 0 : struct page *page;
4455 : 0 : unsigned long flags;
4456 : :
4457 : 0 : spin_lock_irqsave(&n->list_lock, flags);
4458 : :
4459 [ # # ]: 0 : list_for_each_entry(page, &n->partial, slab_list) {
4460 : 0 : validate_slab(s, page);
4461 : 0 : count++;
4462 : : }
4463 [ # # ]: 0 : if (count != n->nr_partial)
4464 : 0 : pr_err("SLUB %s: %ld partial slabs counted but counter=%ld\n",
4465 : : s->name, count, n->nr_partial);
4466 : :
4467 [ # # ]: 0 : if (!(s->flags & SLAB_STORE_USER))
4468 : 0 : goto out;
4469 : :
4470 [ # # ]: 0 : list_for_each_entry(page, &n->full, slab_list) {
4471 : 0 : validate_slab(s, page);
4472 : 0 : count++;
4473 : : }
4474 [ # # ]: 0 : if (count != atomic_long_read(&n->nr_slabs))
4475 : 0 : pr_err("SLUB: %s %ld slabs counted but counter=%ld\n",
4476 : : s->name, count, atomic_long_read(&n->nr_slabs));
4477 : :
4478 : 0 : out:
4479 : 0 : spin_unlock_irqrestore(&n->list_lock, flags);
4480 : 0 : return count;
4481 : : }
4482 : :
4483 : 0 : static long validate_slab_cache(struct kmem_cache *s)
4484 : : {
4485 : 0 : int node;
4486 : 0 : unsigned long count = 0;
4487 : 0 : struct kmem_cache_node *n;
4488 : :
4489 : 0 : flush_all(s);
4490 [ # # # # ]: 0 : for_each_kmem_cache_node(s, node, n)
4491 : 0 : count += validate_slab_node(s, n);
4492 : :
4493 : 0 : return count;
4494 : : }
4495 : : /*
4496 : : * Generate lists of code addresses where slabcache objects are allocated
4497 : : * and freed.
4498 : : */
4499 : :
4500 : : struct location {
4501 : : unsigned long count;
4502 : : unsigned long addr;
4503 : : long long sum_time;
4504 : : long min_time;
4505 : : long max_time;
4506 : : long min_pid;
4507 : : long max_pid;
4508 : : DECLARE_BITMAP(cpus, NR_CPUS);
4509 : : nodemask_t nodes;
4510 : : };
4511 : :
4512 : : struct loc_track {
4513 : : unsigned long max;
4514 : : unsigned long count;
4515 : : struct location *loc;
4516 : : };
4517 : :
4518 : : static void free_loc_track(struct loc_track *t)
4519 : : {
4520 : : if (t->max)
4521 : : free_pages((unsigned long)t->loc,
4522 : : get_order(sizeof(struct location) * t->max));
4523 : : }
4524 : :
4525 : 0 : static int alloc_loc_track(struct loc_track *t, unsigned long max, gfp_t flags)
4526 : : {
4527 : 0 : struct location *l;
4528 : 0 : int order;
4529 : :
4530 : 0 : order = get_order(sizeof(struct location) * max);
4531 : :
4532 : 0 : l = (void *)__get_free_pages(flags, order);
4533 [ # # ]: 0 : if (!l)
4534 : : return 0;
4535 : :
4536 [ # # ]: 0 : if (t->count) {
4537 : 0 : memcpy(l, t->loc, sizeof(struct location) * t->count);
4538 : 0 : free_loc_track(t);
4539 : : }
4540 : 0 : t->max = max;
4541 : 0 : t->loc = l;
4542 : 0 : return 1;
4543 : : }
4544 : :
4545 : : static int add_location(struct loc_track *t, struct kmem_cache *s,
4546 : : const struct track *track)
4547 : : {
4548 : : long start, end, pos;
4549 : : struct location *l;
4550 : : unsigned long caddr;
4551 : : unsigned long age = jiffies - track->when;
4552 : :
4553 : : start = -1;
4554 : : end = t->count;
4555 : :
4556 : : for ( ; ; ) {
4557 : : pos = start + (end - start + 1) / 2;
4558 : :
4559 : : /*
4560 : : * There is nothing at "end". If we end up there
4561 : : * we need to add something to before end.
4562 : : */
4563 : : if (pos == end)
4564 : : break;
4565 : :
4566 : : caddr = t->loc[pos].addr;
4567 : : if (track->addr == caddr) {
4568 : :
4569 : : l = &t->loc[pos];
4570 : : l->count++;
4571 : : if (track->when) {
4572 : : l->sum_time += age;
4573 : : if (age < l->min_time)
4574 : : l->min_time = age;
4575 : : if (age > l->max_time)
4576 : : l->max_time = age;
4577 : :
4578 : : if (track->pid < l->min_pid)
4579 : : l->min_pid = track->pid;
4580 : : if (track->pid > l->max_pid)
4581 : : l->max_pid = track->pid;
4582 : :
4583 : : cpumask_set_cpu(track->cpu,
4584 : : to_cpumask(l->cpus));
4585 : : }
4586 : : node_set(page_to_nid(virt_to_page(track)), l->nodes);
4587 : : return 1;
4588 : : }
4589 : :
4590 : : if (track->addr < caddr)
4591 : : end = pos;
4592 : : else
4593 : : start = pos;
4594 : : }
4595 : :
4596 : : /*
4597 : : * Not found. Insert new tracking element.
4598 : : */
4599 : : if (t->count >= t->max && !alloc_loc_track(t, 2 * t->max, GFP_ATOMIC))
4600 : : return 0;
4601 : :
4602 : : l = t->loc + pos;
4603 : : if (pos < t->count)
4604 : : memmove(l + 1, l,
4605 : : (t->count - pos) * sizeof(struct location));
4606 : : t->count++;
4607 : : l->count = 1;
4608 : : l->addr = track->addr;
4609 : : l->sum_time = age;
4610 : : l->min_time = age;
4611 : : l->max_time = age;
4612 : : l->min_pid = track->pid;
4613 : : l->max_pid = track->pid;
4614 : : cpumask_clear(to_cpumask(l->cpus));
4615 : : cpumask_set_cpu(track->cpu, to_cpumask(l->cpus));
4616 : : nodes_clear(l->nodes);
4617 : : node_set(page_to_nid(virt_to_page(track)), l->nodes);
4618 : : return 1;
4619 : : }
4620 : :
4621 : 0 : static void process_slab(struct loc_track *t, struct kmem_cache *s,
4622 : : struct page *page, enum track_item alloc)
4623 : : {
4624 : 0 : void *addr = page_address(page);
4625 : 0 : void *p;
4626 : 0 : unsigned long *map;
4627 : :
4628 : 0 : map = get_map(s, page);
4629 [ # # # # ]: 0 : for_each_object(p, s, addr, page->objects)
4630 [ # # # # ]: 0 : if (!test_bit(slab_index(p, s, addr), map))
4631 [ # # ]: 0 : add_location(t, s, get_track(s, p, alloc));
4632 : 0 : put_map(map);
4633 : 0 : }
4634 : :
4635 : 0 : static int list_locations(struct kmem_cache *s, char *buf,
4636 : : enum track_item alloc)
4637 : : {
4638 : 0 : int len = 0;
4639 : 0 : unsigned long i;
4640 : 0 : struct loc_track t = { 0, 0, NULL };
4641 : 0 : int node;
4642 : 0 : struct kmem_cache_node *n;
4643 : :
4644 [ # # ]: 0 : if (!alloc_loc_track(&t, PAGE_SIZE / sizeof(struct location),
4645 : : GFP_KERNEL)) {
4646 : 0 : return sprintf(buf, "Out of memory\n");
4647 : : }
4648 : : /* Push back cpu slabs */
4649 : 0 : flush_all(s);
4650 : :
4651 [ # # # # ]: 0 : for_each_kmem_cache_node(s, node, n) {
4652 : 0 : unsigned long flags;
4653 : 0 : struct page *page;
4654 : :
4655 [ # # ]: 0 : if (!atomic_long_read(&n->nr_slabs))
4656 : 0 : continue;
4657 : :
4658 : 0 : spin_lock_irqsave(&n->list_lock, flags);
4659 [ # # ]: 0 : list_for_each_entry(page, &n->partial, slab_list)
4660 : 0 : process_slab(&t, s, page, alloc);
4661 [ # # ]: 0 : list_for_each_entry(page, &n->full, slab_list)
4662 : 0 : process_slab(&t, s, page, alloc);
4663 : 0 : spin_unlock_irqrestore(&n->list_lock, flags);
4664 : : }
4665 : :
4666 [ # # ]: 0 : for (i = 0; i < t.count; i++) {
4667 : 0 : struct location *l = &t.loc[i];
4668 : :
4669 [ # # ]: 0 : if (len > PAGE_SIZE - KSYM_SYMBOL_LEN - 100)
4670 : : break;
4671 : 0 : len += sprintf(buf + len, "%7ld ", l->count);
4672 : :
4673 [ # # ]: 0 : if (l->addr)
4674 : 0 : len += sprintf(buf + len, "%pS", (void *)l->addr);
4675 : : else
4676 : 0 : len += sprintf(buf + len, "<not-available>");
4677 : :
4678 [ # # ]: 0 : if (l->sum_time != l->min_time) {
4679 : 0 : len += sprintf(buf + len, " age=%ld/%ld/%ld",
4680 : : l->min_time,
4681 : 0 : (long)div_u64(l->sum_time, l->count),
4682 : : l->max_time);
4683 : : } else
4684 : 0 : len += sprintf(buf + len, " age=%ld",
4685 : : l->min_time);
4686 : :
4687 [ # # ]: 0 : if (l->min_pid != l->max_pid)
4688 : 0 : len += sprintf(buf + len, " pid=%ld-%ld",
4689 : : l->min_pid, l->max_pid);
4690 : : else
4691 : 0 : len += sprintf(buf + len, " pid=%ld",
4692 : : l->min_pid);
4693 : :
4694 [ # # # # ]: 0 : if (num_online_cpus() > 1 &&
4695 : 0 : !cpumask_empty(to_cpumask(l->cpus)) &&
4696 [ # # ]: 0 : len < PAGE_SIZE - 60)
4697 : 0 : len += scnprintf(buf + len, PAGE_SIZE - len - 50,
4698 : : " cpus=%*pbl",
4699 : 0 : cpumask_pr_args(to_cpumask(l->cpus)));
4700 : :
4701 [ # # # # ]: 0 : if (nr_online_nodes > 1 && !nodes_empty(l->nodes) &&
4702 [ # # ]: 0 : len < PAGE_SIZE - 60)
4703 : 0 : len += scnprintf(buf + len, PAGE_SIZE - len - 50,
4704 : : " nodes=%*pbl",
4705 [ # # ]: 0 : nodemask_pr_args(&l->nodes));
4706 : :
4707 : 0 : len += sprintf(buf + len, "\n");
4708 : : }
4709 : :
4710 : 0 : free_loc_track(&t);
4711 [ # # ]: 0 : if (!t.count)
4712 : 0 : len += sprintf(buf, "No data\n");
4713 : : return len;
4714 : : }
4715 : : #endif /* CONFIG_SLUB_DEBUG */
4716 : :
4717 : : #ifdef SLUB_RESILIENCY_TEST
4718 : : static void __init resiliency_test(void)
4719 : : {
4720 : : u8 *p;
4721 : : int type = KMALLOC_NORMAL;
4722 : :
4723 : : BUILD_BUG_ON(KMALLOC_MIN_SIZE > 16 || KMALLOC_SHIFT_HIGH < 10);
4724 : :
4725 : : pr_err("SLUB resiliency testing\n");
4726 : : pr_err("-----------------------\n");
4727 : : pr_err("A. Corruption after allocation\n");
4728 : :
4729 : : p = kzalloc(16, GFP_KERNEL);
4730 : : p[16] = 0x12;
4731 : : pr_err("\n1. kmalloc-16: Clobber Redzone/next pointer 0x12->0x%p\n\n",
4732 : : p + 16);
4733 : :
4734 : : validate_slab_cache(kmalloc_caches[type][4]);
4735 : :
4736 : : /* Hmmm... The next two are dangerous */
4737 : : p = kzalloc(32, GFP_KERNEL);
4738 : : p[32 + sizeof(void *)] = 0x34;
4739 : : pr_err("\n2. kmalloc-32: Clobber next pointer/next slab 0x34 -> -0x%p\n",
4740 : : p);
4741 : : pr_err("If allocated object is overwritten then not detectable\n\n");
4742 : :
4743 : : validate_slab_cache(kmalloc_caches[type][5]);
4744 : : p = kzalloc(64, GFP_KERNEL);
4745 : : p += 64 + (get_cycles() & 0xff) * sizeof(void *);
4746 : : *p = 0x56;
4747 : : pr_err("\n3. kmalloc-64: corrupting random byte 0x56->0x%p\n",
4748 : : p);
4749 : : pr_err("If allocated object is overwritten then not detectable\n\n");
4750 : : validate_slab_cache(kmalloc_caches[type][6]);
4751 : :
4752 : : pr_err("\nB. Corruption after free\n");
4753 : : p = kzalloc(128, GFP_KERNEL);
4754 : : kfree(p);
4755 : : *p = 0x78;
4756 : : pr_err("1. kmalloc-128: Clobber first word 0x78->0x%p\n\n", p);
4757 : : validate_slab_cache(kmalloc_caches[type][7]);
4758 : :
4759 : : p = kzalloc(256, GFP_KERNEL);
4760 : : kfree(p);
4761 : : p[50] = 0x9a;
4762 : : pr_err("\n2. kmalloc-256: Clobber 50th byte 0x9a->0x%p\n\n", p);
4763 : : validate_slab_cache(kmalloc_caches[type][8]);
4764 : :
4765 : : p = kzalloc(512, GFP_KERNEL);
4766 : : kfree(p);
4767 : : p[512] = 0xab;
4768 : : pr_err("\n3. kmalloc-512: Clobber redzone 0xab->0x%p\n\n", p);
4769 : : validate_slab_cache(kmalloc_caches[type][9]);
4770 : : }
4771 : : #else
4772 : : #ifdef CONFIG_SYSFS
4773 : 3 : static void resiliency_test(void) {};
4774 : : #endif
4775 : : #endif /* SLUB_RESILIENCY_TEST */
4776 : :
4777 : : #ifdef CONFIG_SYSFS
4778 : : enum slab_stat_type {
4779 : : SL_ALL, /* All slabs */
4780 : : SL_PARTIAL, /* Only partially allocated slabs */
4781 : : SL_CPU, /* Only slabs used for cpu caches */
4782 : : SL_OBJECTS, /* Determine allocated objects not slabs */
4783 : : SL_TOTAL /* Determine object capacity not slabs */
4784 : : };
4785 : :
4786 : : #define SO_ALL (1 << SL_ALL)
4787 : : #define SO_PARTIAL (1 << SL_PARTIAL)
4788 : : #define SO_CPU (1 << SL_CPU)
4789 : : #define SO_OBJECTS (1 << SL_OBJECTS)
4790 : : #define SO_TOTAL (1 << SL_TOTAL)
4791 : :
4792 : : #ifdef CONFIG_MEMCG
4793 : : static bool memcg_sysfs_enabled = IS_ENABLED(CONFIG_SLUB_MEMCG_SYSFS_ON);
4794 : :
4795 : : static int __init setup_slub_memcg_sysfs(char *str)
4796 : : {
4797 : : int v;
4798 : :
4799 : : if (get_option(&str, &v) > 0)
4800 : : memcg_sysfs_enabled = v;
4801 : :
4802 : : return 1;
4803 : : }
4804 : :
4805 : : __setup("slub_memcg_sysfs=", setup_slub_memcg_sysfs);
4806 : : #endif
4807 : :
4808 : 0 : static ssize_t show_slab_objects(struct kmem_cache *s,
4809 : : char *buf, unsigned long flags)
4810 : : {
4811 : 0 : unsigned long total = 0;
4812 : 0 : int node;
4813 : 0 : int x;
4814 : 0 : unsigned long *nodes;
4815 : :
4816 : 0 : nodes = kcalloc(nr_node_ids, sizeof(unsigned long), GFP_KERNEL);
4817 [ # # ]: 0 : if (!nodes)
4818 : : return -ENOMEM;
4819 : :
4820 [ # # ]: 0 : if (flags & SO_CPU) {
4821 : : int cpu;
4822 : :
4823 [ # # ]: 0 : for_each_possible_cpu(cpu) {
4824 : 0 : struct kmem_cache_cpu *c = per_cpu_ptr(s->cpu_slab,
4825 : : cpu);
4826 : 0 : int node;
4827 : 0 : struct page *page;
4828 : :
4829 [ # # ]: 0 : page = READ_ONCE(c->page);
4830 [ # # ]: 0 : if (!page)
4831 : 0 : continue;
4832 : :
4833 [ # # ]: 0 : node = page_to_nid(page);
4834 [ # # ]: 0 : if (flags & SO_TOTAL)
4835 : 0 : x = page->objects;
4836 [ # # ]: 0 : else if (flags & SO_OBJECTS)
4837 : 0 : x = page->inuse;
4838 : : else
4839 : : x = 1;
4840 : :
4841 : 0 : total += x;
4842 : 0 : nodes[node] += x;
4843 : :
4844 [ # # ]: 0 : page = slub_percpu_partial_read_once(c);
4845 [ # # ]: 0 : if (page) {
4846 [ # # ]: 0 : node = page_to_nid(page);
4847 [ # # ]: 0 : if (flags & SO_TOTAL)
4848 : 0 : WARN_ON_ONCE(1);
4849 [ # # ]: 0 : else if (flags & SO_OBJECTS)
4850 : 0 : WARN_ON_ONCE(1);
4851 : : else
4852 : 0 : x = page->pages;
4853 : 0 : total += x;
4854 : 0 : nodes[node] += x;
4855 : : }
4856 : : }
4857 : : }
4858 : :
4859 : : /*
4860 : : * It is impossible to take "mem_hotplug_lock" here with "kernfs_mutex"
4861 : : * already held which will conflict with an existing lock order:
4862 : : *
4863 : : * mem_hotplug_lock->slab_mutex->kernfs_mutex
4864 : : *
4865 : : * We don't really need mem_hotplug_lock (to hold off
4866 : : * slab_mem_going_offline_callback) here because slab's memory hot
4867 : : * unplug code doesn't destroy the kmem_cache->node[] data.
4868 : : */
4869 : :
4870 : : #ifdef CONFIG_SLUB_DEBUG
4871 [ # # ]: 0 : if (flags & SO_ALL) {
4872 : : struct kmem_cache_node *n;
4873 : :
4874 [ # # # # ]: 0 : for_each_kmem_cache_node(s, node, n) {
4875 : :
4876 [ # # ]: 0 : if (flags & SO_TOTAL)
4877 : 0 : x = atomic_long_read(&n->total_objects);
4878 [ # # ]: 0 : else if (flags & SO_OBJECTS)
4879 : 0 : x = atomic_long_read(&n->total_objects) -
4880 : 0 : count_partial(n, count_free);
4881 : : else
4882 : 0 : x = atomic_long_read(&n->nr_slabs);
4883 : 0 : total += x;
4884 : 0 : nodes[node] += x;
4885 : : }
4886 : :
4887 : : } else
4888 : : #endif
4889 [ # # ]: 0 : if (flags & SO_PARTIAL) {
4890 : : struct kmem_cache_node *n;
4891 : :
4892 [ # # # # ]: 0 : for_each_kmem_cache_node(s, node, n) {
4893 [ # # ]: 0 : if (flags & SO_TOTAL)
4894 : 0 : x = count_partial(n, count_total);
4895 [ # # ]: 0 : else if (flags & SO_OBJECTS)
4896 : 0 : x = count_partial(n, count_inuse);
4897 : : else
4898 : 0 : x = n->nr_partial;
4899 : 0 : total += x;
4900 : 0 : nodes[node] += x;
4901 : : }
4902 : : }
4903 : 0 : x = sprintf(buf, "%lu", total);
4904 : : #ifdef CONFIG_NUMA
4905 [ # # ]: 0 : for (node = 0; node < nr_node_ids; node++)
4906 [ # # ]: 0 : if (nodes[node])
4907 : 0 : x += sprintf(buf + x, " N%d=%lu",
4908 : : node, nodes[node]);
4909 : : #endif
4910 : 0 : kfree(nodes);
4911 : 0 : return x + sprintf(buf + x, "\n");
4912 : : }
4913 : :
4914 : : #ifdef CONFIG_SLUB_DEBUG
4915 : 0 : static int any_slab_objects(struct kmem_cache *s)
4916 : : {
4917 : 0 : int node;
4918 : 0 : struct kmem_cache_node *n;
4919 : :
4920 [ # # # # : 0 : for_each_kmem_cache_node(s, node, n)
# # # # #
# # # ]
4921 [ # # # # : 0 : if (atomic_long_read(&n->total_objects))
# # ]
4922 : : return 1;
4923 : :
4924 : : return 0;
4925 : : }
4926 : : #endif
4927 : :
4928 : : #define to_slab_attr(n) container_of(n, struct slab_attribute, attr)
4929 : : #define to_slab(n) container_of(n, struct kmem_cache, kobj)
4930 : :
4931 : : struct slab_attribute {
4932 : : struct attribute attr;
4933 : : ssize_t (*show)(struct kmem_cache *s, char *buf);
4934 : : ssize_t (*store)(struct kmem_cache *s, const char *x, size_t count);
4935 : : };
4936 : :
4937 : : #define SLAB_ATTR_RO(_name) \
4938 : : static struct slab_attribute _name##_attr = \
4939 : : __ATTR(_name, 0400, _name##_show, NULL)
4940 : :
4941 : : #define SLAB_ATTR(_name) \
4942 : : static struct slab_attribute _name##_attr = \
4943 : : __ATTR(_name, 0600, _name##_show, _name##_store)
4944 : :
4945 : 0 : static ssize_t slab_size_show(struct kmem_cache *s, char *buf)
4946 : : {
4947 : 0 : return sprintf(buf, "%u\n", s->size);
4948 : : }
4949 : : SLAB_ATTR_RO(slab_size);
4950 : :
4951 : 0 : static ssize_t align_show(struct kmem_cache *s, char *buf)
4952 : : {
4953 : 0 : return sprintf(buf, "%u\n", s->align);
4954 : : }
4955 : : SLAB_ATTR_RO(align);
4956 : :
4957 : 0 : static ssize_t object_size_show(struct kmem_cache *s, char *buf)
4958 : : {
4959 : 0 : return sprintf(buf, "%u\n", s->object_size);
4960 : : }
4961 : : SLAB_ATTR_RO(object_size);
4962 : :
4963 : 0 : static ssize_t objs_per_slab_show(struct kmem_cache *s, char *buf)
4964 : : {
4965 : 0 : return sprintf(buf, "%u\n", oo_objects(s->oo));
4966 : : }
4967 : : SLAB_ATTR_RO(objs_per_slab);
4968 : :
4969 : 0 : static ssize_t order_store(struct kmem_cache *s,
4970 : : const char *buf, size_t length)
4971 : : {
4972 : 0 : unsigned int order;
4973 : 0 : int err;
4974 : :
4975 : 0 : err = kstrtouint(buf, 10, &order);
4976 [ # # ]: 0 : if (err)
4977 : 0 : return err;
4978 : :
4979 [ # # # # ]: 0 : if (order > slub_max_order || order < slub_min_order)
4980 : : return -EINVAL;
4981 : :
4982 : 0 : calculate_sizes(s, order);
4983 : 0 : return length;
4984 : : }
4985 : :
4986 : 0 : static ssize_t order_show(struct kmem_cache *s, char *buf)
4987 : : {
4988 : 0 : return sprintf(buf, "%u\n", oo_order(s->oo));
4989 : : }
4990 : : SLAB_ATTR(order);
4991 : :
4992 : 0 : static ssize_t min_partial_show(struct kmem_cache *s, char *buf)
4993 : : {
4994 : 0 : return sprintf(buf, "%lu\n", s->min_partial);
4995 : : }
4996 : :
4997 : 0 : static ssize_t min_partial_store(struct kmem_cache *s, const char *buf,
4998 : : size_t length)
4999 : : {
5000 : 0 : unsigned long min;
5001 : 0 : int err;
5002 : :
5003 : 0 : err = kstrtoul(buf, 10, &min);
5004 [ # # ]: 0 : if (err)
5005 : 0 : return err;
5006 : :
5007 : 0 : set_min_partial(s, min);
5008 : 0 : return length;
5009 : : }
5010 : : SLAB_ATTR(min_partial);
5011 : :
5012 : 0 : static ssize_t cpu_partial_show(struct kmem_cache *s, char *buf)
5013 : : {
5014 : 0 : return sprintf(buf, "%u\n", slub_cpu_partial(s));
5015 : : }
5016 : :
5017 : 0 : static ssize_t cpu_partial_store(struct kmem_cache *s, const char *buf,
5018 : : size_t length)
5019 : : {
5020 : 0 : unsigned int objects;
5021 : 0 : int err;
5022 : :
5023 : 0 : err = kstrtouint(buf, 10, &objects);
5024 [ # # ]: 0 : if (err)
5025 : 0 : return err;
5026 [ # # # # ]: 0 : if (objects && !kmem_cache_has_cpu_partial(s))
5027 : : return -EINVAL;
5028 : :
5029 : 0 : slub_set_cpu_partial(s, objects);
5030 : 0 : flush_all(s);
5031 : 0 : return length;
5032 : : }
5033 : : SLAB_ATTR(cpu_partial);
5034 : :
5035 : 0 : static ssize_t ctor_show(struct kmem_cache *s, char *buf)
5036 : : {
5037 [ # # ]: 0 : if (!s->ctor)
5038 : : return 0;
5039 : 0 : return sprintf(buf, "%pS\n", s->ctor);
5040 : : }
5041 : : SLAB_ATTR_RO(ctor);
5042 : :
5043 : 0 : static ssize_t aliases_show(struct kmem_cache *s, char *buf)
5044 : : {
5045 [ # # ]: 0 : return sprintf(buf, "%d\n", s->refcount < 0 ? 0 : s->refcount - 1);
5046 : : }
5047 : : SLAB_ATTR_RO(aliases);
5048 : :
5049 : 0 : static ssize_t partial_show(struct kmem_cache *s, char *buf)
5050 : : {
5051 : 0 : return show_slab_objects(s, buf, SO_PARTIAL);
5052 : : }
5053 : : SLAB_ATTR_RO(partial);
5054 : :
5055 : 0 : static ssize_t cpu_slabs_show(struct kmem_cache *s, char *buf)
5056 : : {
5057 : 0 : return show_slab_objects(s, buf, SO_CPU);
5058 : : }
5059 : : SLAB_ATTR_RO(cpu_slabs);
5060 : :
5061 : 0 : static ssize_t objects_show(struct kmem_cache *s, char *buf)
5062 : : {
5063 : 0 : return show_slab_objects(s, buf, SO_ALL|SO_OBJECTS);
5064 : : }
5065 : : SLAB_ATTR_RO(objects);
5066 : :
5067 : 0 : static ssize_t objects_partial_show(struct kmem_cache *s, char *buf)
5068 : : {
5069 : 0 : return show_slab_objects(s, buf, SO_PARTIAL|SO_OBJECTS);
5070 : : }
5071 : : SLAB_ATTR_RO(objects_partial);
5072 : :
5073 : 0 : static ssize_t slabs_cpu_partial_show(struct kmem_cache *s, char *buf)
5074 : : {
5075 : 0 : int objects = 0;
5076 : 0 : int pages = 0;
5077 : 0 : int cpu;
5078 : 0 : int len;
5079 : :
5080 [ # # ]: 0 : for_each_online_cpu(cpu) {
5081 : 0 : struct page *page;
5082 : :
5083 : 0 : page = slub_percpu_partial(per_cpu_ptr(s->cpu_slab, cpu));
5084 : :
5085 [ # # ]: 0 : if (page) {
5086 : 0 : pages += page->pages;
5087 : 0 : objects += page->pobjects;
5088 : : }
5089 : : }
5090 : :
5091 : 0 : len = sprintf(buf, "%d(%d)", objects, pages);
5092 : :
5093 : : #ifdef CONFIG_SMP
5094 [ # # ]: 0 : for_each_online_cpu(cpu) {
5095 : 0 : struct page *page;
5096 : :
5097 : 0 : page = slub_percpu_partial(per_cpu_ptr(s->cpu_slab, cpu));
5098 : :
5099 [ # # ]: 0 : if (page && len < PAGE_SIZE - 20)
5100 : 0 : len += sprintf(buf + len, " C%d=%d(%d)", cpu,
5101 : : page->pobjects, page->pages);
5102 : : }
5103 : : #endif
5104 : 0 : return len + sprintf(buf + len, "\n");
5105 : : }
5106 : : SLAB_ATTR_RO(slabs_cpu_partial);
5107 : :
5108 : 0 : static ssize_t reclaim_account_show(struct kmem_cache *s, char *buf)
5109 : : {
5110 : 0 : return sprintf(buf, "%d\n", !!(s->flags & SLAB_RECLAIM_ACCOUNT));
5111 : : }
5112 : :
5113 : 0 : static ssize_t reclaim_account_store(struct kmem_cache *s,
5114 : : const char *buf, size_t length)
5115 : : {
5116 : 0 : s->flags &= ~SLAB_RECLAIM_ACCOUNT;
5117 [ # # ]: 0 : if (buf[0] == '1')
5118 : 0 : s->flags |= SLAB_RECLAIM_ACCOUNT;
5119 : 0 : return length;
5120 : : }
5121 : : SLAB_ATTR(reclaim_account);
5122 : :
5123 : 0 : static ssize_t hwcache_align_show(struct kmem_cache *s, char *buf)
5124 : : {
5125 : 0 : return sprintf(buf, "%d\n", !!(s->flags & SLAB_HWCACHE_ALIGN));
5126 : : }
5127 : : SLAB_ATTR_RO(hwcache_align);
5128 : :
5129 : : #ifdef CONFIG_ZONE_DMA
5130 : 0 : static ssize_t cache_dma_show(struct kmem_cache *s, char *buf)
5131 : : {
5132 : 0 : return sprintf(buf, "%d\n", !!(s->flags & SLAB_CACHE_DMA));
5133 : : }
5134 : : SLAB_ATTR_RO(cache_dma);
5135 : : #endif
5136 : :
5137 : 0 : static ssize_t usersize_show(struct kmem_cache *s, char *buf)
5138 : : {
5139 : 0 : return sprintf(buf, "%u\n", s->usersize);
5140 : : }
5141 : : SLAB_ATTR_RO(usersize);
5142 : :
5143 : 0 : static ssize_t destroy_by_rcu_show(struct kmem_cache *s, char *buf)
5144 : : {
5145 : 0 : return sprintf(buf, "%d\n", !!(s->flags & SLAB_TYPESAFE_BY_RCU));
5146 : : }
5147 : : SLAB_ATTR_RO(destroy_by_rcu);
5148 : :
5149 : : #ifdef CONFIG_SLUB_DEBUG
5150 : 0 : static ssize_t slabs_show(struct kmem_cache *s, char *buf)
5151 : : {
5152 : 0 : return show_slab_objects(s, buf, SO_ALL);
5153 : : }
5154 : : SLAB_ATTR_RO(slabs);
5155 : :
5156 : 0 : static ssize_t total_objects_show(struct kmem_cache *s, char *buf)
5157 : : {
5158 : 0 : return show_slab_objects(s, buf, SO_ALL|SO_TOTAL);
5159 : : }
5160 : : SLAB_ATTR_RO(total_objects);
5161 : :
5162 : 0 : static ssize_t sanity_checks_show(struct kmem_cache *s, char *buf)
5163 : : {
5164 : 0 : return sprintf(buf, "%d\n", !!(s->flags & SLAB_CONSISTENCY_CHECKS));
5165 : : }
5166 : :
5167 : 0 : static ssize_t sanity_checks_store(struct kmem_cache *s,
5168 : : const char *buf, size_t length)
5169 : : {
5170 : 0 : s->flags &= ~SLAB_CONSISTENCY_CHECKS;
5171 [ # # ]: 0 : if (buf[0] == '1') {
5172 : 0 : s->flags &= ~__CMPXCHG_DOUBLE;
5173 : 0 : s->flags |= SLAB_CONSISTENCY_CHECKS;
5174 : : }
5175 : 0 : return length;
5176 : : }
5177 : : SLAB_ATTR(sanity_checks);
5178 : :
5179 : 0 : static ssize_t trace_show(struct kmem_cache *s, char *buf)
5180 : : {
5181 : 0 : return sprintf(buf, "%d\n", !!(s->flags & SLAB_TRACE));
5182 : : }
5183 : :
5184 : 0 : static ssize_t trace_store(struct kmem_cache *s, const char *buf,
5185 : : size_t length)
5186 : : {
5187 : : /*
5188 : : * Tracing a merged cache is going to give confusing results
5189 : : * as well as cause other issues like converting a mergeable
5190 : : * cache into an umergeable one.
5191 : : */
5192 [ # # ]: 0 : if (s->refcount > 1)
5193 : : return -EINVAL;
5194 : :
5195 : 0 : s->flags &= ~SLAB_TRACE;
5196 [ # # ]: 0 : if (buf[0] == '1') {
5197 : 0 : s->flags &= ~__CMPXCHG_DOUBLE;
5198 : 0 : s->flags |= SLAB_TRACE;
5199 : : }
5200 : 0 : return length;
5201 : : }
5202 : : SLAB_ATTR(trace);
5203 : :
5204 : 0 : static ssize_t red_zone_show(struct kmem_cache *s, char *buf)
5205 : : {
5206 : 0 : return sprintf(buf, "%d\n", !!(s->flags & SLAB_RED_ZONE));
5207 : : }
5208 : :
5209 : 0 : static ssize_t red_zone_store(struct kmem_cache *s,
5210 : : const char *buf, size_t length)
5211 : : {
5212 [ # # ]: 0 : if (any_slab_objects(s))
5213 : : return -EBUSY;
5214 : :
5215 : 0 : s->flags &= ~SLAB_RED_ZONE;
5216 [ # # ]: 0 : if (buf[0] == '1') {
5217 : 0 : s->flags |= SLAB_RED_ZONE;
5218 : : }
5219 : 0 : calculate_sizes(s, -1);
5220 : 0 : return length;
5221 : : }
5222 : : SLAB_ATTR(red_zone);
5223 : :
5224 : 0 : static ssize_t poison_show(struct kmem_cache *s, char *buf)
5225 : : {
5226 : 0 : return sprintf(buf, "%d\n", !!(s->flags & SLAB_POISON));
5227 : : }
5228 : :
5229 : 0 : static ssize_t poison_store(struct kmem_cache *s,
5230 : : const char *buf, size_t length)
5231 : : {
5232 [ # # ]: 0 : if (any_slab_objects(s))
5233 : : return -EBUSY;
5234 : :
5235 : 0 : s->flags &= ~SLAB_POISON;
5236 [ # # ]: 0 : if (buf[0] == '1') {
5237 : 0 : s->flags |= SLAB_POISON;
5238 : : }
5239 : 0 : calculate_sizes(s, -1);
5240 : 0 : return length;
5241 : : }
5242 : : SLAB_ATTR(poison);
5243 : :
5244 : 0 : static ssize_t store_user_show(struct kmem_cache *s, char *buf)
5245 : : {
5246 : 0 : return sprintf(buf, "%d\n", !!(s->flags & SLAB_STORE_USER));
5247 : : }
5248 : :
5249 : 0 : static ssize_t store_user_store(struct kmem_cache *s,
5250 : : const char *buf, size_t length)
5251 : : {
5252 [ # # ]: 0 : if (any_slab_objects(s))
5253 : : return -EBUSY;
5254 : :
5255 : 0 : s->flags &= ~SLAB_STORE_USER;
5256 [ # # ]: 0 : if (buf[0] == '1') {
5257 : 0 : s->flags &= ~__CMPXCHG_DOUBLE;
5258 : 0 : s->flags |= SLAB_STORE_USER;
5259 : : }
5260 : 0 : calculate_sizes(s, -1);
5261 : 0 : return length;
5262 : : }
5263 : : SLAB_ATTR(store_user);
5264 : :
5265 : 0 : static ssize_t validate_show(struct kmem_cache *s, char *buf)
5266 : : {
5267 : 0 : return 0;
5268 : : }
5269 : :
5270 : 0 : static ssize_t validate_store(struct kmem_cache *s,
5271 : : const char *buf, size_t length)
5272 : : {
5273 : 0 : int ret = -EINVAL;
5274 : :
5275 [ # # ]: 0 : if (buf[0] == '1') {
5276 : 0 : ret = validate_slab_cache(s);
5277 [ # # ]: 0 : if (ret >= 0)
5278 : 0 : ret = length;
5279 : : }
5280 : 0 : return ret;
5281 : : }
5282 : : SLAB_ATTR(validate);
5283 : :
5284 : 0 : static ssize_t alloc_calls_show(struct kmem_cache *s, char *buf)
5285 : : {
5286 [ # # ]: 0 : if (!(s->flags & SLAB_STORE_USER))
5287 : : return -ENOSYS;
5288 : 0 : return list_locations(s, buf, TRACK_ALLOC);
5289 : : }
5290 : : SLAB_ATTR_RO(alloc_calls);
5291 : :
5292 : 0 : static ssize_t free_calls_show(struct kmem_cache *s, char *buf)
5293 : : {
5294 [ # # ]: 0 : if (!(s->flags & SLAB_STORE_USER))
5295 : : return -ENOSYS;
5296 : 0 : return list_locations(s, buf, TRACK_FREE);
5297 : : }
5298 : : SLAB_ATTR_RO(free_calls);
5299 : : #endif /* CONFIG_SLUB_DEBUG */
5300 : :
5301 : : #ifdef CONFIG_FAILSLAB
5302 : : static ssize_t failslab_show(struct kmem_cache *s, char *buf)
5303 : : {
5304 : : return sprintf(buf, "%d\n", !!(s->flags & SLAB_FAILSLAB));
5305 : : }
5306 : :
5307 : : static ssize_t failslab_store(struct kmem_cache *s, const char *buf,
5308 : : size_t length)
5309 : : {
5310 : : if (s->refcount > 1)
5311 : : return -EINVAL;
5312 : :
5313 : : s->flags &= ~SLAB_FAILSLAB;
5314 : : if (buf[0] == '1')
5315 : : s->flags |= SLAB_FAILSLAB;
5316 : : return length;
5317 : : }
5318 : : SLAB_ATTR(failslab);
5319 : : #endif
5320 : :
5321 : 0 : static ssize_t shrink_show(struct kmem_cache *s, char *buf)
5322 : : {
5323 : 0 : return 0;
5324 : : }
5325 : :
5326 : 0 : static ssize_t shrink_store(struct kmem_cache *s,
5327 : : const char *buf, size_t length)
5328 : : {
5329 [ # # ]: 0 : if (buf[0] == '1')
5330 : 0 : kmem_cache_shrink_all(s);
5331 : : else
5332 : : return -EINVAL;
5333 : 0 : return length;
5334 : : }
5335 : : SLAB_ATTR(shrink);
5336 : :
5337 : : #ifdef CONFIG_NUMA
5338 : 0 : static ssize_t remote_node_defrag_ratio_show(struct kmem_cache *s, char *buf)
5339 : : {
5340 : 0 : return sprintf(buf, "%u\n", s->remote_node_defrag_ratio / 10);
5341 : : }
5342 : :
5343 : 0 : static ssize_t remote_node_defrag_ratio_store(struct kmem_cache *s,
5344 : : const char *buf, size_t length)
5345 : : {
5346 : 0 : unsigned int ratio;
5347 : 0 : int err;
5348 : :
5349 : 0 : err = kstrtouint(buf, 10, &ratio);
5350 [ # # ]: 0 : if (err)
5351 : 0 : return err;
5352 [ # # ]: 0 : if (ratio > 100)
5353 : : return -ERANGE;
5354 : :
5355 : 0 : s->remote_node_defrag_ratio = ratio * 10;
5356 : :
5357 : 0 : return length;
5358 : : }
5359 : : SLAB_ATTR(remote_node_defrag_ratio);
5360 : : #endif
5361 : :
5362 : : #ifdef CONFIG_SLUB_STATS
5363 : : static int show_stat(struct kmem_cache *s, char *buf, enum stat_item si)
5364 : : {
5365 : : unsigned long sum = 0;
5366 : : int cpu;
5367 : : int len;
5368 : : int *data = kmalloc_array(nr_cpu_ids, sizeof(int), GFP_KERNEL);
5369 : :
5370 : : if (!data)
5371 : : return -ENOMEM;
5372 : :
5373 : : for_each_online_cpu(cpu) {
5374 : : unsigned x = per_cpu_ptr(s->cpu_slab, cpu)->stat[si];
5375 : :
5376 : : data[cpu] = x;
5377 : : sum += x;
5378 : : }
5379 : :
5380 : : len = sprintf(buf, "%lu", sum);
5381 : :
5382 : : #ifdef CONFIG_SMP
5383 : : for_each_online_cpu(cpu) {
5384 : : if (data[cpu] && len < PAGE_SIZE - 20)
5385 : : len += sprintf(buf + len, " C%d=%u", cpu, data[cpu]);
5386 : : }
5387 : : #endif
5388 : : kfree(data);
5389 : : return len + sprintf(buf + len, "\n");
5390 : : }
5391 : :
5392 : : static void clear_stat(struct kmem_cache *s, enum stat_item si)
5393 : : {
5394 : : int cpu;
5395 : :
5396 : : for_each_online_cpu(cpu)
5397 : : per_cpu_ptr(s->cpu_slab, cpu)->stat[si] = 0;
5398 : : }
5399 : :
5400 : : #define STAT_ATTR(si, text) \
5401 : : static ssize_t text##_show(struct kmem_cache *s, char *buf) \
5402 : : { \
5403 : : return show_stat(s, buf, si); \
5404 : : } \
5405 : : static ssize_t text##_store(struct kmem_cache *s, \
5406 : : const char *buf, size_t length) \
5407 : : { \
5408 : : if (buf[0] != '0') \
5409 : : return -EINVAL; \
5410 : : clear_stat(s, si); \
5411 : : return length; \
5412 : : } \
5413 : : SLAB_ATTR(text); \
5414 : :
5415 : : STAT_ATTR(ALLOC_FASTPATH, alloc_fastpath);
5416 : : STAT_ATTR(ALLOC_SLOWPATH, alloc_slowpath);
5417 : : STAT_ATTR(FREE_FASTPATH, free_fastpath);
5418 : : STAT_ATTR(FREE_SLOWPATH, free_slowpath);
5419 : : STAT_ATTR(FREE_FROZEN, free_frozen);
5420 : : STAT_ATTR(FREE_ADD_PARTIAL, free_add_partial);
5421 : : STAT_ATTR(FREE_REMOVE_PARTIAL, free_remove_partial);
5422 : : STAT_ATTR(ALLOC_FROM_PARTIAL, alloc_from_partial);
5423 : : STAT_ATTR(ALLOC_SLAB, alloc_slab);
5424 : : STAT_ATTR(ALLOC_REFILL, alloc_refill);
5425 : : STAT_ATTR(ALLOC_NODE_MISMATCH, alloc_node_mismatch);
5426 : : STAT_ATTR(FREE_SLAB, free_slab);
5427 : : STAT_ATTR(CPUSLAB_FLUSH, cpuslab_flush);
5428 : : STAT_ATTR(DEACTIVATE_FULL, deactivate_full);
5429 : : STAT_ATTR(DEACTIVATE_EMPTY, deactivate_empty);
5430 : : STAT_ATTR(DEACTIVATE_TO_HEAD, deactivate_to_head);
5431 : : STAT_ATTR(DEACTIVATE_TO_TAIL, deactivate_to_tail);
5432 : : STAT_ATTR(DEACTIVATE_REMOTE_FREES, deactivate_remote_frees);
5433 : : STAT_ATTR(DEACTIVATE_BYPASS, deactivate_bypass);
5434 : : STAT_ATTR(ORDER_FALLBACK, order_fallback);
5435 : : STAT_ATTR(CMPXCHG_DOUBLE_CPU_FAIL, cmpxchg_double_cpu_fail);
5436 : : STAT_ATTR(CMPXCHG_DOUBLE_FAIL, cmpxchg_double_fail);
5437 : : STAT_ATTR(CPU_PARTIAL_ALLOC, cpu_partial_alloc);
5438 : : STAT_ATTR(CPU_PARTIAL_FREE, cpu_partial_free);
5439 : : STAT_ATTR(CPU_PARTIAL_NODE, cpu_partial_node);
5440 : : STAT_ATTR(CPU_PARTIAL_DRAIN, cpu_partial_drain);
5441 : : #endif /* CONFIG_SLUB_STATS */
5442 : :
5443 : : static struct attribute *slab_attrs[] = {
5444 : : &slab_size_attr.attr,
5445 : : &object_size_attr.attr,
5446 : : &objs_per_slab_attr.attr,
5447 : : &order_attr.attr,
5448 : : &min_partial_attr.attr,
5449 : : &cpu_partial_attr.attr,
5450 : : &objects_attr.attr,
5451 : : &objects_partial_attr.attr,
5452 : : &partial_attr.attr,
5453 : : &cpu_slabs_attr.attr,
5454 : : &ctor_attr.attr,
5455 : : &aliases_attr.attr,
5456 : : &align_attr.attr,
5457 : : &hwcache_align_attr.attr,
5458 : : &reclaim_account_attr.attr,
5459 : : &destroy_by_rcu_attr.attr,
5460 : : &shrink_attr.attr,
5461 : : &slabs_cpu_partial_attr.attr,
5462 : : #ifdef CONFIG_SLUB_DEBUG
5463 : : &total_objects_attr.attr,
5464 : : &slabs_attr.attr,
5465 : : &sanity_checks_attr.attr,
5466 : : &trace_attr.attr,
5467 : : &red_zone_attr.attr,
5468 : : &poison_attr.attr,
5469 : : &store_user_attr.attr,
5470 : : &validate_attr.attr,
5471 : : &alloc_calls_attr.attr,
5472 : : &free_calls_attr.attr,
5473 : : #endif
5474 : : #ifdef CONFIG_ZONE_DMA
5475 : : &cache_dma_attr.attr,
5476 : : #endif
5477 : : #ifdef CONFIG_NUMA
5478 : : &remote_node_defrag_ratio_attr.attr,
5479 : : #endif
5480 : : #ifdef CONFIG_SLUB_STATS
5481 : : &alloc_fastpath_attr.attr,
5482 : : &alloc_slowpath_attr.attr,
5483 : : &free_fastpath_attr.attr,
5484 : : &free_slowpath_attr.attr,
5485 : : &free_frozen_attr.attr,
5486 : : &free_add_partial_attr.attr,
5487 : : &free_remove_partial_attr.attr,
5488 : : &alloc_from_partial_attr.attr,
5489 : : &alloc_slab_attr.attr,
5490 : : &alloc_refill_attr.attr,
5491 : : &alloc_node_mismatch_attr.attr,
5492 : : &free_slab_attr.attr,
5493 : : &cpuslab_flush_attr.attr,
5494 : : &deactivate_full_attr.attr,
5495 : : &deactivate_empty_attr.attr,
5496 : : &deactivate_to_head_attr.attr,
5497 : : &deactivate_to_tail_attr.attr,
5498 : : &deactivate_remote_frees_attr.attr,
5499 : : &deactivate_bypass_attr.attr,
5500 : : &order_fallback_attr.attr,
5501 : : &cmpxchg_double_fail_attr.attr,
5502 : : &cmpxchg_double_cpu_fail_attr.attr,
5503 : : &cpu_partial_alloc_attr.attr,
5504 : : &cpu_partial_free_attr.attr,
5505 : : &cpu_partial_node_attr.attr,
5506 : : &cpu_partial_drain_attr.attr,
5507 : : #endif
5508 : : #ifdef CONFIG_FAILSLAB
5509 : : &failslab_attr.attr,
5510 : : #endif
5511 : : &usersize_attr.attr,
5512 : :
5513 : : NULL
5514 : : };
5515 : :
5516 : : static const struct attribute_group slab_attr_group = {
5517 : : .attrs = slab_attrs,
5518 : : };
5519 : :
5520 : 0 : static ssize_t slab_attr_show(struct kobject *kobj,
5521 : : struct attribute *attr,
5522 : : char *buf)
5523 : : {
5524 : 0 : struct slab_attribute *attribute;
5525 : 0 : struct kmem_cache *s;
5526 : 0 : int err;
5527 : :
5528 : 0 : attribute = to_slab_attr(attr);
5529 : 0 : s = to_slab(kobj);
5530 : :
5531 [ # # ]: 0 : if (!attribute->show)
5532 : : return -EIO;
5533 : :
5534 : 0 : err = attribute->show(s, buf);
5535 : :
5536 : 0 : return err;
5537 : : }
5538 : :
5539 : 0 : static ssize_t slab_attr_store(struct kobject *kobj,
5540 : : struct attribute *attr,
5541 : : const char *buf, size_t len)
5542 : : {
5543 : 0 : struct slab_attribute *attribute;
5544 : 0 : struct kmem_cache *s;
5545 : 0 : int err;
5546 : :
5547 : 0 : attribute = to_slab_attr(attr);
5548 : 0 : s = to_slab(kobj);
5549 : :
5550 [ # # ]: 0 : if (!attribute->store)
5551 : : return -EIO;
5552 : :
5553 : 0 : err = attribute->store(s, buf, len);
5554 : : #ifdef CONFIG_MEMCG
5555 : : if (slab_state >= FULL && err >= 0 && is_root_cache(s)) {
5556 : : struct kmem_cache *c;
5557 : :
5558 : : mutex_lock(&slab_mutex);
5559 : : if (s->max_attr_size < len)
5560 : : s->max_attr_size = len;
5561 : :
5562 : : /*
5563 : : * This is a best effort propagation, so this function's return
5564 : : * value will be determined by the parent cache only. This is
5565 : : * basically because not all attributes will have a well
5566 : : * defined semantics for rollbacks - most of the actions will
5567 : : * have permanent effects.
5568 : : *
5569 : : * Returning the error value of any of the children that fail
5570 : : * is not 100 % defined, in the sense that users seeing the
5571 : : * error code won't be able to know anything about the state of
5572 : : * the cache.
5573 : : *
5574 : : * Only returning the error code for the parent cache at least
5575 : : * has well defined semantics. The cache being written to
5576 : : * directly either failed or succeeded, in which case we loop
5577 : : * through the descendants with best-effort propagation.
5578 : : */
5579 : : for_each_memcg_cache(c, s)
5580 : : attribute->store(c, buf, len);
5581 : : mutex_unlock(&slab_mutex);
5582 : : }
5583 : : #endif
5584 : 0 : return err;
5585 : : }
5586 : :
5587 : 219 : static void memcg_propagate_slab_attrs(struct kmem_cache *s)
5588 : : {
5589 : : #ifdef CONFIG_MEMCG
5590 : : int i;
5591 : : char *buffer = NULL;
5592 : : struct kmem_cache *root_cache;
5593 : :
5594 : : if (is_root_cache(s))
5595 : : return;
5596 : :
5597 : : root_cache = s->memcg_params.root_cache;
5598 : :
5599 : : /*
5600 : : * This mean this cache had no attribute written. Therefore, no point
5601 : : * in copying default values around
5602 : : */
5603 : : if (!root_cache->max_attr_size)
5604 : : return;
5605 : :
5606 : : for (i = 0; i < ARRAY_SIZE(slab_attrs); i++) {
5607 : : char mbuf[64];
5608 : : char *buf;
5609 : : struct slab_attribute *attr = to_slab_attr(slab_attrs[i]);
5610 : : ssize_t len;
5611 : :
5612 : : if (!attr || !attr->store || !attr->show)
5613 : : continue;
5614 : :
5615 : : /*
5616 : : * It is really bad that we have to allocate here, so we will
5617 : : * do it only as a fallback. If we actually allocate, though,
5618 : : * we can just use the allocated buffer until the end.
5619 : : *
5620 : : * Most of the slub attributes will tend to be very small in
5621 : : * size, but sysfs allows buffers up to a page, so they can
5622 : : * theoretically happen.
5623 : : */
5624 : : if (buffer)
5625 : : buf = buffer;
5626 : : else if (root_cache->max_attr_size < ARRAY_SIZE(mbuf))
5627 : : buf = mbuf;
5628 : : else {
5629 : : buffer = (char *) get_zeroed_page(GFP_KERNEL);
5630 : : if (WARN_ON(!buffer))
5631 : : continue;
5632 : : buf = buffer;
5633 : : }
5634 : :
5635 : : len = attr->show(root_cache, buf);
5636 : : if (len > 0)
5637 : : attr->store(s, buf, len);
5638 : : }
5639 : :
5640 : : if (buffer)
5641 : : free_page((unsigned long)buffer);
5642 : : #endif /* CONFIG_MEMCG */
5643 : 219 : }
5644 : :
5645 : 0 : static void kmem_cache_release(struct kobject *k)
5646 : : {
5647 : 0 : slab_kmem_cache_release(to_slab(k));
5648 : 0 : }
5649 : :
5650 : : static const struct sysfs_ops slab_sysfs_ops = {
5651 : : .show = slab_attr_show,
5652 : : .store = slab_attr_store,
5653 : : };
5654 : :
5655 : : static struct kobj_type slab_ktype = {
5656 : : .sysfs_ops = &slab_sysfs_ops,
5657 : : .release = kmem_cache_release,
5658 : : };
5659 : :
5660 : 657 : static int uevent_filter(struct kset *kset, struct kobject *kobj)
5661 : : {
5662 [ + - ]: 657 : struct kobj_type *ktype = get_ktype(kobj);
5663 : :
5664 [ + - ]: 657 : if (ktype == &slab_ktype)
5665 : 657 : return 1;
5666 : : return 0;
5667 : : }
5668 : :
5669 : : static const struct kset_uevent_ops slab_uevent_ops = {
5670 : : .filter = uevent_filter,
5671 : : };
5672 : :
5673 : : static struct kset *slab_kset;
5674 : :
5675 : 657 : static inline struct kset *cache_kset(struct kmem_cache *s)
5676 : : {
5677 : : #ifdef CONFIG_MEMCG
5678 : : if (!is_root_cache(s))
5679 : : return s->memcg_params.root_cache->memcg_kset;
5680 : : #endif
5681 : 657 : return slab_kset;
5682 : : }
5683 : :
5684 : : #define ID_STR_LENGTH 64
5685 : :
5686 : : /* Create a unique string id for a slab cache:
5687 : : *
5688 : : * Format :[flags-]size
5689 : : */
5690 : : static char *create_unique_id(struct kmem_cache *s)
5691 : : {
5692 : : char *name = kmalloc(ID_STR_LENGTH, GFP_KERNEL);
5693 : : char *p = name;
5694 : :
5695 : : BUG_ON(!name);
5696 : :
5697 : : *p++ = ':';
5698 : : /*
5699 : : * First flags affecting slabcache operations. We will only
5700 : : * get here for aliasable slabs so we do not need to support
5701 : : * too many flags. The flags here must cover all flags that
5702 : : * are matched during merging to guarantee that the id is
5703 : : * unique.
5704 : : */
5705 : : if (s->flags & SLAB_CACHE_DMA)
5706 : : *p++ = 'd';
5707 : : if (s->flags & SLAB_CACHE_DMA32)
5708 : : *p++ = 'D';
5709 : : if (s->flags & SLAB_RECLAIM_ACCOUNT)
5710 : : *p++ = 'a';
5711 : : if (s->flags & SLAB_CONSISTENCY_CHECKS)
5712 : : *p++ = 'F';
5713 : : if (s->flags & SLAB_ACCOUNT)
5714 : : *p++ = 'A';
5715 : : if (p != name + 1)
5716 : : *p++ = '-';
5717 : : p += sprintf(p, "%07u", s->size);
5718 : :
5719 : : BUG_ON(p > name + ID_STR_LENGTH - 1);
5720 : : return name;
5721 : : }
5722 : :
5723 : 0 : static void sysfs_slab_remove_workfn(struct work_struct *work)
5724 : : {
5725 : 0 : struct kmem_cache *s =
5726 : 0 : container_of(work, struct kmem_cache, kobj_remove_work);
5727 : :
5728 [ # # ]: 0 : if (!s->kobj.state_in_sysfs)
5729 : : /*
5730 : : * For a memcg cache, this may be called during
5731 : : * deactivation and again on shutdown. Remove only once.
5732 : : * A cache is never shut down before deactivation is
5733 : : * complete, so no need to worry about synchronization.
5734 : : */
5735 : 0 : goto out;
5736 : :
5737 : : #ifdef CONFIG_MEMCG
5738 : : kset_unregister(s->memcg_kset);
5739 : : #endif
5740 : 0 : kobject_uevent(&s->kobj, KOBJ_REMOVE);
5741 : 0 : out:
5742 : 0 : kobject_put(&s->kobj);
5743 : 0 : }
5744 : :
5745 : 657 : static int sysfs_slab_add(struct kmem_cache *s)
5746 : : {
5747 : 657 : int err;
5748 : 657 : const char *name;
5749 : 657 : struct kset *kset = cache_kset(s);
5750 : 657 : int unmergeable = slab_unmergeable(s);
5751 : :
5752 [ - + ]: 657 : INIT_WORK(&s->kobj_remove_work, sysfs_slab_remove_workfn);
5753 : :
5754 [ - + ]: 657 : if (!kset) {
5755 : 0 : kobject_init(&s->kobj, &slab_ktype);
5756 : 0 : return 0;
5757 : : }
5758 : :
5759 [ - + - - ]: 657 : if (!unmergeable && disable_higher_order_debug &&
5760 [ # # ]: 0 : (slub_debug & DEBUG_METADATA_FLAGS))
5761 : : unmergeable = 1;
5762 : :
5763 [ + - ]: 657 : if (unmergeable) {
5764 : : /*
5765 : : * Slabcache can never be merged so we can use the name proper.
5766 : : * This is typically the case for debug situations. In that
5767 : : * case we can catch duplicate names easily.
5768 : : */
5769 : 657 : sysfs_remove_link(&slab_kset->kobj, s->name);
5770 : 657 : name = s->name;
5771 : : } else {
5772 : : /*
5773 : : * Create a unique name for the slab as a target
5774 : : * for the symlinks.
5775 : : */
5776 : 0 : name = create_unique_id(s);
5777 : : }
5778 : :
5779 : 657 : s->kobj.kset = kset;
5780 : 657 : err = kobject_init_and_add(&s->kobj, &slab_ktype, NULL, "%s", name);
5781 [ - + ]: 657 : if (err)
5782 : 0 : goto out;
5783 : :
5784 : 657 : err = sysfs_create_group(&s->kobj, &slab_attr_group);
5785 [ - + ]: 657 : if (err)
5786 : 0 : goto out_del_kobj;
5787 : :
5788 : : #ifdef CONFIG_MEMCG
5789 : : if (is_root_cache(s) && memcg_sysfs_enabled) {
5790 : : s->memcg_kset = kset_create_and_add("cgroup", NULL, &s->kobj);
5791 : : if (!s->memcg_kset) {
5792 : : err = -ENOMEM;
5793 : : goto out_del_kobj;
5794 : : }
5795 : : }
5796 : : #endif
5797 : :
5798 : 657 : kobject_uevent(&s->kobj, KOBJ_ADD);
5799 [ + - ]: 657 : if (!unmergeable) {
5800 : : /* Setup first alias */
5801 : 0 : sysfs_slab_alias(s, s->name);
5802 : : }
5803 : 657 : out:
5804 [ - + ]: 657 : if (!unmergeable)
5805 : 0 : kfree(name);
5806 : : return err;
5807 : : out_del_kobj:
5808 : 0 : kobject_del(&s->kobj);
5809 : 0 : goto out;
5810 : : }
5811 : :
5812 : 0 : static void sysfs_slab_remove(struct kmem_cache *s)
5813 : : {
5814 [ # # ]: 0 : if (slab_state < FULL)
5815 : : /*
5816 : : * Sysfs has not been setup yet so no need to remove the
5817 : : * cache from sysfs.
5818 : : */
5819 : : return;
5820 : :
5821 : 0 : kobject_get(&s->kobj);
5822 : 0 : schedule_work(&s->kobj_remove_work);
5823 : : }
5824 : :
5825 : 0 : void sysfs_slab_unlink(struct kmem_cache *s)
5826 : : {
5827 [ # # ]: 0 : if (slab_state >= FULL)
5828 : 0 : kobject_del(&s->kobj);
5829 : 0 : }
5830 : :
5831 : 0 : void sysfs_slab_release(struct kmem_cache *s)
5832 : : {
5833 [ # # ]: 0 : if (slab_state >= FULL)
5834 : 0 : kobject_put(&s->kobj);
5835 : 0 : }
5836 : :
5837 : : /*
5838 : : * Need to buffer aliases during bootup until sysfs becomes
5839 : : * available lest we lose that information.
5840 : : */
5841 : : struct saved_alias {
5842 : : struct kmem_cache *s;
5843 : : const char *name;
5844 : : struct saved_alias *next;
5845 : : };
5846 : :
5847 : : static struct saved_alias *alias_list;
5848 : :
5849 : 0 : static int sysfs_slab_alias(struct kmem_cache *s, const char *name)
5850 : : {
5851 : 0 : struct saved_alias *al;
5852 : :
5853 [ # # ]: 0 : if (slab_state == FULL) {
5854 : : /*
5855 : : * If we have a leftover link then remove it.
5856 : : */
5857 : 0 : sysfs_remove_link(&slab_kset->kobj, name);
5858 : 0 : return sysfs_create_link(&slab_kset->kobj, &s->kobj, name);
5859 : : }
5860 : :
5861 : 0 : al = kmalloc(sizeof(struct saved_alias), GFP_KERNEL);
5862 [ # # ]: 0 : if (!al)
5863 : : return -ENOMEM;
5864 : :
5865 : 0 : al->s = s;
5866 : 0 : al->name = name;
5867 : 0 : al->next = alias_list;
5868 : 0 : alias_list = al;
5869 : 0 : return 0;
5870 : : }
5871 : :
5872 : 3 : static int __init slab_sysfs_init(void)
5873 : : {
5874 : 3 : struct kmem_cache *s;
5875 : 3 : int err;
5876 : :
5877 : 3 : mutex_lock(&slab_mutex);
5878 : :
5879 : 3 : slab_kset = kset_create_and_add("slab", &slab_uevent_ops, kernel_kobj);
5880 [ - + ]: 3 : if (!slab_kset) {
5881 : 0 : mutex_unlock(&slab_mutex);
5882 : 0 : pr_err("Cannot register slab subsystem.\n");
5883 : 0 : return -ENOSYS;
5884 : : }
5885 : :
5886 : 3 : slab_state = FULL;
5887 : :
5888 [ + + ]: 441 : list_for_each_entry(s, &slab_caches, list) {
5889 : 438 : err = sysfs_slab_add(s);
5890 [ - + ]: 438 : if (err)
5891 : 0 : pr_err("SLUB: Unable to add boot slab %s to sysfs\n",
5892 : : s->name);
5893 : : }
5894 : :
5895 [ - + ]: 3 : while (alias_list) {
5896 : 0 : struct saved_alias *al = alias_list;
5897 : :
5898 : 0 : alias_list = alias_list->next;
5899 : 0 : err = sysfs_slab_alias(al->s, al->name);
5900 [ # # ]: 0 : if (err)
5901 : 0 : pr_err("SLUB: Unable to add boot slab alias %s to sysfs\n",
5902 : : al->name);
5903 : 0 : kfree(al);
5904 : : }
5905 : :
5906 : 3 : mutex_unlock(&slab_mutex);
5907 : 3 : resiliency_test();
5908 : 3 : return 0;
5909 : : }
5910 : :
5911 : : __initcall(slab_sysfs_init);
5912 : : #endif /* CONFIG_SYSFS */
5913 : :
5914 : : /*
5915 : : * The /proc/slabinfo ABI
5916 : : */
5917 : : #ifdef CONFIG_SLUB_DEBUG
5918 : 0 : void get_slabinfo(struct kmem_cache *s, struct slabinfo *sinfo)
5919 : : {
5920 : 0 : unsigned long nr_slabs = 0;
5921 : 0 : unsigned long nr_objs = 0;
5922 : 0 : unsigned long nr_free = 0;
5923 : 0 : int node;
5924 : 0 : struct kmem_cache_node *n;
5925 : :
5926 [ # # # # ]: 0 : for_each_kmem_cache_node(s, node, n) {
5927 : 0 : nr_slabs += node_nr_slabs(n);
5928 : 0 : nr_objs += node_nr_objs(n);
5929 : 0 : nr_free += count_partial(n, count_free);
5930 : : }
5931 : :
5932 : 0 : sinfo->active_objs = nr_objs - nr_free;
5933 : 0 : sinfo->num_objs = nr_objs;
5934 : 0 : sinfo->active_slabs = nr_slabs;
5935 : 0 : sinfo->num_slabs = nr_slabs;
5936 : 0 : sinfo->objects_per_slab = oo_objects(s->oo);
5937 : 0 : sinfo->cache_order = oo_order(s->oo);
5938 : 0 : }
5939 : :
5940 : 0 : void slabinfo_show_stats(struct seq_file *m, struct kmem_cache *s)
5941 : : {
5942 : 0 : }
5943 : :
5944 : 0 : ssize_t slabinfo_write(struct file *file, const char __user *buffer,
5945 : : size_t count, loff_t *ppos)
5946 : : {
5947 : 0 : return -EIO;
5948 : : }
5949 : : #endif /* CONFIG_SLUB_DEBUG */
|
