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 <[email protected]> 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 typedef u32 depot_flags_t; 36 37 /* 38 * Flags that can be passed to stack_depot_save_flags(); see the comment next 39 * to its declaration for more details. 40 */ 41 #define STACK_DEPOT_FLAG_CAN_ALLOC ((depot_flags_t)0x0001) 42 #define STACK_DEPOT_FLAG_GET ((depot_flags_t)0x0002) 43 44 #define STACK_DEPOT_FLAGS_NUM 2 45 #define STACK_DEPOT_FLAGS_MASK ((depot_flags_t)((1 << STACK_DEPOT_FLAGS_NUM) - 1)) 46 47 /* 48 * Using stack depot requires its initialization, which can be done in 3 ways: 49 * 50 * 1. Selecting CONFIG_STACKDEPOT_ALWAYS_INIT. This option is suitable in 51 * scenarios where it's known at compile time that stack depot will be used. 52 * Enabling this config makes the kernel initialize stack depot in mm_init(). 53 * 54 * 2. Calling stack_depot_request_early_init() during early boot, before 55 * stack_depot_early_init() in mm_init() completes. For example, this can 56 * be done when evaluating kernel boot parameters. 57 * 58 * 3. Calling stack_depot_init(). Possible after boot is complete. This option 59 * is recommended for modules initialized later in the boot process, after 60 * mm_init() completes. 61 * 62 * stack_depot_init() and stack_depot_request_early_init() can be called 63 * regardless of whether CONFIG_STACKDEPOT is enabled and are no-op when this 64 * config is disabled. The save/fetch/print stack depot functions can only be 65 * called from the code that makes sure CONFIG_STACKDEPOT is enabled _and_ 66 * initializes stack depot via one of the ways listed above. 67 */ 68 #ifdef CONFIG_STACKDEPOT 69 int stack_depot_init(void); 70 71 void __init stack_depot_request_early_init(void); 72 73 /* Must be only called from mm_init(). */ 74 int __init stack_depot_early_init(void); 75 #else 76 static inline int stack_depot_init(void) { return 0; } 77 78 static inline void stack_depot_request_early_init(void) { } 79 80 static inline int stack_depot_early_init(void) { return 0; } 81 #endif 82 83 /** 84 * stack_depot_save_flags - Save a stack trace to stack depot 85 * 86 * @entries: Pointer to the stack trace 87 * @nr_entries: Number of frames in the stack 88 * @alloc_flags: Allocation GFP flags 89 * @depot_flags: Stack depot flags 90 * 91 * Saves a stack trace from @entries array of size @nr_entries. 92 * 93 * If STACK_DEPOT_FLAG_CAN_ALLOC is set in @depot_flags, stack depot can 94 * replenish the stack pools in case no space is left (allocates using GFP 95 * flags of @alloc_flags). Otherwise, stack depot avoids any allocations and 96 * fails if no space is left to store the stack trace. 97 * 98 * If STACK_DEPOT_FLAG_GET is set in @depot_flags, stack depot will increment 99 * the refcount on the saved stack trace if it already exists in stack depot. 100 * Users of this flag must also call stack_depot_put() when keeping the stack 101 * trace is no longer required to avoid overflowing the refcount. 102 * 103 * If the provided stack trace comes from the interrupt context, only the part 104 * up to the interrupt entry is saved. 105 * 106 * Context: Any context, but setting STACK_DEPOT_FLAG_CAN_ALLOC is required if 107 * alloc_pages() cannot be used from the current context. Currently 108 * this is the case for contexts where neither %GFP_ATOMIC nor 109 * %GFP_NOWAIT can be used (NMI, raw_spin_lock). 110 * 111 * Return: Handle of the stack struct stored in depot, 0 on failure 112 */ 113 depot_stack_handle_t stack_depot_save_flags(unsigned long *entries, 114 unsigned int nr_entries, 115 gfp_t gfp_flags, 116 depot_flags_t depot_flags); 117 118 /** 119 * stack_depot_save - Save a stack trace to stack depot 120 * 121 * @entries: Pointer to the stack trace 122 * @nr_entries: Number of frames in the stack 123 * @alloc_flags: Allocation GFP flags 124 * 125 * Does not increment the refcount on the saved stack trace; see 126 * stack_depot_save_flags() for more details. 127 * 128 * Context: Contexts where allocations via alloc_pages() are allowed; 129 * see stack_depot_save_flags() for more details. 130 * 131 * Return: Handle of the stack trace stored in depot, 0 on failure 132 */ 133 depot_stack_handle_t stack_depot_save(unsigned long *entries, 134 unsigned int nr_entries, gfp_t gfp_flags); 135 136 /** 137 * stack_depot_fetch - Fetch a stack trace from stack depot 138 * 139 * @handle: Stack depot handle returned from stack_depot_save() 140 * @entries: Pointer to store the address of the stack trace 141 * 142 * Return: Number of frames for the fetched stack 143 */ 144 unsigned int stack_depot_fetch(depot_stack_handle_t handle, 145 unsigned long **entries); 146 147 /** 148 * stack_depot_print - Print a stack trace from stack depot 149 * 150 * @stack: Stack depot handle returned from stack_depot_save() 151 */ 152 void stack_depot_print(depot_stack_handle_t stack); 153 154 /** 155 * stack_depot_snprint - Print a stack trace from stack depot into a buffer 156 * 157 * @handle: Stack depot handle returned from stack_depot_save() 158 * @buf: Pointer to the print buffer 159 * @size: Size of the print buffer 160 * @spaces: Number of leading spaces to print 161 * 162 * Return: Number of bytes printed 163 */ 164 int stack_depot_snprint(depot_stack_handle_t handle, char *buf, size_t size, 165 int spaces); 166 167 /** 168 * stack_depot_put - Drop a reference to a stack trace from stack depot 169 * 170 * @handle: Stack depot handle returned from stack_depot_save() 171 * 172 * The stack trace is evicted from stack depot once all references to it have 173 * been dropped (once the number of stack_depot_evict() calls matches the 174 * number of stack_depot_save_flags() calls with STACK_DEPOT_FLAG_GET set for 175 * this stack trace). 176 */ 177 void stack_depot_put(depot_stack_handle_t handle); 178 179 /** 180 * stack_depot_set_extra_bits - Set extra bits in a stack depot handle 181 * 182 * @handle: Stack depot handle returned from stack_depot_save() 183 * @extra_bits: Value to set the extra bits 184 * 185 * Return: Stack depot handle with extra bits set 186 * 187 * Stack depot handles have a few unused bits, which can be used for storing 188 * user-specific information. These bits are transparent to the stack depot. 189 */ 190 depot_stack_handle_t __must_check stack_depot_set_extra_bits( 191 depot_stack_handle_t handle, unsigned int extra_bits); 192 193 /** 194 * stack_depot_get_extra_bits - Retrieve extra bits from a stack depot handle 195 * 196 * @handle: Stack depot handle with extra bits saved 197 * 198 * Return: Extra bits retrieved from the stack depot handle 199 */ 200 unsigned int stack_depot_get_extra_bits(depot_stack_handle_t handle); 201 202 #endif 203