xref: /openbmc/linux/mm/slab.h (revision a6978d1b7bb8f3a25305e8ff7d367f7289614c5d)
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   */
176  static inline bool slab_test_pfmemalloc(const struct slab *slab)
177  {
178  	return folio_test_active((struct folio *)slab_folio(slab));
179  }
180  
181  static inline void slab_set_pfmemalloc(struct slab *slab)
182  {
183  	folio_set_active(slab_folio(slab));
184  }
185  
186  static inline void slab_clear_pfmemalloc(struct slab *slab)
187  {
188  	folio_clear_active(slab_folio(slab));
189  }
190  
191  static inline void __slab_clear_pfmemalloc(struct slab *slab)
192  {
193  	__folio_clear_active(slab_folio(slab));
194  }
195  
196  static inline void *slab_address(const struct slab *slab)
197  {
198  	return folio_address(slab_folio(slab));
199  }
200  
201  static inline int slab_nid(const struct slab *slab)
202  {
203  	return folio_nid(slab_folio(slab));
204  }
205  
206  static inline pg_data_t *slab_pgdat(const struct slab *slab)
207  {
208  	return folio_pgdat(slab_folio(slab));
209  }
210  
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  
221  static inline int slab_order(const struct slab *slab)
222  {
223  	return folio_order((struct folio *)slab_folio(slab));
224  }
225  
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  
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  
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);
404  static inline bool __slub_debug_enabled(void)
405  {
406  	return static_branch_unlikely(&slub_debug_enabled);
407  }
408  #else
409  static inline void print_tracking(struct kmem_cache *s, void *object)
410  {
411  }
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   */
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   */
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  
456  static inline void memcg_free_slab_cgroups(struct slab *slab)
457  {
458  	kfree(slab_objcgs(slab));
459  	slab->memcg_data = 0;
460  }
461  
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   */
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  
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  
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 */
579  static inline struct obj_cgroup **slab_objcgs(struct slab *slab)
580  {
581  	return NULL;
582  }
583  
584  static inline struct mem_cgroup *memcg_from_slab_obj(void *ptr)
585  {
586  	return NULL;
587  }
588  
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  
596  static inline void memcg_free_slab_cgroups(struct slab *slab)
597  {
598  }
599  
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  
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  
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  
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  
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  
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  
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  
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  
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  
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  
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
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
835  static inline int cache_random_seq_create(struct kmem_cache *cachep,
836  					unsigned int count, gfp_t gfp)
837  {
838  	return 0;
839  }
840  static inline void cache_random_seq_destroy(struct kmem_cache *cachep) { }
841  #endif /* CONFIG_SLAB_FREELIST_RANDOM */
842  
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  
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
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