xref: /openbmc/linux/mm/slab.h (revision 3c615294)
1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef MM_SLAB_H
3 #define MM_SLAB_H
4 /*
5  * Internal slab definitions
6  */
7 void __init kmem_cache_init(void);
8 
9 #ifdef CONFIG_64BIT
10 # ifdef system_has_cmpxchg128
11 # define system_has_freelist_aba()	system_has_cmpxchg128()
12 # define try_cmpxchg_freelist		try_cmpxchg128
13 # endif
14 #define this_cpu_try_cmpxchg_freelist	this_cpu_try_cmpxchg128
15 typedef u128 freelist_full_t;
16 #else /* CONFIG_64BIT */
17 # ifdef system_has_cmpxchg64
18 # define system_has_freelist_aba()	system_has_cmpxchg64()
19 # define try_cmpxchg_freelist		try_cmpxchg64
20 # endif
21 #define this_cpu_try_cmpxchg_freelist	this_cpu_try_cmpxchg64
22 typedef u64 freelist_full_t;
23 #endif /* CONFIG_64BIT */
24 
25 #if defined(system_has_freelist_aba) && !defined(CONFIG_HAVE_ALIGNED_STRUCT_PAGE)
26 #undef system_has_freelist_aba
27 #endif
28 
29 /*
30  * Freelist pointer and counter to cmpxchg together, avoids the typical ABA
31  * problems with cmpxchg of just a pointer.
32  */
33 typedef union {
34 	struct {
35 		void *freelist;
36 		unsigned long counter;
37 	};
38 	freelist_full_t full;
39 } freelist_aba_t;
40 
41 /* Reuses the bits in struct page */
42 struct slab {
43 	unsigned long __page_flags;
44 
45 #if defined(CONFIG_SLAB)
46 
47 	struct kmem_cache *slab_cache;
48 	union {
49 		struct {
50 			struct list_head slab_list;
51 			void *freelist;	/* array of free object indexes */
52 			void *s_mem;	/* first object */
53 		};
54 		struct rcu_head rcu_head;
55 	};
56 	unsigned int active;
57 
58 #elif defined(CONFIG_SLUB)
59 
60 	struct kmem_cache *slab_cache;
61 	union {
62 		struct {
63 			union {
64 				struct list_head slab_list;
65 #ifdef CONFIG_SLUB_CPU_PARTIAL
66 				struct {
67 					struct slab *next;
68 					int slabs;	/* Nr of slabs left */
69 				};
70 #endif
71 			};
72 			/* Double-word boundary */
73 			union {
74 				struct {
75 					void *freelist;		/* first free object */
76 					union {
77 						unsigned long counters;
78 						struct {
79 							unsigned inuse:16;
80 							unsigned objects:15;
81 							unsigned frozen:1;
82 						};
83 					};
84 				};
85 #ifdef system_has_freelist_aba
86 				freelist_aba_t freelist_counter;
87 #endif
88 			};
89 		};
90 		struct rcu_head rcu_head;
91 	};
92 	unsigned int __unused;
93 
94 #else
95 #error "Unexpected slab allocator configured"
96 #endif
97 
98 	atomic_t __page_refcount;
99 #ifdef CONFIG_MEMCG
100 	unsigned long memcg_data;
101 #endif
102 };
103 
104 #define SLAB_MATCH(pg, sl)						\
105 	static_assert(offsetof(struct page, pg) == offsetof(struct slab, sl))
106 SLAB_MATCH(flags, __page_flags);
107 SLAB_MATCH(compound_head, slab_cache);	/* Ensure bit 0 is clear */
108 SLAB_MATCH(_refcount, __page_refcount);
109 #ifdef CONFIG_MEMCG
110 SLAB_MATCH(memcg_data, memcg_data);
111 #endif
112 #undef SLAB_MATCH
113 static_assert(sizeof(struct slab) <= sizeof(struct page));
114 #if defined(system_has_freelist_aba) && defined(CONFIG_SLUB)
115 static_assert(IS_ALIGNED(offsetof(struct slab, freelist), sizeof(freelist_aba_t)));
116 #endif
117 
118 /**
119  * folio_slab - Converts from folio to slab.
120  * @folio: The folio.
121  *
122  * Currently struct slab is a different representation of a folio where
123  * folio_test_slab() is true.
124  *
125  * Return: The slab which contains this folio.
126  */
127 #define folio_slab(folio)	(_Generic((folio),			\
128 	const struct folio *:	(const struct slab *)(folio),		\
129 	struct folio *:		(struct slab *)(folio)))
130 
131 /**
132  * slab_folio - The folio allocated for a slab
133  * @slab: The slab.
134  *
135  * Slabs are allocated as folios that contain the individual objects and are
136  * using some fields in the first struct page of the folio - those fields are
137  * now accessed by struct slab. It is occasionally necessary to convert back to
138  * a folio in order to communicate with the rest of the mm.  Please use this
139  * helper function instead of casting yourself, as the implementation may change
140  * in the future.
141  */
142 #define slab_folio(s)		(_Generic((s),				\
143 	const struct slab *:	(const struct folio *)s,		\
144 	struct slab *:		(struct folio *)s))
145 
146 /**
147  * page_slab - Converts from first struct page to slab.
148  * @p: The first (either head of compound or single) page of slab.
149  *
150  * A temporary wrapper to convert struct page to struct slab in situations where
151  * we know the page is the compound head, or single order-0 page.
152  *
153  * Long-term ideally everything would work with struct slab directly or go
154  * through folio to struct slab.
155  *
156  * Return: The slab which contains this page
157  */
158 #define page_slab(p)		(_Generic((p),				\
159 	const struct page *:	(const struct slab *)(p),		\
160 	struct page *:		(struct slab *)(p)))
161 
162 /**
163  * slab_page - The first struct page allocated for a slab
164  * @slab: The slab.
165  *
166  * A convenience wrapper for converting slab to the first struct page of the
167  * underlying folio, to communicate with code not yet converted to folio or
168  * struct slab.
169  */
170 #define slab_page(s) folio_page(slab_folio(s), 0)
171 
172 /*
173  * If network-based swap is enabled, sl*b must keep track of whether pages
174  * were allocated from pfmemalloc reserves.
175  */
slab_test_pfmemalloc(const struct slab * slab)176 static inline bool slab_test_pfmemalloc(const struct slab *slab)
177 {
178 	return folio_test_active((struct folio *)slab_folio(slab));
179 }
180 
slab_set_pfmemalloc(struct slab * slab)181 static inline void slab_set_pfmemalloc(struct slab *slab)
182 {
183 	folio_set_active(slab_folio(slab));
184 }
185 
slab_clear_pfmemalloc(struct slab * slab)186 static inline void slab_clear_pfmemalloc(struct slab *slab)
187 {
188 	folio_clear_active(slab_folio(slab));
189 }
190 
__slab_clear_pfmemalloc(struct slab * slab)191 static inline void __slab_clear_pfmemalloc(struct slab *slab)
192 {
193 	__folio_clear_active(slab_folio(slab));
194 }
195 
slab_address(const struct slab * slab)196 static inline void *slab_address(const struct slab *slab)
197 {
198 	return folio_address(slab_folio(slab));
199 }
200 
slab_nid(const struct slab * slab)201 static inline int slab_nid(const struct slab *slab)
202 {
203 	return folio_nid(slab_folio(slab));
204 }
205 
slab_pgdat(const struct slab * slab)206 static inline pg_data_t *slab_pgdat(const struct slab *slab)
207 {
208 	return folio_pgdat(slab_folio(slab));
209 }
210 
virt_to_slab(const void * addr)211 static inline struct slab *virt_to_slab(const void *addr)
212 {
213 	struct folio *folio = virt_to_folio(addr);
214 
215 	if (!folio_test_slab(folio))
216 		return NULL;
217 
218 	return folio_slab(folio);
219 }
220 
slab_order(const struct slab * slab)221 static inline int slab_order(const struct slab *slab)
222 {
223 	return folio_order((struct folio *)slab_folio(slab));
224 }
225 
slab_size(const struct slab * slab)226 static inline size_t slab_size(const struct slab *slab)
227 {
228 	return PAGE_SIZE << slab_order(slab);
229 }
230 
231 #ifdef CONFIG_SLAB
232 #include <linux/slab_def.h>
233 #endif
234 
235 #ifdef CONFIG_SLUB
236 #include <linux/slub_def.h>
237 #endif
238 
239 #include <linux/memcontrol.h>
240 #include <linux/fault-inject.h>
241 #include <linux/kasan.h>
242 #include <linux/kmemleak.h>
243 #include <linux/random.h>
244 #include <linux/sched/mm.h>
245 #include <linux/list_lru.h>
246 
247 /*
248  * State of the slab allocator.
249  *
250  * This is used to describe the states of the allocator during bootup.
251  * Allocators use this to gradually bootstrap themselves. Most allocators
252  * have the problem that the structures used for managing slab caches are
253  * allocated from slab caches themselves.
254  */
255 enum slab_state {
256 	DOWN,			/* No slab functionality yet */
257 	PARTIAL,		/* SLUB: kmem_cache_node available */
258 	PARTIAL_NODE,		/* SLAB: kmalloc size for node struct available */
259 	UP,			/* Slab caches usable but not all extras yet */
260 	FULL			/* Everything is working */
261 };
262 
263 extern enum slab_state slab_state;
264 
265 /* The slab cache mutex protects the management structures during changes */
266 extern struct mutex slab_mutex;
267 
268 /* The list of all slab caches on the system */
269 extern struct list_head slab_caches;
270 
271 /* The slab cache that manages slab cache information */
272 extern struct kmem_cache *kmem_cache;
273 
274 /* A table of kmalloc cache names and sizes */
275 extern const struct kmalloc_info_struct {
276 	const char *name[NR_KMALLOC_TYPES];
277 	unsigned int size;
278 } kmalloc_info[];
279 
280 /* Kmalloc array related functions */
281 void setup_kmalloc_cache_index_table(void);
282 void create_kmalloc_caches(slab_flags_t);
283 
284 /* Find the kmalloc slab corresponding for a certain size */
285 struct kmem_cache *kmalloc_slab(size_t size, gfp_t flags, unsigned long caller);
286 
287 void *__kmem_cache_alloc_node(struct kmem_cache *s, gfp_t gfpflags,
288 			      int node, size_t orig_size,
289 			      unsigned long caller);
290 void __kmem_cache_free(struct kmem_cache *s, void *x, unsigned long caller);
291 
292 gfp_t kmalloc_fix_flags(gfp_t flags);
293 
294 /* Functions provided by the slab allocators */
295 int __kmem_cache_create(struct kmem_cache *, slab_flags_t flags);
296 
297 void __init new_kmalloc_cache(int idx, enum kmalloc_cache_type type,
298 			      slab_flags_t flags);
299 extern void create_boot_cache(struct kmem_cache *, const char *name,
300 			unsigned int size, slab_flags_t flags,
301 			unsigned int useroffset, unsigned int usersize);
302 
303 int slab_unmergeable(struct kmem_cache *s);
304 struct kmem_cache *find_mergeable(unsigned size, unsigned align,
305 		slab_flags_t flags, const char *name, void (*ctor)(void *));
306 struct kmem_cache *
307 __kmem_cache_alias(const char *name, unsigned int size, unsigned int align,
308 		   slab_flags_t flags, void (*ctor)(void *));
309 
310 slab_flags_t kmem_cache_flags(unsigned int object_size,
311 	slab_flags_t flags, const char *name);
312 
is_kmalloc_cache(struct kmem_cache * s)313 static inline bool is_kmalloc_cache(struct kmem_cache *s)
314 {
315 	return (s->flags & SLAB_KMALLOC);
316 }
317 
318 /* Legal flag mask for kmem_cache_create(), for various configurations */
319 #define SLAB_CORE_FLAGS (SLAB_HWCACHE_ALIGN | SLAB_CACHE_DMA | \
320 			 SLAB_CACHE_DMA32 | SLAB_PANIC | \
321 			 SLAB_TYPESAFE_BY_RCU | SLAB_DEBUG_OBJECTS )
322 
323 #if defined(CONFIG_DEBUG_SLAB)
324 #define SLAB_DEBUG_FLAGS (SLAB_RED_ZONE | SLAB_POISON | SLAB_STORE_USER)
325 #elif defined(CONFIG_SLUB_DEBUG)
326 #define SLAB_DEBUG_FLAGS (SLAB_RED_ZONE | SLAB_POISON | SLAB_STORE_USER | \
327 			  SLAB_TRACE | SLAB_CONSISTENCY_CHECKS)
328 #else
329 #define SLAB_DEBUG_FLAGS (0)
330 #endif
331 
332 #if defined(CONFIG_SLAB)
333 #define SLAB_CACHE_FLAGS (SLAB_MEM_SPREAD | SLAB_NOLEAKTRACE | \
334 			  SLAB_RECLAIM_ACCOUNT | SLAB_TEMPORARY | \
335 			  SLAB_ACCOUNT | SLAB_NO_MERGE)
336 #elif defined(CONFIG_SLUB)
337 #define SLAB_CACHE_FLAGS (SLAB_NOLEAKTRACE | SLAB_RECLAIM_ACCOUNT | \
338 			  SLAB_TEMPORARY | SLAB_ACCOUNT | \
339 			  SLAB_NO_USER_FLAGS | SLAB_KMALLOC | SLAB_NO_MERGE)
340 #else
341 #define SLAB_CACHE_FLAGS (SLAB_NOLEAKTRACE)
342 #endif
343 
344 /* Common flags available with current configuration */
345 #define CACHE_CREATE_MASK (SLAB_CORE_FLAGS | SLAB_DEBUG_FLAGS | SLAB_CACHE_FLAGS)
346 
347 /* Common flags permitted for kmem_cache_create */
348 #define SLAB_FLAGS_PERMITTED (SLAB_CORE_FLAGS | \
349 			      SLAB_RED_ZONE | \
350 			      SLAB_POISON | \
351 			      SLAB_STORE_USER | \
352 			      SLAB_TRACE | \
353 			      SLAB_CONSISTENCY_CHECKS | \
354 			      SLAB_MEM_SPREAD | \
355 			      SLAB_NOLEAKTRACE | \
356 			      SLAB_RECLAIM_ACCOUNT | \
357 			      SLAB_TEMPORARY | \
358 			      SLAB_ACCOUNT | \
359 			      SLAB_KMALLOC | \
360 			      SLAB_NO_MERGE | \
361 			      SLAB_NO_USER_FLAGS)
362 
363 bool __kmem_cache_empty(struct kmem_cache *);
364 int __kmem_cache_shutdown(struct kmem_cache *);
365 void __kmem_cache_release(struct kmem_cache *);
366 int __kmem_cache_shrink(struct kmem_cache *);
367 void slab_kmem_cache_release(struct kmem_cache *);
368 
369 struct seq_file;
370 struct file;
371 
372 struct slabinfo {
373 	unsigned long active_objs;
374 	unsigned long num_objs;
375 	unsigned long active_slabs;
376 	unsigned long num_slabs;
377 	unsigned long shared_avail;
378 	unsigned int limit;
379 	unsigned int batchcount;
380 	unsigned int shared;
381 	unsigned int objects_per_slab;
382 	unsigned int cache_order;
383 };
384 
385 void get_slabinfo(struct kmem_cache *s, struct slabinfo *sinfo);
386 void slabinfo_show_stats(struct seq_file *m, struct kmem_cache *s);
387 ssize_t slabinfo_write(struct file *file, const char __user *buffer,
388 		       size_t count, loff_t *ppos);
389 
cache_vmstat_idx(struct kmem_cache * s)390 static inline enum node_stat_item cache_vmstat_idx(struct kmem_cache *s)
391 {
392 	return (s->flags & SLAB_RECLAIM_ACCOUNT) ?
393 		NR_SLAB_RECLAIMABLE_B : NR_SLAB_UNRECLAIMABLE_B;
394 }
395 
396 #ifdef CONFIG_SLUB_DEBUG
397 #ifdef CONFIG_SLUB_DEBUG_ON
398 DECLARE_STATIC_KEY_TRUE(slub_debug_enabled);
399 #else
400 DECLARE_STATIC_KEY_FALSE(slub_debug_enabled);
401 #endif
402 extern void print_tracking(struct kmem_cache *s, void *object);
403 long validate_slab_cache(struct kmem_cache *s);
__slub_debug_enabled(void)404 static inline bool __slub_debug_enabled(void)
405 {
406 	return static_branch_unlikely(&slub_debug_enabled);
407 }
408 #else
print_tracking(struct kmem_cache * s,void * object)409 static inline void print_tracking(struct kmem_cache *s, void *object)
410 {
411 }
__slub_debug_enabled(void)412 static inline bool __slub_debug_enabled(void)
413 {
414 	return false;
415 }
416 #endif
417 
418 /*
419  * Returns true if any of the specified slub_debug flags is enabled for the
420  * cache. Use only for flags parsed by setup_slub_debug() as it also enables
421  * the static key.
422  */
kmem_cache_debug_flags(struct kmem_cache * s,slab_flags_t flags)423 static inline bool kmem_cache_debug_flags(struct kmem_cache *s, slab_flags_t flags)
424 {
425 	if (IS_ENABLED(CONFIG_SLUB_DEBUG))
426 		VM_WARN_ON_ONCE(!(flags & SLAB_DEBUG_FLAGS));
427 	if (__slub_debug_enabled())
428 		return s->flags & flags;
429 	return false;
430 }
431 
432 #ifdef CONFIG_MEMCG_KMEM
433 /*
434  * slab_objcgs - get the object cgroups vector associated with a slab
435  * @slab: a pointer to the slab struct
436  *
437  * Returns a pointer to the object cgroups vector associated with the slab,
438  * or NULL if no such vector has been associated yet.
439  */
slab_objcgs(struct slab * slab)440 static inline struct obj_cgroup **slab_objcgs(struct slab *slab)
441 {
442 	unsigned long memcg_data = READ_ONCE(slab->memcg_data);
443 
444 	VM_BUG_ON_PAGE(memcg_data && !(memcg_data & MEMCG_DATA_OBJCGS),
445 							slab_page(slab));
446 	VM_BUG_ON_PAGE(memcg_data & MEMCG_DATA_KMEM, slab_page(slab));
447 
448 	return (struct obj_cgroup **)(memcg_data & ~MEMCG_DATA_FLAGS_MASK);
449 }
450 
451 int memcg_alloc_slab_cgroups(struct slab *slab, struct kmem_cache *s,
452 				 gfp_t gfp, bool new_slab);
453 void mod_objcg_state(struct obj_cgroup *objcg, struct pglist_data *pgdat,
454 		     enum node_stat_item idx, int nr);
455 
memcg_free_slab_cgroups(struct slab * slab)456 static inline void memcg_free_slab_cgroups(struct slab *slab)
457 {
458 	kfree(slab_objcgs(slab));
459 	slab->memcg_data = 0;
460 }
461 
obj_full_size(struct kmem_cache * s)462 static inline size_t obj_full_size(struct kmem_cache *s)
463 {
464 	/*
465 	 * For each accounted object there is an extra space which is used
466 	 * to store obj_cgroup membership. Charge it too.
467 	 */
468 	return s->size + sizeof(struct obj_cgroup *);
469 }
470 
471 /*
472  * Returns false if the allocation should fail.
473  */
memcg_slab_pre_alloc_hook(struct kmem_cache * s,struct list_lru * lru,struct obj_cgroup ** objcgp,size_t objects,gfp_t flags)474 static inline bool memcg_slab_pre_alloc_hook(struct kmem_cache *s,
475 					     struct list_lru *lru,
476 					     struct obj_cgroup **objcgp,
477 					     size_t objects, gfp_t flags)
478 {
479 	struct obj_cgroup *objcg;
480 
481 	if (!memcg_kmem_online())
482 		return true;
483 
484 	if (!(flags & __GFP_ACCOUNT) && !(s->flags & SLAB_ACCOUNT))
485 		return true;
486 
487 	objcg = get_obj_cgroup_from_current();
488 	if (!objcg)
489 		return true;
490 
491 	if (lru) {
492 		int ret;
493 		struct mem_cgroup *memcg;
494 
495 		memcg = get_mem_cgroup_from_objcg(objcg);
496 		ret = memcg_list_lru_alloc(memcg, lru, flags);
497 		css_put(&memcg->css);
498 
499 		if (ret)
500 			goto out;
501 	}
502 
503 	if (obj_cgroup_charge(objcg, flags, objects * obj_full_size(s)))
504 		goto out;
505 
506 	*objcgp = objcg;
507 	return true;
508 out:
509 	obj_cgroup_put(objcg);
510 	return false;
511 }
512 
memcg_slab_post_alloc_hook(struct kmem_cache * s,struct obj_cgroup * objcg,gfp_t flags,size_t size,void ** p)513 static inline void memcg_slab_post_alloc_hook(struct kmem_cache *s,
514 					      struct obj_cgroup *objcg,
515 					      gfp_t flags, size_t size,
516 					      void **p)
517 {
518 	struct slab *slab;
519 	unsigned long off;
520 	size_t i;
521 
522 	if (!memcg_kmem_online() || !objcg)
523 		return;
524 
525 	for (i = 0; i < size; i++) {
526 		if (likely(p[i])) {
527 			slab = virt_to_slab(p[i]);
528 
529 			if (!slab_objcgs(slab) &&
530 			    memcg_alloc_slab_cgroups(slab, s, flags,
531 							 false)) {
532 				obj_cgroup_uncharge(objcg, obj_full_size(s));
533 				continue;
534 			}
535 
536 			off = obj_to_index(s, slab, p[i]);
537 			obj_cgroup_get(objcg);
538 			slab_objcgs(slab)[off] = objcg;
539 			mod_objcg_state(objcg, slab_pgdat(slab),
540 					cache_vmstat_idx(s), obj_full_size(s));
541 		} else {
542 			obj_cgroup_uncharge(objcg, obj_full_size(s));
543 		}
544 	}
545 	obj_cgroup_put(objcg);
546 }
547 
memcg_slab_free_hook(struct kmem_cache * s,struct slab * slab,void ** p,int objects)548 static inline void memcg_slab_free_hook(struct kmem_cache *s, struct slab *slab,
549 					void **p, int objects)
550 {
551 	struct obj_cgroup **objcgs;
552 	int i;
553 
554 	if (!memcg_kmem_online())
555 		return;
556 
557 	objcgs = slab_objcgs(slab);
558 	if (!objcgs)
559 		return;
560 
561 	for (i = 0; i < objects; i++) {
562 		struct obj_cgroup *objcg;
563 		unsigned int off;
564 
565 		off = obj_to_index(s, slab, p[i]);
566 		objcg = objcgs[off];
567 		if (!objcg)
568 			continue;
569 
570 		objcgs[off] = NULL;
571 		obj_cgroup_uncharge(objcg, obj_full_size(s));
572 		mod_objcg_state(objcg, slab_pgdat(slab), cache_vmstat_idx(s),
573 				-obj_full_size(s));
574 		obj_cgroup_put(objcg);
575 	}
576 }
577 
578 #else /* CONFIG_MEMCG_KMEM */
slab_objcgs(struct slab * slab)579 static inline struct obj_cgroup **slab_objcgs(struct slab *slab)
580 {
581 	return NULL;
582 }
583 
memcg_from_slab_obj(void * ptr)584 static inline struct mem_cgroup *memcg_from_slab_obj(void *ptr)
585 {
586 	return NULL;
587 }
588 
memcg_alloc_slab_cgroups(struct slab * slab,struct kmem_cache * s,gfp_t gfp,bool new_slab)589 static inline int memcg_alloc_slab_cgroups(struct slab *slab,
590 					       struct kmem_cache *s, gfp_t gfp,
591 					       bool new_slab)
592 {
593 	return 0;
594 }
595 
memcg_free_slab_cgroups(struct slab * slab)596 static inline void memcg_free_slab_cgroups(struct slab *slab)
597 {
598 }
599 
memcg_slab_pre_alloc_hook(struct kmem_cache * s,struct list_lru * lru,struct obj_cgroup ** objcgp,size_t objects,gfp_t flags)600 static inline bool memcg_slab_pre_alloc_hook(struct kmem_cache *s,
601 					     struct list_lru *lru,
602 					     struct obj_cgroup **objcgp,
603 					     size_t objects, gfp_t flags)
604 {
605 	return true;
606 }
607 
memcg_slab_post_alloc_hook(struct kmem_cache * s,struct obj_cgroup * objcg,gfp_t flags,size_t size,void ** p)608 static inline void memcg_slab_post_alloc_hook(struct kmem_cache *s,
609 					      struct obj_cgroup *objcg,
610 					      gfp_t flags, size_t size,
611 					      void **p)
612 {
613 }
614 
memcg_slab_free_hook(struct kmem_cache * s,struct slab * slab,void ** p,int objects)615 static inline void memcg_slab_free_hook(struct kmem_cache *s, struct slab *slab,
616 					void **p, int objects)
617 {
618 }
619 #endif /* CONFIG_MEMCG_KMEM */
620 
virt_to_cache(const void * obj)621 static inline struct kmem_cache *virt_to_cache(const void *obj)
622 {
623 	struct slab *slab;
624 
625 	slab = virt_to_slab(obj);
626 	if (WARN_ONCE(!slab, "%s: Object is not a Slab page!\n",
627 					__func__))
628 		return NULL;
629 	return slab->slab_cache;
630 }
631 
account_slab(struct slab * slab,int order,struct kmem_cache * s,gfp_t gfp)632 static __always_inline void account_slab(struct slab *slab, int order,
633 					 struct kmem_cache *s, gfp_t gfp)
634 {
635 	if (memcg_kmem_online() && (s->flags & SLAB_ACCOUNT))
636 		memcg_alloc_slab_cgroups(slab, s, gfp, true);
637 
638 	mod_node_page_state(slab_pgdat(slab), cache_vmstat_idx(s),
639 			    PAGE_SIZE << order);
640 }
641 
unaccount_slab(struct slab * slab,int order,struct kmem_cache * s)642 static __always_inline void unaccount_slab(struct slab *slab, int order,
643 					   struct kmem_cache *s)
644 {
645 	if (memcg_kmem_online())
646 		memcg_free_slab_cgroups(slab);
647 
648 	mod_node_page_state(slab_pgdat(slab), cache_vmstat_idx(s),
649 			    -(PAGE_SIZE << order));
650 }
651 
cache_from_obj(struct kmem_cache * s,void * x)652 static inline struct kmem_cache *cache_from_obj(struct kmem_cache *s, void *x)
653 {
654 	struct kmem_cache *cachep;
655 
656 	if (!IS_ENABLED(CONFIG_SLAB_FREELIST_HARDENED) &&
657 	    !kmem_cache_debug_flags(s, SLAB_CONSISTENCY_CHECKS))
658 		return s;
659 
660 	cachep = virt_to_cache(x);
661 	if (WARN(cachep && cachep != s,
662 		  "%s: Wrong slab cache. %s but object is from %s\n",
663 		  __func__, s->name, cachep->name))
664 		print_tracking(cachep, x);
665 	return cachep;
666 }
667 
668 void free_large_kmalloc(struct folio *folio, void *object);
669 
670 size_t __ksize(const void *objp);
671 
slab_ksize(const struct kmem_cache * s)672 static inline size_t slab_ksize(const struct kmem_cache *s)
673 {
674 #ifndef CONFIG_SLUB
675 	return s->object_size;
676 
677 #else /* CONFIG_SLUB */
678 # ifdef CONFIG_SLUB_DEBUG
679 	/*
680 	 * Debugging requires use of the padding between object
681 	 * and whatever may come after it.
682 	 */
683 	if (s->flags & (SLAB_RED_ZONE | SLAB_POISON))
684 		return s->object_size;
685 # endif
686 	if (s->flags & SLAB_KASAN)
687 		return s->object_size;
688 	/*
689 	 * If we have the need to store the freelist pointer
690 	 * back there or track user information then we can
691 	 * only use the space before that information.
692 	 */
693 	if (s->flags & (SLAB_TYPESAFE_BY_RCU | SLAB_STORE_USER))
694 		return s->inuse;
695 	/*
696 	 * Else we can use all the padding etc for the allocation
697 	 */
698 	return s->size;
699 #endif
700 }
701 
slab_pre_alloc_hook(struct kmem_cache * s,struct list_lru * lru,struct obj_cgroup ** objcgp,size_t size,gfp_t flags)702 static inline struct kmem_cache *slab_pre_alloc_hook(struct kmem_cache *s,
703 						     struct list_lru *lru,
704 						     struct obj_cgroup **objcgp,
705 						     size_t size, gfp_t flags)
706 {
707 	flags &= gfp_allowed_mask;
708 
709 	might_alloc(flags);
710 
711 	if (should_failslab(s, flags))
712 		return NULL;
713 
714 	if (!memcg_slab_pre_alloc_hook(s, lru, objcgp, size, flags))
715 		return NULL;
716 
717 	return s;
718 }
719 
slab_post_alloc_hook(struct kmem_cache * s,struct obj_cgroup * objcg,gfp_t flags,size_t size,void ** p,bool init,unsigned int orig_size)720 static inline void slab_post_alloc_hook(struct kmem_cache *s,
721 					struct obj_cgroup *objcg, gfp_t flags,
722 					size_t size, void **p, bool init,
723 					unsigned int orig_size)
724 {
725 	unsigned int zero_size = s->object_size;
726 	bool kasan_init = init;
727 	size_t i;
728 
729 	flags &= gfp_allowed_mask;
730 
731 	/*
732 	 * For kmalloc object, the allocated memory size(object_size) is likely
733 	 * larger than the requested size(orig_size). If redzone check is
734 	 * enabled for the extra space, don't zero it, as it will be redzoned
735 	 * soon. The redzone operation for this extra space could be seen as a
736 	 * replacement of current poisoning under certain debug option, and
737 	 * won't break other sanity checks.
738 	 */
739 	if (kmem_cache_debug_flags(s, SLAB_STORE_USER | SLAB_RED_ZONE) &&
740 	    (s->flags & SLAB_KMALLOC))
741 		zero_size = orig_size;
742 
743 	/*
744 	 * When slub_debug is enabled, avoid memory initialization integrated
745 	 * into KASAN and instead zero out the memory via the memset below with
746 	 * the proper size. Otherwise, KASAN might overwrite SLUB redzones and
747 	 * cause false-positive reports. This does not lead to a performance
748 	 * penalty on production builds, as slub_debug is not intended to be
749 	 * enabled there.
750 	 */
751 	if (__slub_debug_enabled())
752 		kasan_init = false;
753 
754 	/*
755 	 * As memory initialization might be integrated into KASAN,
756 	 * kasan_slab_alloc and initialization memset must be
757 	 * kept together to avoid discrepancies in behavior.
758 	 *
759 	 * As p[i] might get tagged, memset and kmemleak hook come after KASAN.
760 	 */
761 	for (i = 0; i < size; i++) {
762 		p[i] = kasan_slab_alloc(s, p[i], flags, kasan_init);
763 		if (p[i] && init && (!kasan_init || !kasan_has_integrated_init()))
764 			memset(p[i], 0, zero_size);
765 		kmemleak_alloc_recursive(p[i], s->object_size, 1,
766 					 s->flags, flags);
767 		kmsan_slab_alloc(s, p[i], flags);
768 	}
769 
770 	memcg_slab_post_alloc_hook(s, objcg, flags, size, p);
771 }
772 
773 /*
774  * The slab lists for all objects.
775  */
776 struct kmem_cache_node {
777 #ifdef CONFIG_SLAB
778 	raw_spinlock_t list_lock;
779 	struct list_head slabs_partial;	/* partial list first, better asm code */
780 	struct list_head slabs_full;
781 	struct list_head slabs_free;
782 	unsigned long total_slabs;	/* length of all slab lists */
783 	unsigned long free_slabs;	/* length of free slab list only */
784 	unsigned long free_objects;
785 	unsigned int free_limit;
786 	unsigned int colour_next;	/* Per-node cache coloring */
787 	struct array_cache *shared;	/* shared per node */
788 	struct alien_cache **alien;	/* on other nodes */
789 	unsigned long next_reap;	/* updated without locking */
790 	int free_touched;		/* updated without locking */
791 #endif
792 
793 #ifdef CONFIG_SLUB
794 	spinlock_t list_lock;
795 	unsigned long nr_partial;
796 	struct list_head partial;
797 #ifdef CONFIG_SLUB_DEBUG
798 	atomic_long_t nr_slabs;
799 	atomic_long_t total_objects;
800 	struct list_head full;
801 #endif
802 #endif
803 
804 };
805 
get_node(struct kmem_cache * s,int node)806 static inline struct kmem_cache_node *get_node(struct kmem_cache *s, int node)
807 {
808 	return s->node[node];
809 }
810 
811 /*
812  * Iterator over all nodes. The body will be executed for each node that has
813  * a kmem_cache_node structure allocated (which is true for all online nodes)
814  */
815 #define for_each_kmem_cache_node(__s, __node, __n) \
816 	for (__node = 0; __node < nr_node_ids; __node++) \
817 		 if ((__n = get_node(__s, __node)))
818 
819 
820 #if defined(CONFIG_SLAB) || defined(CONFIG_SLUB_DEBUG)
821 void dump_unreclaimable_slab(void);
822 #else
dump_unreclaimable_slab(void)823 static inline void dump_unreclaimable_slab(void)
824 {
825 }
826 #endif
827 
828 void ___cache_free(struct kmem_cache *cache, void *x, unsigned long addr);
829 
830 #ifdef CONFIG_SLAB_FREELIST_RANDOM
831 int cache_random_seq_create(struct kmem_cache *cachep, unsigned int count,
832 			gfp_t gfp);
833 void cache_random_seq_destroy(struct kmem_cache *cachep);
834 #else
cache_random_seq_create(struct kmem_cache * cachep,unsigned int count,gfp_t gfp)835 static inline int cache_random_seq_create(struct kmem_cache *cachep,
836 					unsigned int count, gfp_t gfp)
837 {
838 	return 0;
839 }
cache_random_seq_destroy(struct kmem_cache * cachep)840 static inline void cache_random_seq_destroy(struct kmem_cache *cachep) { }
841 #endif /* CONFIG_SLAB_FREELIST_RANDOM */
842 
slab_want_init_on_alloc(gfp_t flags,struct kmem_cache * c)843 static inline bool slab_want_init_on_alloc(gfp_t flags, struct kmem_cache *c)
844 {
845 	if (static_branch_maybe(CONFIG_INIT_ON_ALLOC_DEFAULT_ON,
846 				&init_on_alloc)) {
847 		if (c->ctor)
848 			return false;
849 		if (c->flags & (SLAB_TYPESAFE_BY_RCU | SLAB_POISON))
850 			return flags & __GFP_ZERO;
851 		return true;
852 	}
853 	return flags & __GFP_ZERO;
854 }
855 
slab_want_init_on_free(struct kmem_cache * c)856 static inline bool slab_want_init_on_free(struct kmem_cache *c)
857 {
858 	if (static_branch_maybe(CONFIG_INIT_ON_FREE_DEFAULT_ON,
859 				&init_on_free))
860 		return !(c->ctor ||
861 			 (c->flags & (SLAB_TYPESAFE_BY_RCU | SLAB_POISON)));
862 	return false;
863 }
864 
865 #if defined(CONFIG_DEBUG_FS) && defined(CONFIG_SLUB_DEBUG)
866 void debugfs_slab_release(struct kmem_cache *);
867 #else
debugfs_slab_release(struct kmem_cache * s)868 static inline void debugfs_slab_release(struct kmem_cache *s) { }
869 #endif
870 
871 #ifdef CONFIG_PRINTK
872 #define KS_ADDRS_COUNT 16
873 struct kmem_obj_info {
874 	void *kp_ptr;
875 	struct slab *kp_slab;
876 	void *kp_objp;
877 	unsigned long kp_data_offset;
878 	struct kmem_cache *kp_slab_cache;
879 	void *kp_ret;
880 	void *kp_stack[KS_ADDRS_COUNT];
881 	void *kp_free_stack[KS_ADDRS_COUNT];
882 };
883 void __kmem_obj_info(struct kmem_obj_info *kpp, void *object, struct slab *slab);
884 #endif
885 
886 void __check_heap_object(const void *ptr, unsigned long n,
887 			 const struct slab *slab, bool to_user);
888 
889 #ifdef CONFIG_SLUB_DEBUG
890 void skip_orig_size_check(struct kmem_cache *s, const void *object);
891 #endif
892 
893 #endif /* MM_SLAB_H */
894