1 /* SPDX-License-Identifier: GPL-2.0-or-later */
2 /*
3  * Stack depot - a stack trace storage that avoids duplication.
4  *
5  * Stack depot is intended to be used by subsystems that need to store and
6  * later retrieve many potentially duplicated stack traces without wasting
7  * memory.
8  *
9  * For example, KASAN needs to save allocation and free stack traces for each
10  * object. Storing two stack traces per object requires a lot of memory (e.g.
11  * SLUB_DEBUG needs 256 bytes per object for that). Since allocation and free
12  * stack traces often repeat, using stack depot allows to save about 100x space.
13  *
14  * Stack traces are never removed from the stack depot.
15  *
16  * Author: Alexander Potapenko <glider@google.com>
17  * Copyright (C) 2016 Google, Inc.
18  *
19  * Based on the code by Dmitry Chernenkov.
20  */
21 
22 #ifndef _LINUX_STACKDEPOT_H
23 #define _LINUX_STACKDEPOT_H
24 
25 #include <linux/gfp.h>
26 
27 typedef u32 depot_stack_handle_t;
28 
29 /*
30  * Number of bits in the handle that stack depot doesn't use. Users may store
31  * information in them via stack_depot_set/get_extra_bits.
32  */
33 #define STACK_DEPOT_EXTRA_BITS 5
34 
35 /*
36  * Using stack depot requires its initialization, which can be done in 3 ways:
37  *
38  * 1. Selecting CONFIG_STACKDEPOT_ALWAYS_INIT. This option is suitable in
39  *    scenarios where it's known at compile time that stack depot will be used.
40  *    Enabling this config makes the kernel initialize stack depot in mm_init().
41  *
42  * 2. Calling stack_depot_request_early_init() during early boot, before
43  *    stack_depot_early_init() in mm_init() completes. For example, this can
44  *    be done when evaluating kernel boot parameters.
45  *
46  * 3. Calling stack_depot_init(). Possible after boot is complete. This option
47  *    is recommended for modules initialized later in the boot process, after
48  *    mm_init() completes.
49  *
50  * stack_depot_init() and stack_depot_request_early_init() can be called
51  * regardless of whether CONFIG_STACKDEPOT is enabled and are no-op when this
52  * config is disabled. The save/fetch/print stack depot functions can only be
53  * called from the code that makes sure CONFIG_STACKDEPOT is enabled _and_
54  * initializes stack depot via one of the ways listed above.
55  */
56 #ifdef CONFIG_STACKDEPOT
57 int stack_depot_init(void);
58 
59 void __init stack_depot_request_early_init(void);
60 
61 /* Must be only called from mm_init(). */
62 int __init stack_depot_early_init(void);
63 #else
stack_depot_init(void)64 static inline int stack_depot_init(void) { return 0; }
65 
stack_depot_request_early_init(void)66 static inline void stack_depot_request_early_init(void) { }
67 
stack_depot_early_init(void)68 static inline int stack_depot_early_init(void)	{ return 0; }
69 #endif
70 
71 /**
72  * __stack_depot_save - Save a stack trace to stack depot
73  *
74  * @entries:		Pointer to the stack trace
75  * @nr_entries:		Number of frames in the stack
76  * @alloc_flags:	Allocation GFP flags
77  * @can_alloc:		Allocate stack pools (increased chance of failure if false)
78  *
79  * Saves a stack trace from @entries array of size @nr_entries. If @can_alloc is
80  * %true, stack depot can replenish the stack pools in case no space is left
81  * (allocates using GFP flags of @alloc_flags). If @can_alloc is %false, avoids
82  * any allocations and fails if no space is left to store the stack trace.
83  *
84  * If the provided stack trace comes from the interrupt context, only the part
85  * up to the interrupt entry is saved.
86  *
87  * Context: Any context, but setting @can_alloc to %false is required if
88  *          alloc_pages() cannot be used from the current context. Currently
89  *          this is the case for contexts where neither %GFP_ATOMIC nor
90  *          %GFP_NOWAIT can be used (NMI, raw_spin_lock).
91  *
92  * Return: Handle of the stack struct stored in depot, 0 on failure
93  */
94 depot_stack_handle_t __stack_depot_save(unsigned long *entries,
95 					unsigned int nr_entries,
96 					gfp_t gfp_flags, bool can_alloc);
97 
98 /**
99  * stack_depot_save - Save a stack trace to stack depot
100  *
101  * @entries:		Pointer to the stack trace
102  * @nr_entries:		Number of frames in the stack
103  * @alloc_flags:	Allocation GFP flags
104  *
105  * Context: Contexts where allocations via alloc_pages() are allowed.
106  *          See __stack_depot_save() for more details.
107  *
108  * Return: Handle of the stack trace stored in depot, 0 on failure
109  */
110 depot_stack_handle_t stack_depot_save(unsigned long *entries,
111 				      unsigned int nr_entries, gfp_t gfp_flags);
112 
113 /**
114  * stack_depot_fetch - Fetch a stack trace from stack depot
115  *
116  * @handle:	Stack depot handle returned from stack_depot_save()
117  * @entries:	Pointer to store the address of the stack trace
118  *
119  * Return: Number of frames for the fetched stack
120  */
121 unsigned int stack_depot_fetch(depot_stack_handle_t handle,
122 			       unsigned long **entries);
123 
124 /**
125  * stack_depot_print - Print a stack trace from stack depot
126  *
127  * @stack:	Stack depot handle returned from stack_depot_save()
128  */
129 void stack_depot_print(depot_stack_handle_t stack);
130 
131 /**
132  * stack_depot_snprint - Print a stack trace from stack depot into a buffer
133  *
134  * @handle:	Stack depot handle returned from stack_depot_save()
135  * @buf:	Pointer to the print buffer
136  * @size:	Size of the print buffer
137  * @spaces:	Number of leading spaces to print
138  *
139  * Return:	Number of bytes printed
140  */
141 int stack_depot_snprint(depot_stack_handle_t handle, char *buf, size_t size,
142 		       int spaces);
143 
144 /**
145  * stack_depot_set_extra_bits - Set extra bits in a stack depot handle
146  *
147  * @handle:	Stack depot handle returned from stack_depot_save()
148  * @extra_bits:	Value to set the extra bits
149  *
150  * Return: Stack depot handle with extra bits set
151  *
152  * Stack depot handles have a few unused bits, which can be used for storing
153  * user-specific information. These bits are transparent to the stack depot.
154  */
155 depot_stack_handle_t __must_check stack_depot_set_extra_bits(
156 			depot_stack_handle_t handle, unsigned int extra_bits);
157 
158 /**
159  * stack_depot_get_extra_bits - Retrieve extra bits from a stack depot handle
160  *
161  * @handle:	Stack depot handle with extra bits saved
162  *
163  * Return: Extra bits retrieved from the stack depot handle
164  */
165 unsigned int stack_depot_get_extra_bits(depot_stack_handle_t handle);
166 
167 #endif
168