include/linux/stackdepot.h

   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 /*
  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
  64 static inline int stack_depot_init(void) { return 0; }
  65
  66 static inline void stack_depot_request_early_init(void) { }
  67
  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