drivers/md/dm-vdo/memory-alloc.h

   1 /* SPDX-License-Identifier: GPL-2.0-only */
   2 /*
   3  * Copyright 2023 Red Hat
   4  */
   5
   6 #ifndef VDO_MEMORY_ALLOC_H
   7 #define VDO_MEMORY_ALLOC_H
   8
   9 #include <linux/cache.h>
  10 #include <linux/io.h> /* for PAGE_SIZE */
  11
  12 #include "permassert.h"
  13 #include "thread-registry.h"
  14
  15 /* Custom memory allocation function that tracks memory usage */
  16 int __must_check vdo_allocate_memory(size_t size, size_t align, const char *what, void *ptr);
  17
  18 /*
  19  * Allocate storage based on element counts, sizes, and alignment.
  20  *
  21  * This is a generalized form of our allocation use case: It allocates an array of objects,
  22  * optionally preceded by one object of another type (i.e., a struct with trailing variable-length
  23  * array), with the alignment indicated.
  24  *
  25  * Why is this inline? The sizes and alignment will always be constant, when invoked through the
  26  * macros below, and often the count will be a compile-time constant 1 or the number of extra bytes
  27  * will be a compile-time constant 0. So at least some of the arithmetic can usually be optimized
  28  * away, and the run-time selection between allocation functions always can. In many cases, it'll
  29  * boil down to just a function call with a constant size.
  30  *
  31  * @count: The number of objects to allocate
  32  * @size: The size of an object
  33  * @extra: The number of additional bytes to allocate
  34  * @align: The required alignment
  35  * @what: What is being allocated (for error logging)
  36  * @ptr: A pointer to hold the allocated memory
  37  *
  38  * Return: VDO_SUCCESS or an error code
  39  */
  40 static inline int __vdo_do_allocation(size_t count, size_t size, size_t extra,
  41                                       size_t align, const char *what, void *ptr)
  42 {
  43         size_t total_size = count * size + extra;
  44
  45         /* Overflow check: */
  46         if ((size > 0) && (count > ((SIZE_MAX - extra) / size))) {
  47                 /*
  48                  * This is kind of a hack: We rely on the fact that SIZE_MAX would cover the entire
  49                  * address space (minus one byte) and thus the system can never allocate that much
  50                  * and the call will always fail. So we can report an overflow as "out of memory"
  51                  * by asking for "merely" SIZE_MAX bytes.
  52                  */
  53                 total_size = SIZE_MAX;
  54         }
  55
  56         return vdo_allocate_memory(total_size, align, what, ptr);
  57 }
  58
  59 /*
  60  * Allocate one or more elements of the indicated type, logging an error if the allocation fails.
  61  * The memory will be zeroed.
  62  *
  63  * @COUNT: The number of objects to allocate
  64  * @TYPE: The type of objects to allocate. This type determines the alignment of the allocation.
  65  * @WHAT: What is being allocated (for error logging)
  66  * @PTR: A pointer to hold the allocated memory
  67  *
  68  * Return: VDO_SUCCESS or an error code
  69  */
  70 #define vdo_allocate(COUNT, TYPE, WHAT, PTR) \
  71         __vdo_do_allocation(COUNT, sizeof(TYPE), 0, __alignof__(TYPE), WHAT, PTR)
  72
  73 /*
  74  * Allocate one object of an indicated type, followed by one or more elements of a second type,
  75  * logging an error if the allocation fails. The memory will be zeroed.
  76  *
  77  * @TYPE1: The type of the primary object to allocate. This type determines the alignment of the
  78  *         allocated memory.
  79  * @COUNT: The number of objects to allocate
  80  * @TYPE2: The type of array objects to allocate
  81  * @WHAT: What is being allocated (for error logging)
  82  * @PTR: A pointer to hold the allocated memory
  83  *
  84  * Return: VDO_SUCCESS or an error code
  85  */
  86 #define vdo_allocate_extended(TYPE1, COUNT, TYPE2, WHAT, PTR)           \
  87         __extension__({                                                 \
  88                 int _result;                                            \
  89                 TYPE1 **_ptr = (PTR);                                   \
  90                 BUILD_BUG_ON(__alignof__(TYPE1) < __alignof__(TYPE2));  \
  91                 _result = __vdo_do_allocation(COUNT,                    \
  92                                               sizeof(TYPE2),            \
  93                                               sizeof(TYPE1),            \
  94                                               __alignof__(TYPE1),       \
  95                                               WHAT,                     \
  96                                               _ptr);                    \
  97                 _result;                                                \
  98         })
  99
 100 /*
 101  * Allocate memory starting on a cache line boundary, logging an error if the allocation fails. The
 102  * memory will be zeroed.
 103  *
 104  * @size: The number of bytes to allocate
 105  * @what: What is being allocated (for error logging)
 106  * @ptr: A pointer to hold the allocated memory
 107  *
 108  * Return: VDO_SUCCESS or an error code
 109  */
 110 static inline int __must_check vdo_allocate_cache_aligned(size_t size, const char *what, void *ptr)
 111 {
 112         return vdo_allocate_memory(size, L1_CACHE_BYTES, what, ptr);
 113 }
 114
 115 /*
 116  * Allocate one element of the indicated type immediately, failing if the required memory is not
 117  * immediately available.
 118  *
 119  * @size: The number of bytes to allocate
 120  * @what: What is being allocated (for error logging)
 121  *
 122  * Return: pointer to the memory, or NULL if the memory is not available.
 123  */
 124 void *__must_check vdo_allocate_memory_nowait(size_t size, const char *what);
 125
 126 int __must_check vdo_reallocate_memory(void *ptr, size_t old_size, size_t size,
 127                                        const char *what, void *new_ptr);
 128
 129 int __must_check vdo_duplicate_string(const char *string, const char *what,
 130                                       char **new_string);
 131
 132 /* Free memory allocated with vdo_allocate(). */
 133 void vdo_free(void *ptr);
 134
 135 static inline void *__vdo_forget(void **ptr_ptr)
 136 {
 137         void *ptr = *ptr_ptr;
 138
 139         *ptr_ptr = NULL;
 140         return ptr;
 141 }
 142
 143 /*
 144  * Null out a pointer and return a copy to it. This macro should be used when passing a pointer to
 145  * a function for which it is not safe to access the pointer once the function returns.
 146  */
 147 #define vdo_forget(ptr) __vdo_forget((void **) &(ptr))
 148
 149 void vdo_memory_init(void);
 150
 151 void vdo_memory_exit(void);
 152
 153 void vdo_register_allocating_thread(struct registered_thread *new_thread,
 154                                     const bool *flag_ptr);
 155
 156 void vdo_unregister_allocating_thread(void);
 157
 158 void vdo_get_memory_stats(u64 *bytes_used, u64 *peak_bytes_used);
 159
 160 void vdo_report_memory_usage(void);
 161
 162 #endif /* VDO_MEMORY_ALLOC_H */