slab: fixup calculate_alignment() argument type
[muen/linux.git] / mm / slab_common.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Slab allocator functions that are independent of the allocator strategy
4  *
5  * (C) 2012 Christoph Lameter <cl@linux.com>
6  */
7 #include <linux/slab.h>
8
9 #include <linux/mm.h>
10 #include <linux/poison.h>
11 #include <linux/interrupt.h>
12 #include <linux/memory.h>
13 #include <linux/cache.h>
14 #include <linux/compiler.h>
15 #include <linux/module.h>
16 #include <linux/cpu.h>
17 #include <linux/uaccess.h>
18 #include <linux/seq_file.h>
19 #include <linux/proc_fs.h>
20 #include <asm/cacheflush.h>
21 #include <asm/tlbflush.h>
22 #include <asm/page.h>
23 #include <linux/memcontrol.h>
24
25 #define CREATE_TRACE_POINTS
26 #include <trace/events/kmem.h>
27
28 #include "slab.h"
29
30 enum slab_state slab_state;
31 LIST_HEAD(slab_caches);
32 DEFINE_MUTEX(slab_mutex);
33 struct kmem_cache *kmem_cache;
34
35 #ifdef CONFIG_HARDENED_USERCOPY
36 bool usercopy_fallback __ro_after_init =
37                 IS_ENABLED(CONFIG_HARDENED_USERCOPY_FALLBACK);
38 module_param(usercopy_fallback, bool, 0400);
39 MODULE_PARM_DESC(usercopy_fallback,
40                 "WARN instead of reject usercopy whitelist violations");
41 #endif
42
43 static LIST_HEAD(slab_caches_to_rcu_destroy);
44 static void slab_caches_to_rcu_destroy_workfn(struct work_struct *work);
45 static DECLARE_WORK(slab_caches_to_rcu_destroy_work,
46                     slab_caches_to_rcu_destroy_workfn);
47
48 /*
49  * Set of flags that will prevent slab merging
50  */
51 #define SLAB_NEVER_MERGE (SLAB_RED_ZONE | SLAB_POISON | SLAB_STORE_USER | \
52                 SLAB_TRACE | SLAB_TYPESAFE_BY_RCU | SLAB_NOLEAKTRACE | \
53                 SLAB_FAILSLAB | SLAB_KASAN)
54
55 #define SLAB_MERGE_SAME (SLAB_RECLAIM_ACCOUNT | SLAB_CACHE_DMA | \
56                          SLAB_ACCOUNT)
57
58 /*
59  * Merge control. If this is set then no merging of slab caches will occur.
60  */
61 static bool slab_nomerge = !IS_ENABLED(CONFIG_SLAB_MERGE_DEFAULT);
62
63 static int __init setup_slab_nomerge(char *str)
64 {
65         slab_nomerge = true;
66         return 1;
67 }
68
69 #ifdef CONFIG_SLUB
70 __setup_param("slub_nomerge", slub_nomerge, setup_slab_nomerge, 0);
71 #endif
72
73 __setup("slab_nomerge", setup_slab_nomerge);
74
75 /*
76  * Determine the size of a slab object
77  */
78 unsigned int kmem_cache_size(struct kmem_cache *s)
79 {
80         return s->object_size;
81 }
82 EXPORT_SYMBOL(kmem_cache_size);
83
84 #ifdef CONFIG_DEBUG_VM
85 static int kmem_cache_sanity_check(const char *name, size_t size)
86 {
87         struct kmem_cache *s = NULL;
88
89         if (!name || in_interrupt() || size < sizeof(void *) ||
90                 size > KMALLOC_MAX_SIZE) {
91                 pr_err("kmem_cache_create(%s) integrity check failed\n", name);
92                 return -EINVAL;
93         }
94
95         list_for_each_entry(s, &slab_caches, list) {
96                 char tmp;
97                 int res;
98
99                 /*
100                  * This happens when the module gets unloaded and doesn't
101                  * destroy its slab cache and no-one else reuses the vmalloc
102                  * area of the module.  Print a warning.
103                  */
104                 res = probe_kernel_address(s->name, tmp);
105                 if (res) {
106                         pr_err("Slab cache with size %d has lost its name\n",
107                                s->object_size);
108                         continue;
109                 }
110         }
111
112         WARN_ON(strchr(name, ' '));     /* It confuses parsers */
113         return 0;
114 }
115 #else
116 static inline int kmem_cache_sanity_check(const char *name, size_t size)
117 {
118         return 0;
119 }
120 #endif
121
122 void __kmem_cache_free_bulk(struct kmem_cache *s, size_t nr, void **p)
123 {
124         size_t i;
125
126         for (i = 0; i < nr; i++) {
127                 if (s)
128                         kmem_cache_free(s, p[i]);
129                 else
130                         kfree(p[i]);
131         }
132 }
133
134 int __kmem_cache_alloc_bulk(struct kmem_cache *s, gfp_t flags, size_t nr,
135                                                                 void **p)
136 {
137         size_t i;
138
139         for (i = 0; i < nr; i++) {
140                 void *x = p[i] = kmem_cache_alloc(s, flags);
141                 if (!x) {
142                         __kmem_cache_free_bulk(s, i, p);
143                         return 0;
144                 }
145         }
146         return i;
147 }
148
149 #if defined(CONFIG_MEMCG) && !defined(CONFIG_SLOB)
150
151 LIST_HEAD(slab_root_caches);
152
153 void slab_init_memcg_params(struct kmem_cache *s)
154 {
155         s->memcg_params.root_cache = NULL;
156         RCU_INIT_POINTER(s->memcg_params.memcg_caches, NULL);
157         INIT_LIST_HEAD(&s->memcg_params.children);
158 }
159
160 static int init_memcg_params(struct kmem_cache *s,
161                 struct mem_cgroup *memcg, struct kmem_cache *root_cache)
162 {
163         struct memcg_cache_array *arr;
164
165         if (root_cache) {
166                 s->memcg_params.root_cache = root_cache;
167                 s->memcg_params.memcg = memcg;
168                 INIT_LIST_HEAD(&s->memcg_params.children_node);
169                 INIT_LIST_HEAD(&s->memcg_params.kmem_caches_node);
170                 return 0;
171         }
172
173         slab_init_memcg_params(s);
174
175         if (!memcg_nr_cache_ids)
176                 return 0;
177
178         arr = kvzalloc(sizeof(struct memcg_cache_array) +
179                        memcg_nr_cache_ids * sizeof(void *),
180                        GFP_KERNEL);
181         if (!arr)
182                 return -ENOMEM;
183
184         RCU_INIT_POINTER(s->memcg_params.memcg_caches, arr);
185         return 0;
186 }
187
188 static void destroy_memcg_params(struct kmem_cache *s)
189 {
190         if (is_root_cache(s))
191                 kvfree(rcu_access_pointer(s->memcg_params.memcg_caches));
192 }
193
194 static void free_memcg_params(struct rcu_head *rcu)
195 {
196         struct memcg_cache_array *old;
197
198         old = container_of(rcu, struct memcg_cache_array, rcu);
199         kvfree(old);
200 }
201
202 static int update_memcg_params(struct kmem_cache *s, int new_array_size)
203 {
204         struct memcg_cache_array *old, *new;
205
206         new = kvzalloc(sizeof(struct memcg_cache_array) +
207                        new_array_size * sizeof(void *), GFP_KERNEL);
208         if (!new)
209                 return -ENOMEM;
210
211         old = rcu_dereference_protected(s->memcg_params.memcg_caches,
212                                         lockdep_is_held(&slab_mutex));
213         if (old)
214                 memcpy(new->entries, old->entries,
215                        memcg_nr_cache_ids * sizeof(void *));
216
217         rcu_assign_pointer(s->memcg_params.memcg_caches, new);
218         if (old)
219                 call_rcu(&old->rcu, free_memcg_params);
220         return 0;
221 }
222
223 int memcg_update_all_caches(int num_memcgs)
224 {
225         struct kmem_cache *s;
226         int ret = 0;
227
228         mutex_lock(&slab_mutex);
229         list_for_each_entry(s, &slab_root_caches, root_caches_node) {
230                 ret = update_memcg_params(s, num_memcgs);
231                 /*
232                  * Instead of freeing the memory, we'll just leave the caches
233                  * up to this point in an updated state.
234                  */
235                 if (ret)
236                         break;
237         }
238         mutex_unlock(&slab_mutex);
239         return ret;
240 }
241
242 void memcg_link_cache(struct kmem_cache *s)
243 {
244         if (is_root_cache(s)) {
245                 list_add(&s->root_caches_node, &slab_root_caches);
246         } else {
247                 list_add(&s->memcg_params.children_node,
248                          &s->memcg_params.root_cache->memcg_params.children);
249                 list_add(&s->memcg_params.kmem_caches_node,
250                          &s->memcg_params.memcg->kmem_caches);
251         }
252 }
253
254 static void memcg_unlink_cache(struct kmem_cache *s)
255 {
256         if (is_root_cache(s)) {
257                 list_del(&s->root_caches_node);
258         } else {
259                 list_del(&s->memcg_params.children_node);
260                 list_del(&s->memcg_params.kmem_caches_node);
261         }
262 }
263 #else
264 static inline int init_memcg_params(struct kmem_cache *s,
265                 struct mem_cgroup *memcg, struct kmem_cache *root_cache)
266 {
267         return 0;
268 }
269
270 static inline void destroy_memcg_params(struct kmem_cache *s)
271 {
272 }
273
274 static inline void memcg_unlink_cache(struct kmem_cache *s)
275 {
276 }
277 #endif /* CONFIG_MEMCG && !CONFIG_SLOB */
278
279 /*
280  * Figure out what the alignment of the objects will be given a set of
281  * flags, a user specified alignment and the size of the objects.
282  */
283 static unsigned long calculate_alignment(slab_flags_t flags,
284                 unsigned long align, unsigned long size)
285 {
286         /*
287          * If the user wants hardware cache aligned objects then follow that
288          * suggestion if the object is sufficiently large.
289          *
290          * The hardware cache alignment cannot override the specified
291          * alignment though. If that is greater then use it.
292          */
293         if (flags & SLAB_HWCACHE_ALIGN) {
294                 unsigned long ralign;
295
296                 ralign = cache_line_size();
297                 while (size <= ralign / 2)
298                         ralign /= 2;
299                 align = max(align, ralign);
300         }
301
302         if (align < ARCH_SLAB_MINALIGN)
303                 align = ARCH_SLAB_MINALIGN;
304
305         return ALIGN(align, sizeof(void *));
306 }
307
308 /*
309  * Find a mergeable slab cache
310  */
311 int slab_unmergeable(struct kmem_cache *s)
312 {
313         if (slab_nomerge || (s->flags & SLAB_NEVER_MERGE))
314                 return 1;
315
316         if (!is_root_cache(s))
317                 return 1;
318
319         if (s->ctor)
320                 return 1;
321
322         if (s->usersize)
323                 return 1;
324
325         /*
326          * We may have set a slab to be unmergeable during bootstrap.
327          */
328         if (s->refcount < 0)
329                 return 1;
330
331         return 0;
332 }
333
334 struct kmem_cache *find_mergeable(size_t size, size_t align,
335                 slab_flags_t flags, const char *name, void (*ctor)(void *))
336 {
337         struct kmem_cache *s;
338
339         if (slab_nomerge)
340                 return NULL;
341
342         if (ctor)
343                 return NULL;
344
345         size = ALIGN(size, sizeof(void *));
346         align = calculate_alignment(flags, align, size);
347         size = ALIGN(size, align);
348         flags = kmem_cache_flags(size, flags, name, NULL);
349
350         if (flags & SLAB_NEVER_MERGE)
351                 return NULL;
352
353         list_for_each_entry_reverse(s, &slab_root_caches, root_caches_node) {
354                 if (slab_unmergeable(s))
355                         continue;
356
357                 if (size > s->size)
358                         continue;
359
360                 if ((flags & SLAB_MERGE_SAME) != (s->flags & SLAB_MERGE_SAME))
361                         continue;
362                 /*
363                  * Check if alignment is compatible.
364                  * Courtesy of Adrian Drzewiecki
365                  */
366                 if ((s->size & ~(align - 1)) != s->size)
367                         continue;
368
369                 if (s->size - size >= sizeof(void *))
370                         continue;
371
372                 if (IS_ENABLED(CONFIG_SLAB) && align &&
373                         (align > s->align || s->align % align))
374                         continue;
375
376                 return s;
377         }
378         return NULL;
379 }
380
381 static struct kmem_cache *create_cache(const char *name,
382                 size_t object_size, size_t size, size_t align,
383                 slab_flags_t flags, size_t useroffset,
384                 size_t usersize, void (*ctor)(void *),
385                 struct mem_cgroup *memcg, struct kmem_cache *root_cache)
386 {
387         struct kmem_cache *s;
388         int err;
389
390         if (WARN_ON(useroffset + usersize > object_size))
391                 useroffset = usersize = 0;
392
393         err = -ENOMEM;
394         s = kmem_cache_zalloc(kmem_cache, GFP_KERNEL);
395         if (!s)
396                 goto out;
397
398         s->name = name;
399         s->object_size = object_size;
400         s->size = size;
401         s->align = align;
402         s->ctor = ctor;
403         s->useroffset = useroffset;
404         s->usersize = usersize;
405
406         err = init_memcg_params(s, memcg, root_cache);
407         if (err)
408                 goto out_free_cache;
409
410         err = __kmem_cache_create(s, flags);
411         if (err)
412                 goto out_free_cache;
413
414         s->refcount = 1;
415         list_add(&s->list, &slab_caches);
416         memcg_link_cache(s);
417 out:
418         if (err)
419                 return ERR_PTR(err);
420         return s;
421
422 out_free_cache:
423         destroy_memcg_params(s);
424         kmem_cache_free(kmem_cache, s);
425         goto out;
426 }
427
428 /*
429  * kmem_cache_create_usercopy - Create a cache.
430  * @name: A string which is used in /proc/slabinfo to identify this cache.
431  * @size: The size of objects to be created in this cache.
432  * @align: The required alignment for the objects.
433  * @flags: SLAB flags
434  * @useroffset: Usercopy region offset
435  * @usersize: Usercopy region size
436  * @ctor: A constructor for the objects.
437  *
438  * Returns a ptr to the cache on success, NULL on failure.
439  * Cannot be called within a interrupt, but can be interrupted.
440  * The @ctor is run when new pages are allocated by the cache.
441  *
442  * The flags are
443  *
444  * %SLAB_POISON - Poison the slab with a known test pattern (a5a5a5a5)
445  * to catch references to uninitialised memory.
446  *
447  * %SLAB_RED_ZONE - Insert `Red' zones around the allocated memory to check
448  * for buffer overruns.
449  *
450  * %SLAB_HWCACHE_ALIGN - Align the objects in this cache to a hardware
451  * cacheline.  This can be beneficial if you're counting cycles as closely
452  * as davem.
453  */
454 struct kmem_cache *
455 kmem_cache_create_usercopy(const char *name, size_t size, size_t align,
456                   slab_flags_t flags, size_t useroffset, size_t usersize,
457                   void (*ctor)(void *))
458 {
459         struct kmem_cache *s = NULL;
460         const char *cache_name;
461         int err;
462
463         get_online_cpus();
464         get_online_mems();
465         memcg_get_cache_ids();
466
467         mutex_lock(&slab_mutex);
468
469         err = kmem_cache_sanity_check(name, size);
470         if (err) {
471                 goto out_unlock;
472         }
473
474         /* Refuse requests with allocator specific flags */
475         if (flags & ~SLAB_FLAGS_PERMITTED) {
476                 err = -EINVAL;
477                 goto out_unlock;
478         }
479
480         /*
481          * Some allocators will constraint the set of valid flags to a subset
482          * of all flags. We expect them to define CACHE_CREATE_MASK in this
483          * case, and we'll just provide them with a sanitized version of the
484          * passed flags.
485          */
486         flags &= CACHE_CREATE_MASK;
487
488         /* Fail closed on bad usersize of useroffset values. */
489         if (WARN_ON(!usersize && useroffset) ||
490             WARN_ON(size < usersize || size - usersize < useroffset))
491                 usersize = useroffset = 0;
492
493         if (!usersize)
494                 s = __kmem_cache_alias(name, size, align, flags, ctor);
495         if (s)
496                 goto out_unlock;
497
498         cache_name = kstrdup_const(name, GFP_KERNEL);
499         if (!cache_name) {
500                 err = -ENOMEM;
501                 goto out_unlock;
502         }
503
504         s = create_cache(cache_name, size, size,
505                          calculate_alignment(flags, align, size),
506                          flags, useroffset, usersize, ctor, NULL, NULL);
507         if (IS_ERR(s)) {
508                 err = PTR_ERR(s);
509                 kfree_const(cache_name);
510         }
511
512 out_unlock:
513         mutex_unlock(&slab_mutex);
514
515         memcg_put_cache_ids();
516         put_online_mems();
517         put_online_cpus();
518
519         if (err) {
520                 if (flags & SLAB_PANIC)
521                         panic("kmem_cache_create: Failed to create slab '%s'. Error %d\n",
522                                 name, err);
523                 else {
524                         pr_warn("kmem_cache_create(%s) failed with error %d\n",
525                                 name, err);
526                         dump_stack();
527                 }
528                 return NULL;
529         }
530         return s;
531 }
532 EXPORT_SYMBOL(kmem_cache_create_usercopy);
533
534 struct kmem_cache *
535 kmem_cache_create(const char *name, size_t size, size_t align,
536                 slab_flags_t flags, void (*ctor)(void *))
537 {
538         return kmem_cache_create_usercopy(name, size, align, flags, 0, 0,
539                                           ctor);
540 }
541 EXPORT_SYMBOL(kmem_cache_create);
542
543 static void slab_caches_to_rcu_destroy_workfn(struct work_struct *work)
544 {
545         LIST_HEAD(to_destroy);
546         struct kmem_cache *s, *s2;
547
548         /*
549          * On destruction, SLAB_TYPESAFE_BY_RCU kmem_caches are put on the
550          * @slab_caches_to_rcu_destroy list.  The slab pages are freed
551          * through RCU and and the associated kmem_cache are dereferenced
552          * while freeing the pages, so the kmem_caches should be freed only
553          * after the pending RCU operations are finished.  As rcu_barrier()
554          * is a pretty slow operation, we batch all pending destructions
555          * asynchronously.
556          */
557         mutex_lock(&slab_mutex);
558         list_splice_init(&slab_caches_to_rcu_destroy, &to_destroy);
559         mutex_unlock(&slab_mutex);
560
561         if (list_empty(&to_destroy))
562                 return;
563
564         rcu_barrier();
565
566         list_for_each_entry_safe(s, s2, &to_destroy, list) {
567 #ifdef SLAB_SUPPORTS_SYSFS
568                 sysfs_slab_release(s);
569 #else
570                 slab_kmem_cache_release(s);
571 #endif
572         }
573 }
574
575 static int shutdown_cache(struct kmem_cache *s)
576 {
577         /* free asan quarantined objects */
578         kasan_cache_shutdown(s);
579
580         if (__kmem_cache_shutdown(s) != 0)
581                 return -EBUSY;
582
583         memcg_unlink_cache(s);
584         list_del(&s->list);
585
586         if (s->flags & SLAB_TYPESAFE_BY_RCU) {
587                 list_add_tail(&s->list, &slab_caches_to_rcu_destroy);
588                 schedule_work(&slab_caches_to_rcu_destroy_work);
589         } else {
590 #ifdef SLAB_SUPPORTS_SYSFS
591                 sysfs_slab_release(s);
592 #else
593                 slab_kmem_cache_release(s);
594 #endif
595         }
596
597         return 0;
598 }
599
600 #if defined(CONFIG_MEMCG) && !defined(CONFIG_SLOB)
601 /*
602  * memcg_create_kmem_cache - Create a cache for a memory cgroup.
603  * @memcg: The memory cgroup the new cache is for.
604  * @root_cache: The parent of the new cache.
605  *
606  * This function attempts to create a kmem cache that will serve allocation
607  * requests going from @memcg to @root_cache. The new cache inherits properties
608  * from its parent.
609  */
610 void memcg_create_kmem_cache(struct mem_cgroup *memcg,
611                              struct kmem_cache *root_cache)
612 {
613         static char memcg_name_buf[NAME_MAX + 1]; /* protected by slab_mutex */
614         struct cgroup_subsys_state *css = &memcg->css;
615         struct memcg_cache_array *arr;
616         struct kmem_cache *s = NULL;
617         char *cache_name;
618         int idx;
619
620         get_online_cpus();
621         get_online_mems();
622
623         mutex_lock(&slab_mutex);
624
625         /*
626          * The memory cgroup could have been offlined while the cache
627          * creation work was pending.
628          */
629         if (memcg->kmem_state != KMEM_ONLINE)
630                 goto out_unlock;
631
632         idx = memcg_cache_id(memcg);
633         arr = rcu_dereference_protected(root_cache->memcg_params.memcg_caches,
634                                         lockdep_is_held(&slab_mutex));
635
636         /*
637          * Since per-memcg caches are created asynchronously on first
638          * allocation (see memcg_kmem_get_cache()), several threads can try to
639          * create the same cache, but only one of them may succeed.
640          */
641         if (arr->entries[idx])
642                 goto out_unlock;
643
644         cgroup_name(css->cgroup, memcg_name_buf, sizeof(memcg_name_buf));
645         cache_name = kasprintf(GFP_KERNEL, "%s(%llu:%s)", root_cache->name,
646                                css->serial_nr, memcg_name_buf);
647         if (!cache_name)
648                 goto out_unlock;
649
650         s = create_cache(cache_name, root_cache->object_size,
651                          root_cache->size, root_cache->align,
652                          root_cache->flags & CACHE_CREATE_MASK,
653                          root_cache->useroffset, root_cache->usersize,
654                          root_cache->ctor, memcg, root_cache);
655         /*
656          * If we could not create a memcg cache, do not complain, because
657          * that's not critical at all as we can always proceed with the root
658          * cache.
659          */
660         if (IS_ERR(s)) {
661                 kfree(cache_name);
662                 goto out_unlock;
663         }
664
665         /*
666          * Since readers won't lock (see cache_from_memcg_idx()), we need a
667          * barrier here to ensure nobody will see the kmem_cache partially
668          * initialized.
669          */
670         smp_wmb();
671         arr->entries[idx] = s;
672
673 out_unlock:
674         mutex_unlock(&slab_mutex);
675
676         put_online_mems();
677         put_online_cpus();
678 }
679
680 static void kmemcg_deactivate_workfn(struct work_struct *work)
681 {
682         struct kmem_cache *s = container_of(work, struct kmem_cache,
683                                             memcg_params.deact_work);
684
685         get_online_cpus();
686         get_online_mems();
687
688         mutex_lock(&slab_mutex);
689
690         s->memcg_params.deact_fn(s);
691
692         mutex_unlock(&slab_mutex);
693
694         put_online_mems();
695         put_online_cpus();
696
697         /* done, put the ref from slab_deactivate_memcg_cache_rcu_sched() */
698         css_put(&s->memcg_params.memcg->css);
699 }
700
701 static void kmemcg_deactivate_rcufn(struct rcu_head *head)
702 {
703         struct kmem_cache *s = container_of(head, struct kmem_cache,
704                                             memcg_params.deact_rcu_head);
705
706         /*
707          * We need to grab blocking locks.  Bounce to ->deact_work.  The
708          * work item shares the space with the RCU head and can't be
709          * initialized eariler.
710          */
711         INIT_WORK(&s->memcg_params.deact_work, kmemcg_deactivate_workfn);
712         queue_work(memcg_kmem_cache_wq, &s->memcg_params.deact_work);
713 }
714
715 /**
716  * slab_deactivate_memcg_cache_rcu_sched - schedule deactivation after a
717  *                                         sched RCU grace period
718  * @s: target kmem_cache
719  * @deact_fn: deactivation function to call
720  *
721  * Schedule @deact_fn to be invoked with online cpus, mems and slab_mutex
722  * held after a sched RCU grace period.  The slab is guaranteed to stay
723  * alive until @deact_fn is finished.  This is to be used from
724  * __kmemcg_cache_deactivate().
725  */
726 void slab_deactivate_memcg_cache_rcu_sched(struct kmem_cache *s,
727                                            void (*deact_fn)(struct kmem_cache *))
728 {
729         if (WARN_ON_ONCE(is_root_cache(s)) ||
730             WARN_ON_ONCE(s->memcg_params.deact_fn))
731                 return;
732
733         /* pin memcg so that @s doesn't get destroyed in the middle */
734         css_get(&s->memcg_params.memcg->css);
735
736         s->memcg_params.deact_fn = deact_fn;
737         call_rcu_sched(&s->memcg_params.deact_rcu_head, kmemcg_deactivate_rcufn);
738 }
739
740 void memcg_deactivate_kmem_caches(struct mem_cgroup *memcg)
741 {
742         int idx;
743         struct memcg_cache_array *arr;
744         struct kmem_cache *s, *c;
745
746         idx = memcg_cache_id(memcg);
747
748         get_online_cpus();
749         get_online_mems();
750
751         mutex_lock(&slab_mutex);
752         list_for_each_entry(s, &slab_root_caches, root_caches_node) {
753                 arr = rcu_dereference_protected(s->memcg_params.memcg_caches,
754                                                 lockdep_is_held(&slab_mutex));
755                 c = arr->entries[idx];
756                 if (!c)
757                         continue;
758
759                 __kmemcg_cache_deactivate(c);
760                 arr->entries[idx] = NULL;
761         }
762         mutex_unlock(&slab_mutex);
763
764         put_online_mems();
765         put_online_cpus();
766 }
767
768 void memcg_destroy_kmem_caches(struct mem_cgroup *memcg)
769 {
770         struct kmem_cache *s, *s2;
771
772         get_online_cpus();
773         get_online_mems();
774
775         mutex_lock(&slab_mutex);
776         list_for_each_entry_safe(s, s2, &memcg->kmem_caches,
777                                  memcg_params.kmem_caches_node) {
778                 /*
779                  * The cgroup is about to be freed and therefore has no charges
780                  * left. Hence, all its caches must be empty by now.
781                  */
782                 BUG_ON(shutdown_cache(s));
783         }
784         mutex_unlock(&slab_mutex);
785
786         put_online_mems();
787         put_online_cpus();
788 }
789
790 static int shutdown_memcg_caches(struct kmem_cache *s)
791 {
792         struct memcg_cache_array *arr;
793         struct kmem_cache *c, *c2;
794         LIST_HEAD(busy);
795         int i;
796
797         BUG_ON(!is_root_cache(s));
798
799         /*
800          * First, shutdown active caches, i.e. caches that belong to online
801          * memory cgroups.
802          */
803         arr = rcu_dereference_protected(s->memcg_params.memcg_caches,
804                                         lockdep_is_held(&slab_mutex));
805         for_each_memcg_cache_index(i) {
806                 c = arr->entries[i];
807                 if (!c)
808                         continue;
809                 if (shutdown_cache(c))
810                         /*
811                          * The cache still has objects. Move it to a temporary
812                          * list so as not to try to destroy it for a second
813                          * time while iterating over inactive caches below.
814                          */
815                         list_move(&c->memcg_params.children_node, &busy);
816                 else
817                         /*
818                          * The cache is empty and will be destroyed soon. Clear
819                          * the pointer to it in the memcg_caches array so that
820                          * it will never be accessed even if the root cache
821                          * stays alive.
822                          */
823                         arr->entries[i] = NULL;
824         }
825
826         /*
827          * Second, shutdown all caches left from memory cgroups that are now
828          * offline.
829          */
830         list_for_each_entry_safe(c, c2, &s->memcg_params.children,
831                                  memcg_params.children_node)
832                 shutdown_cache(c);
833
834         list_splice(&busy, &s->memcg_params.children);
835
836         /*
837          * A cache being destroyed must be empty. In particular, this means
838          * that all per memcg caches attached to it must be empty too.
839          */
840         if (!list_empty(&s->memcg_params.children))
841                 return -EBUSY;
842         return 0;
843 }
844 #else
845 static inline int shutdown_memcg_caches(struct kmem_cache *s)
846 {
847         return 0;
848 }
849 #endif /* CONFIG_MEMCG && !CONFIG_SLOB */
850
851 void slab_kmem_cache_release(struct kmem_cache *s)
852 {
853         __kmem_cache_release(s);
854         destroy_memcg_params(s);
855         kfree_const(s->name);
856         kmem_cache_free(kmem_cache, s);
857 }
858
859 void kmem_cache_destroy(struct kmem_cache *s)
860 {
861         int err;
862
863         if (unlikely(!s))
864                 return;
865
866         get_online_cpus();
867         get_online_mems();
868
869         mutex_lock(&slab_mutex);
870
871         s->refcount--;
872         if (s->refcount)
873                 goto out_unlock;
874
875         err = shutdown_memcg_caches(s);
876         if (!err)
877                 err = shutdown_cache(s);
878
879         if (err) {
880                 pr_err("kmem_cache_destroy %s: Slab cache still has objects\n",
881                        s->name);
882                 dump_stack();
883         }
884 out_unlock:
885         mutex_unlock(&slab_mutex);
886
887         put_online_mems();
888         put_online_cpus();
889 }
890 EXPORT_SYMBOL(kmem_cache_destroy);
891
892 /**
893  * kmem_cache_shrink - Shrink a cache.
894  * @cachep: The cache to shrink.
895  *
896  * Releases as many slabs as possible for a cache.
897  * To help debugging, a zero exit status indicates all slabs were released.
898  */
899 int kmem_cache_shrink(struct kmem_cache *cachep)
900 {
901         int ret;
902
903         get_online_cpus();
904         get_online_mems();
905         kasan_cache_shrink(cachep);
906         ret = __kmem_cache_shrink(cachep);
907         put_online_mems();
908         put_online_cpus();
909         return ret;
910 }
911 EXPORT_SYMBOL(kmem_cache_shrink);
912
913 bool slab_is_available(void)
914 {
915         return slab_state >= UP;
916 }
917
918 #ifndef CONFIG_SLOB
919 /* Create a cache during boot when no slab services are available yet */
920 void __init create_boot_cache(struct kmem_cache *s, const char *name, size_t size,
921                 slab_flags_t flags, size_t useroffset, size_t usersize)
922 {
923         int err;
924
925         s->name = name;
926         s->size = s->object_size = size;
927         s->align = calculate_alignment(flags, ARCH_KMALLOC_MINALIGN, size);
928         s->useroffset = useroffset;
929         s->usersize = usersize;
930
931         slab_init_memcg_params(s);
932
933         err = __kmem_cache_create(s, flags);
934
935         if (err)
936                 panic("Creation of kmalloc slab %s size=%zu failed. Reason %d\n",
937                                         name, size, err);
938
939         s->refcount = -1;       /* Exempt from merging for now */
940 }
941
942 struct kmem_cache *__init create_kmalloc_cache(const char *name, size_t size,
943                                 slab_flags_t flags, size_t useroffset,
944                                 size_t usersize)
945 {
946         struct kmem_cache *s = kmem_cache_zalloc(kmem_cache, GFP_NOWAIT);
947
948         if (!s)
949                 panic("Out of memory when creating slab %s\n", name);
950
951         create_boot_cache(s, name, size, flags, useroffset, usersize);
952         list_add(&s->list, &slab_caches);
953         memcg_link_cache(s);
954         s->refcount = 1;
955         return s;
956 }
957
958 struct kmem_cache *kmalloc_caches[KMALLOC_SHIFT_HIGH + 1] __ro_after_init;
959 EXPORT_SYMBOL(kmalloc_caches);
960
961 #ifdef CONFIG_ZONE_DMA
962 struct kmem_cache *kmalloc_dma_caches[KMALLOC_SHIFT_HIGH + 1] __ro_after_init;
963 EXPORT_SYMBOL(kmalloc_dma_caches);
964 #endif
965
966 /*
967  * Conversion table for small slabs sizes / 8 to the index in the
968  * kmalloc array. This is necessary for slabs < 192 since we have non power
969  * of two cache sizes there. The size of larger slabs can be determined using
970  * fls.
971  */
972 static s8 size_index[24] __ro_after_init = {
973         3,      /* 8 */
974         4,      /* 16 */
975         5,      /* 24 */
976         5,      /* 32 */
977         6,      /* 40 */
978         6,      /* 48 */
979         6,      /* 56 */
980         6,      /* 64 */
981         1,      /* 72 */
982         1,      /* 80 */
983         1,      /* 88 */
984         1,      /* 96 */
985         7,      /* 104 */
986         7,      /* 112 */
987         7,      /* 120 */
988         7,      /* 128 */
989         2,      /* 136 */
990         2,      /* 144 */
991         2,      /* 152 */
992         2,      /* 160 */
993         2,      /* 168 */
994         2,      /* 176 */
995         2,      /* 184 */
996         2       /* 192 */
997 };
998
999 static inline int size_index_elem(size_t bytes)
1000 {
1001         return (bytes - 1) / 8;
1002 }
1003
1004 /*
1005  * Find the kmem_cache structure that serves a given size of
1006  * allocation
1007  */
1008 struct kmem_cache *kmalloc_slab(size_t size, gfp_t flags)
1009 {
1010         int index;
1011
1012         if (unlikely(size > KMALLOC_MAX_SIZE)) {
1013                 WARN_ON_ONCE(!(flags & __GFP_NOWARN));
1014                 return NULL;
1015         }
1016
1017         if (size <= 192) {
1018                 if (!size)
1019                         return ZERO_SIZE_PTR;
1020
1021                 index = size_index[size_index_elem(size)];
1022         } else
1023                 index = fls(size - 1);
1024
1025 #ifdef CONFIG_ZONE_DMA
1026         if (unlikely((flags & GFP_DMA)))
1027                 return kmalloc_dma_caches[index];
1028
1029 #endif
1030         return kmalloc_caches[index];
1031 }
1032
1033 /*
1034  * kmalloc_info[] is to make slub_debug=,kmalloc-xx option work at boot time.
1035  * kmalloc_index() supports up to 2^26=64MB, so the final entry of the table is
1036  * kmalloc-67108864.
1037  */
1038 const struct kmalloc_info_struct kmalloc_info[] __initconst = {
1039         {NULL,                      0},         {"kmalloc-96",             96},
1040         {"kmalloc-192",           192},         {"kmalloc-8",               8},
1041         {"kmalloc-16",             16},         {"kmalloc-32",             32},
1042         {"kmalloc-64",             64},         {"kmalloc-128",           128},
1043         {"kmalloc-256",           256},         {"kmalloc-512",           512},
1044         {"kmalloc-1024",         1024},         {"kmalloc-2048",         2048},
1045         {"kmalloc-4096",         4096},         {"kmalloc-8192",         8192},
1046         {"kmalloc-16384",       16384},         {"kmalloc-32768",       32768},
1047         {"kmalloc-65536",       65536},         {"kmalloc-131072",     131072},
1048         {"kmalloc-262144",     262144},         {"kmalloc-524288",     524288},
1049         {"kmalloc-1048576",   1048576},         {"kmalloc-2097152",   2097152},
1050         {"kmalloc-4194304",   4194304},         {"kmalloc-8388608",   8388608},
1051         {"kmalloc-16777216", 16777216},         {"kmalloc-33554432", 33554432},
1052         {"kmalloc-67108864", 67108864}
1053 };
1054
1055 /*
1056  * Patch up the size_index table if we have strange large alignment
1057  * requirements for the kmalloc array. This is only the case for
1058  * MIPS it seems. The standard arches will not generate any code here.
1059  *
1060  * Largest permitted alignment is 256 bytes due to the way we
1061  * handle the index determination for the smaller caches.
1062  *
1063  * Make sure that nothing crazy happens if someone starts tinkering
1064  * around with ARCH_KMALLOC_MINALIGN
1065  */
1066 void __init setup_kmalloc_cache_index_table(void)
1067 {
1068         int i;
1069
1070         BUILD_BUG_ON(KMALLOC_MIN_SIZE > 256 ||
1071                 (KMALLOC_MIN_SIZE & (KMALLOC_MIN_SIZE - 1)));
1072
1073         for (i = 8; i < KMALLOC_MIN_SIZE; i += 8) {
1074                 int elem = size_index_elem(i);
1075
1076                 if (elem >= ARRAY_SIZE(size_index))
1077                         break;
1078                 size_index[elem] = KMALLOC_SHIFT_LOW;
1079         }
1080
1081         if (KMALLOC_MIN_SIZE >= 64) {
1082                 /*
1083                  * The 96 byte size cache is not used if the alignment
1084                  * is 64 byte.
1085                  */
1086                 for (i = 64 + 8; i <= 96; i += 8)
1087                         size_index[size_index_elem(i)] = 7;
1088
1089         }
1090
1091         if (KMALLOC_MIN_SIZE >= 128) {
1092                 /*
1093                  * The 192 byte sized cache is not used if the alignment
1094                  * is 128 byte. Redirect kmalloc to use the 256 byte cache
1095                  * instead.
1096                  */
1097                 for (i = 128 + 8; i <= 192; i += 8)
1098                         size_index[size_index_elem(i)] = 8;
1099         }
1100 }
1101
1102 static void __init new_kmalloc_cache(int idx, slab_flags_t flags)
1103 {
1104         kmalloc_caches[idx] = create_kmalloc_cache(kmalloc_info[idx].name,
1105                                         kmalloc_info[idx].size, flags, 0,
1106                                         kmalloc_info[idx].size);
1107 }
1108
1109 /*
1110  * Create the kmalloc array. Some of the regular kmalloc arrays
1111  * may already have been created because they were needed to
1112  * enable allocations for slab creation.
1113  */
1114 void __init create_kmalloc_caches(slab_flags_t flags)
1115 {
1116         int i;
1117
1118         for (i = KMALLOC_SHIFT_LOW; i <= KMALLOC_SHIFT_HIGH; i++) {
1119                 if (!kmalloc_caches[i])
1120                         new_kmalloc_cache(i, flags);
1121
1122                 /*
1123                  * Caches that are not of the two-to-the-power-of size.
1124                  * These have to be created immediately after the
1125                  * earlier power of two caches
1126                  */
1127                 if (KMALLOC_MIN_SIZE <= 32 && !kmalloc_caches[1] && i == 6)
1128                         new_kmalloc_cache(1, flags);
1129                 if (KMALLOC_MIN_SIZE <= 64 && !kmalloc_caches[2] && i == 7)
1130                         new_kmalloc_cache(2, flags);
1131         }
1132
1133         /* Kmalloc array is now usable */
1134         slab_state = UP;
1135
1136 #ifdef CONFIG_ZONE_DMA
1137         for (i = 0; i <= KMALLOC_SHIFT_HIGH; i++) {
1138                 struct kmem_cache *s = kmalloc_caches[i];
1139
1140                 if (s) {
1141                         int size = kmalloc_size(i);
1142                         char *n = kasprintf(GFP_NOWAIT,
1143                                  "dma-kmalloc-%d", size);
1144
1145                         BUG_ON(!n);
1146                         kmalloc_dma_caches[i] = create_kmalloc_cache(n,
1147                                 size, SLAB_CACHE_DMA | flags, 0, 0);
1148                 }
1149         }
1150 #endif
1151 }
1152 #endif /* !CONFIG_SLOB */
1153
1154 /*
1155  * To avoid unnecessary overhead, we pass through large allocation requests
1156  * directly to the page allocator. We use __GFP_COMP, because we will need to
1157  * know the allocation order to free the pages properly in kfree.
1158  */
1159 void *kmalloc_order(size_t size, gfp_t flags, unsigned int order)
1160 {
1161         void *ret;
1162         struct page *page;
1163
1164         flags |= __GFP_COMP;
1165         page = alloc_pages(flags, order);
1166         ret = page ? page_address(page) : NULL;
1167         kmemleak_alloc(ret, size, 1, flags);
1168         kasan_kmalloc_large(ret, size, flags);
1169         return ret;
1170 }
1171 EXPORT_SYMBOL(kmalloc_order);
1172
1173 #ifdef CONFIG_TRACING
1174 void *kmalloc_order_trace(size_t size, gfp_t flags, unsigned int order)
1175 {
1176         void *ret = kmalloc_order(size, flags, order);
1177         trace_kmalloc(_RET_IP_, ret, size, PAGE_SIZE << order, flags);
1178         return ret;
1179 }
1180 EXPORT_SYMBOL(kmalloc_order_trace);
1181 #endif
1182
1183 #ifdef CONFIG_SLAB_FREELIST_RANDOM
1184 /* Randomize a generic freelist */
1185 static void freelist_randomize(struct rnd_state *state, unsigned int *list,
1186                         size_t count)
1187 {
1188         size_t i;
1189         unsigned int rand;
1190
1191         for (i = 0; i < count; i++)
1192                 list[i] = i;
1193
1194         /* Fisher-Yates shuffle */
1195         for (i = count - 1; i > 0; i--) {
1196                 rand = prandom_u32_state(state);
1197                 rand %= (i + 1);
1198                 swap(list[i], list[rand]);
1199         }
1200 }
1201
1202 /* Create a random sequence per cache */
1203 int cache_random_seq_create(struct kmem_cache *cachep, unsigned int count,
1204                                     gfp_t gfp)
1205 {
1206         struct rnd_state state;
1207
1208         if (count < 2 || cachep->random_seq)
1209                 return 0;
1210
1211         cachep->random_seq = kcalloc(count, sizeof(unsigned int), gfp);
1212         if (!cachep->random_seq)
1213                 return -ENOMEM;
1214
1215         /* Get best entropy at this stage of boot */
1216         prandom_seed_state(&state, get_random_long());
1217
1218         freelist_randomize(&state, cachep->random_seq, count);
1219         return 0;
1220 }
1221
1222 /* Destroy the per-cache random freelist sequence */
1223 void cache_random_seq_destroy(struct kmem_cache *cachep)
1224 {
1225         kfree(cachep->random_seq);
1226         cachep->random_seq = NULL;
1227 }
1228 #endif /* CONFIG_SLAB_FREELIST_RANDOM */
1229
1230 #if defined(CONFIG_SLAB) || defined(CONFIG_SLUB_DEBUG)
1231 #ifdef CONFIG_SLAB
1232 #define SLABINFO_RIGHTS (S_IWUSR | S_IRUSR)
1233 #else
1234 #define SLABINFO_RIGHTS S_IRUSR
1235 #endif
1236
1237 static void print_slabinfo_header(struct seq_file *m)
1238 {
1239         /*
1240          * Output format version, so at least we can change it
1241          * without _too_ many complaints.
1242          */
1243 #ifdef CONFIG_DEBUG_SLAB
1244         seq_puts(m, "slabinfo - version: 2.1 (statistics)\n");
1245 #else
1246         seq_puts(m, "slabinfo - version: 2.1\n");
1247 #endif
1248         seq_puts(m, "# name            <active_objs> <num_objs> <objsize> <objperslab> <pagesperslab>");
1249         seq_puts(m, " : tunables <limit> <batchcount> <sharedfactor>");
1250         seq_puts(m, " : slabdata <active_slabs> <num_slabs> <sharedavail>");
1251 #ifdef CONFIG_DEBUG_SLAB
1252         seq_puts(m, " : globalstat <listallocs> <maxobjs> <grown> <reaped> <error> <maxfreeable> <nodeallocs> <remotefrees> <alienoverflow>");
1253         seq_puts(m, " : cpustat <allochit> <allocmiss> <freehit> <freemiss>");
1254 #endif
1255         seq_putc(m, '\n');
1256 }
1257
1258 void *slab_start(struct seq_file *m, loff_t *pos)
1259 {
1260         mutex_lock(&slab_mutex);
1261         return seq_list_start(&slab_root_caches, *pos);
1262 }
1263
1264 void *slab_next(struct seq_file *m, void *p, loff_t *pos)
1265 {
1266         return seq_list_next(p, &slab_root_caches, pos);
1267 }
1268
1269 void slab_stop(struct seq_file *m, void *p)
1270 {
1271         mutex_unlock(&slab_mutex);
1272 }
1273
1274 static void
1275 memcg_accumulate_slabinfo(struct kmem_cache *s, struct slabinfo *info)
1276 {
1277         struct kmem_cache *c;
1278         struct slabinfo sinfo;
1279
1280         if (!is_root_cache(s))
1281                 return;
1282
1283         for_each_memcg_cache(c, s) {
1284                 memset(&sinfo, 0, sizeof(sinfo));
1285                 get_slabinfo(c, &sinfo);
1286
1287                 info->active_slabs += sinfo.active_slabs;
1288                 info->num_slabs += sinfo.num_slabs;
1289                 info->shared_avail += sinfo.shared_avail;
1290                 info->active_objs += sinfo.active_objs;
1291                 info->num_objs += sinfo.num_objs;
1292         }
1293 }
1294
1295 static void cache_show(struct kmem_cache *s, struct seq_file *m)
1296 {
1297         struct slabinfo sinfo;
1298
1299         memset(&sinfo, 0, sizeof(sinfo));
1300         get_slabinfo(s, &sinfo);
1301
1302         memcg_accumulate_slabinfo(s, &sinfo);
1303
1304         seq_printf(m, "%-17s %6lu %6lu %6u %4u %4d",
1305                    cache_name(s), sinfo.active_objs, sinfo.num_objs, s->size,
1306                    sinfo.objects_per_slab, (1 << sinfo.cache_order));
1307
1308         seq_printf(m, " : tunables %4u %4u %4u",
1309                    sinfo.limit, sinfo.batchcount, sinfo.shared);
1310         seq_printf(m, " : slabdata %6lu %6lu %6lu",
1311                    sinfo.active_slabs, sinfo.num_slabs, sinfo.shared_avail);
1312         slabinfo_show_stats(m, s);
1313         seq_putc(m, '\n');
1314 }
1315
1316 static int slab_show(struct seq_file *m, void *p)
1317 {
1318         struct kmem_cache *s = list_entry(p, struct kmem_cache, root_caches_node);
1319
1320         if (p == slab_root_caches.next)
1321                 print_slabinfo_header(m);
1322         cache_show(s, m);
1323         return 0;
1324 }
1325
1326 void dump_unreclaimable_slab(void)
1327 {
1328         struct kmem_cache *s, *s2;
1329         struct slabinfo sinfo;
1330
1331         /*
1332          * Here acquiring slab_mutex is risky since we don't prefer to get
1333          * sleep in oom path. But, without mutex hold, it may introduce a
1334          * risk of crash.
1335          * Use mutex_trylock to protect the list traverse, dump nothing
1336          * without acquiring the mutex.
1337          */
1338         if (!mutex_trylock(&slab_mutex)) {
1339                 pr_warn("excessive unreclaimable slab but cannot dump stats\n");
1340                 return;
1341         }
1342
1343         pr_info("Unreclaimable slab info:\n");
1344         pr_info("Name                      Used          Total\n");
1345
1346         list_for_each_entry_safe(s, s2, &slab_caches, list) {
1347                 if (!is_root_cache(s) || (s->flags & SLAB_RECLAIM_ACCOUNT))
1348                         continue;
1349
1350                 get_slabinfo(s, &sinfo);
1351
1352                 if (sinfo.num_objs > 0)
1353                         pr_info("%-17s %10luKB %10luKB\n", cache_name(s),
1354                                 (sinfo.active_objs * s->size) / 1024,
1355                                 (sinfo.num_objs * s->size) / 1024);
1356         }
1357         mutex_unlock(&slab_mutex);
1358 }
1359
1360 #if defined(CONFIG_MEMCG)
1361 void *memcg_slab_start(struct seq_file *m, loff_t *pos)
1362 {
1363         struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m));
1364
1365         mutex_lock(&slab_mutex);
1366         return seq_list_start(&memcg->kmem_caches, *pos);
1367 }
1368
1369 void *memcg_slab_next(struct seq_file *m, void *p, loff_t *pos)
1370 {
1371         struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m));
1372
1373         return seq_list_next(p, &memcg->kmem_caches, pos);
1374 }
1375
1376 void memcg_slab_stop(struct seq_file *m, void *p)
1377 {
1378         mutex_unlock(&slab_mutex);
1379 }
1380
1381 int memcg_slab_show(struct seq_file *m, void *p)
1382 {
1383         struct kmem_cache *s = list_entry(p, struct kmem_cache,
1384                                           memcg_params.kmem_caches_node);
1385         struct mem_cgroup *memcg = mem_cgroup_from_css(seq_css(m));
1386
1387         if (p == memcg->kmem_caches.next)
1388                 print_slabinfo_header(m);
1389         cache_show(s, m);
1390         return 0;
1391 }
1392 #endif
1393
1394 /*
1395  * slabinfo_op - iterator that generates /proc/slabinfo
1396  *
1397  * Output layout:
1398  * cache-name
1399  * num-active-objs
1400  * total-objs
1401  * object size
1402  * num-active-slabs
1403  * total-slabs
1404  * num-pages-per-slab
1405  * + further values on SMP and with statistics enabled
1406  */
1407 static const struct seq_operations slabinfo_op = {
1408         .start = slab_start,
1409         .next = slab_next,
1410         .stop = slab_stop,
1411         .show = slab_show,
1412 };
1413
1414 static int slabinfo_open(struct inode *inode, struct file *file)
1415 {
1416         return seq_open(file, &slabinfo_op);
1417 }
1418
1419 static const struct file_operations proc_slabinfo_operations = {
1420         .open           = slabinfo_open,
1421         .read           = seq_read,
1422         .write          = slabinfo_write,
1423         .llseek         = seq_lseek,
1424         .release        = seq_release,
1425 };
1426
1427 static int __init slab_proc_init(void)
1428 {
1429         proc_create("slabinfo", SLABINFO_RIGHTS, NULL,
1430                                                 &proc_slabinfo_operations);
1431         return 0;
1432 }
1433 module_init(slab_proc_init);
1434 #endif /* CONFIG_SLAB || CONFIG_SLUB_DEBUG */
1435
1436 static __always_inline void *__do_krealloc(const void *p, size_t new_size,
1437                                            gfp_t flags)
1438 {
1439         void *ret;
1440         size_t ks = 0;
1441
1442         if (p)
1443                 ks = ksize(p);
1444
1445         if (ks >= new_size) {
1446                 kasan_krealloc((void *)p, new_size, flags);
1447                 return (void *)p;
1448         }
1449
1450         ret = kmalloc_track_caller(new_size, flags);
1451         if (ret && p)
1452                 memcpy(ret, p, ks);
1453
1454         return ret;
1455 }
1456
1457 /**
1458  * __krealloc - like krealloc() but don't free @p.
1459  * @p: object to reallocate memory for.
1460  * @new_size: how many bytes of memory are required.
1461  * @flags: the type of memory to allocate.
1462  *
1463  * This function is like krealloc() except it never frees the originally
1464  * allocated buffer. Use this if you don't want to free the buffer immediately
1465  * like, for example, with RCU.
1466  */
1467 void *__krealloc(const void *p, size_t new_size, gfp_t flags)
1468 {
1469         if (unlikely(!new_size))
1470                 return ZERO_SIZE_PTR;
1471
1472         return __do_krealloc(p, new_size, flags);
1473
1474 }
1475 EXPORT_SYMBOL(__krealloc);
1476
1477 /**
1478  * krealloc - reallocate memory. The contents will remain unchanged.
1479  * @p: object to reallocate memory for.
1480  * @new_size: how many bytes of memory are required.
1481  * @flags: the type of memory to allocate.
1482  *
1483  * The contents of the object pointed to are preserved up to the
1484  * lesser of the new and old sizes.  If @p is %NULL, krealloc()
1485  * behaves exactly like kmalloc().  If @new_size is 0 and @p is not a
1486  * %NULL pointer, the object pointed to is freed.
1487  */
1488 void *krealloc(const void *p, size_t new_size, gfp_t flags)
1489 {
1490         void *ret;
1491
1492         if (unlikely(!new_size)) {
1493                 kfree(p);
1494                 return ZERO_SIZE_PTR;
1495         }
1496
1497         ret = __do_krealloc(p, new_size, flags);
1498         if (ret && p != ret)
1499                 kfree(p);
1500
1501         return ret;
1502 }
1503 EXPORT_SYMBOL(krealloc);
1504
1505 /**
1506  * kzfree - like kfree but zero memory
1507  * @p: object to free memory of
1508  *
1509  * The memory of the object @p points to is zeroed before freed.
1510  * If @p is %NULL, kzfree() does nothing.
1511  *
1512  * Note: this function zeroes the whole allocated buffer which can be a good
1513  * deal bigger than the requested buffer size passed to kmalloc(). So be
1514  * careful when using this function in performance sensitive code.
1515  */
1516 void kzfree(const void *p)
1517 {
1518         size_t ks;
1519         void *mem = (void *)p;
1520
1521         if (unlikely(ZERO_OR_NULL_PTR(mem)))
1522                 return;
1523         ks = ksize(mem);
1524         memset(mem, 0, ks);
1525         kfree(mem);
1526 }
1527 EXPORT_SYMBOL(kzfree);
1528
1529 /* Tracepoints definitions. */
1530 EXPORT_TRACEPOINT_SYMBOL(kmalloc);
1531 EXPORT_TRACEPOINT_SYMBOL(kmem_cache_alloc);
1532 EXPORT_TRACEPOINT_SYMBOL(kmalloc_node);
1533 EXPORT_TRACEPOINT_SYMBOL(kmem_cache_alloc_node);
1534 EXPORT_TRACEPOINT_SYMBOL(kfree);
1535 EXPORT_TRACEPOINT_SYMBOL(kmem_cache_free);