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