Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 1 | /* |
| 2 | * Buffer-based memory allocator |
| 3 | * |
Bence Szépkúti | 1e14827 | 2020-08-07 13:07:28 +0200 | [diff] [blame] | 4 | * Copyright The Mbed TLS Contributors |
Manuel Pégourié-Gonnard | 37ff140 | 2015-09-04 14:21:07 +0200 | [diff] [blame] | 5 | * SPDX-License-Identifier: Apache-2.0 |
| 6 | * |
| 7 | * Licensed under the Apache License, Version 2.0 (the "License"); you may |
| 8 | * not use this file except in compliance with the License. |
| 9 | * You may obtain a copy of the License at |
| 10 | * |
| 11 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 12 | * |
| 13 | * Unless required by applicable law or agreed to in writing, software |
| 14 | * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| 15 | * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 16 | * See the License for the specific language governing permissions and |
| 17 | * limitations under the License. |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 18 | */ |
| 19 | |
Gilles Peskine | db09ef6 | 2020-06-03 01:43:33 +0200 | [diff] [blame] | 20 | #include "common.h" |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 21 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 22 | #if defined(MBEDTLS_MEMORY_BUFFER_ALLOC_C) |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 23 | # include "mbedtls/memory_buffer_alloc.h" |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 24 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 25 | /* No need for the header guard as MBEDTLS_MEMORY_BUFFER_ALLOC_C |
| 26 | is dependent upon MBEDTLS_PLATFORM_C */ |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 27 | # include "mbedtls/platform.h" |
| 28 | # include "mbedtls/platform_util.h" |
Rich Evans | d08a605 | 2015-02-12 12:17:10 +0000 | [diff] [blame] | 29 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 30 | # include <string.h> |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 31 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 32 | # if defined(MBEDTLS_MEMORY_BACKTRACE) |
| 33 | # include <execinfo.h> |
| 34 | # endif |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 35 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 36 | # if defined(MBEDTLS_THREADING_C) |
| 37 | # include "mbedtls/threading.h" |
| 38 | # endif |
Paul Bakker | 1337aff | 2013-09-29 14:45:34 +0200 | [diff] [blame] | 39 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 40 | # define MAGIC1 0xFF00AA55 |
| 41 | # define MAGIC2 0xEE119966 |
| 42 | # define MAX_BT 20 |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 43 | |
| 44 | typedef struct _memory_header memory_header; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 45 | struct _memory_header { |
| 46 | size_t magic1; |
| 47 | size_t size; |
| 48 | size_t alloc; |
| 49 | memory_header *prev; |
| 50 | memory_header *next; |
| 51 | memory_header *prev_free; |
| 52 | memory_header *next_free; |
| 53 | # if defined(MBEDTLS_MEMORY_BACKTRACE) |
| 54 | char **trace; |
| 55 | size_t trace_count; |
| 56 | # endif |
| 57 | size_t magic2; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 58 | }; |
| 59 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 60 | typedef struct { |
| 61 | unsigned char *buf; |
| 62 | size_t len; |
| 63 | memory_header *first; |
| 64 | memory_header *first_free; |
| 65 | int verify; |
| 66 | # if defined(MBEDTLS_MEMORY_DEBUG) |
| 67 | size_t alloc_count; |
| 68 | size_t free_count; |
| 69 | size_t total_used; |
| 70 | size_t maximum_used; |
| 71 | size_t header_count; |
| 72 | size_t maximum_header_count; |
| 73 | # endif |
| 74 | # if defined(MBEDTLS_THREADING_C) |
| 75 | mbedtls_threading_mutex_t mutex; |
| 76 | # endif |
| 77 | } buffer_alloc_ctx; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 78 | |
| 79 | static buffer_alloc_ctx heap; |
| 80 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 81 | # if defined(MBEDTLS_MEMORY_DEBUG) |
| 82 | static void debug_header(memory_header *hdr) |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 83 | { |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 84 | # if defined(MBEDTLS_MEMORY_BACKTRACE) |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 85 | size_t i; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 86 | # endif |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 87 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 88 | mbedtls_fprintf(stderr, |
| 89 | "HDR: PTR(%10zu), PREV(%10zu), NEXT(%10zu), " |
| 90 | "ALLOC(%zu), SIZE(%10zu)\n", |
| 91 | (size_t)hdr, (size_t)hdr->prev, (size_t)hdr->next, |
| 92 | hdr->alloc, hdr->size); |
| 93 | mbedtls_fprintf(stderr, " FPREV(%10zu), FNEXT(%10zu)\n", |
| 94 | (size_t)hdr->prev_free, (size_t)hdr->next_free); |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 95 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 96 | # if defined(MBEDTLS_MEMORY_BACKTRACE) |
| 97 | mbedtls_fprintf(stderr, "TRACE: \n"); |
| 98 | for (i = 0; i < hdr->trace_count; i++) |
| 99 | mbedtls_fprintf(stderr, "%s\n", hdr->trace[i]); |
| 100 | mbedtls_fprintf(stderr, "\n"); |
| 101 | # endif |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 102 | } |
| 103 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 104 | static void debug_chain(void) |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 105 | { |
| 106 | memory_header *cur = heap.first; |
| 107 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 108 | mbedtls_fprintf(stderr, "\nBlock list\n"); |
| 109 | while (cur != NULL) { |
| 110 | debug_header(cur); |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 111 | cur = cur->next; |
| 112 | } |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 113 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 114 | mbedtls_fprintf(stderr, "Free list\n"); |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 115 | cur = heap.first_free; |
| 116 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 117 | while (cur != NULL) { |
| 118 | debug_header(cur); |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 119 | cur = cur->next_free; |
| 120 | } |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 121 | } |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 122 | # endif /* MBEDTLS_MEMORY_DEBUG */ |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 123 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 124 | static int verify_header(memory_header *hdr) |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 125 | { |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 126 | if (hdr->magic1 != MAGIC1) { |
| 127 | # if defined(MBEDTLS_MEMORY_DEBUG) |
| 128 | mbedtls_fprintf(stderr, "FATAL: MAGIC1 mismatch\n"); |
| 129 | # endif |
| 130 | return 1; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 131 | } |
| 132 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 133 | if (hdr->magic2 != MAGIC2) { |
| 134 | # if defined(MBEDTLS_MEMORY_DEBUG) |
| 135 | mbedtls_fprintf(stderr, "FATAL: MAGIC2 mismatch\n"); |
| 136 | # endif |
| 137 | return 1; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 138 | } |
| 139 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 140 | if (hdr->alloc > 1) { |
| 141 | # if defined(MBEDTLS_MEMORY_DEBUG) |
| 142 | mbedtls_fprintf(stderr, "FATAL: alloc has illegal value\n"); |
| 143 | # endif |
| 144 | return 1; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 145 | } |
| 146 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 147 | if (hdr->prev != NULL && hdr->prev == hdr->next) { |
| 148 | # if defined(MBEDTLS_MEMORY_DEBUG) |
| 149 | mbedtls_fprintf(stderr, "FATAL: prev == next\n"); |
| 150 | # endif |
| 151 | return 1; |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 152 | } |
| 153 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 154 | if (hdr->prev_free != NULL && hdr->prev_free == hdr->next_free) { |
| 155 | # if defined(MBEDTLS_MEMORY_DEBUG) |
| 156 | mbedtls_fprintf(stderr, "FATAL: prev_free == next_free\n"); |
| 157 | # endif |
| 158 | return 1; |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 159 | } |
| 160 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 161 | return 0; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 162 | } |
| 163 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 164 | static int verify_chain(void) |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 165 | { |
Andres AG | 9cf1f96 | 2017-01-30 14:34:25 +0000 | [diff] [blame] | 166 | memory_header *prv = heap.first, *cur; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 167 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 168 | if (prv == NULL || verify_header(prv) != 0) { |
| 169 | # if defined(MBEDTLS_MEMORY_DEBUG) |
| 170 | mbedtls_fprintf(stderr, "FATAL: verification of first header " |
| 171 | "failed\n"); |
| 172 | # endif |
| 173 | return 1; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 174 | } |
| 175 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 176 | if (heap.first->prev != NULL) { |
| 177 | # if defined(MBEDTLS_MEMORY_DEBUG) |
| 178 | mbedtls_fprintf(stderr, "FATAL: verification failed: " |
| 179 | "first->prev != NULL\n"); |
| 180 | # endif |
| 181 | return 1; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 182 | } |
| 183 | |
Andres AG | 9cf1f96 | 2017-01-30 14:34:25 +0000 | [diff] [blame] | 184 | cur = heap.first->next; |
| 185 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 186 | while (cur != NULL) { |
| 187 | if (verify_header(cur) != 0) { |
| 188 | # if defined(MBEDTLS_MEMORY_DEBUG) |
| 189 | mbedtls_fprintf(stderr, "FATAL: verification of header " |
| 190 | "failed\n"); |
| 191 | # endif |
| 192 | return 1; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 193 | } |
| 194 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 195 | if (cur->prev != prv) { |
| 196 | # if defined(MBEDTLS_MEMORY_DEBUG) |
| 197 | mbedtls_fprintf(stderr, "FATAL: verification failed: " |
| 198 | "cur->prev != prv\n"); |
| 199 | # endif |
| 200 | return 1; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 201 | } |
| 202 | |
| 203 | prv = cur; |
| 204 | cur = cur->next; |
| 205 | } |
| 206 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 207 | return 0; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 208 | } |
| 209 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 210 | static void *buffer_alloc_calloc(size_t n, size_t size) |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 211 | { |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 212 | memory_header *new, *cur = heap.first_free; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 213 | unsigned char *p; |
Manuel Pégourié-Gonnard | 200e731 | 2015-05-26 17:42:13 +0200 | [diff] [blame] | 214 | void *ret; |
| 215 | size_t original_len, len; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 216 | # if defined(MBEDTLS_MEMORY_BACKTRACE) |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 217 | void *trace_buffer[MAX_BT]; |
| 218 | size_t trace_cnt; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 219 | # endif |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 220 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 221 | if (heap.buf == NULL || heap.first == NULL) |
| 222 | return NULL; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 223 | |
Manuel Pégourié-Gonnard | 200e731 | 2015-05-26 17:42:13 +0200 | [diff] [blame] | 224 | original_len = len = n * size; |
| 225 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 226 | if (n == 0 || size == 0 || len / n != size) |
| 227 | return NULL; |
| 228 | else if (len > (size_t)-MBEDTLS_MEMORY_ALIGN_MULTIPLE) |
| 229 | return NULL; |
Manuel Pégourié-Gonnard | 200e731 | 2015-05-26 17:42:13 +0200 | [diff] [blame] | 230 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 231 | if (len % MBEDTLS_MEMORY_ALIGN_MULTIPLE) { |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 232 | len -= len % MBEDTLS_MEMORY_ALIGN_MULTIPLE; |
| 233 | len += MBEDTLS_MEMORY_ALIGN_MULTIPLE; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 234 | } |
| 235 | |
| 236 | // Find block that fits |
| 237 | // |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 238 | while (cur != NULL) { |
| 239 | if (cur->size >= len) |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 240 | break; |
| 241 | |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 242 | cur = cur->next_free; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 243 | } |
| 244 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 245 | if (cur == NULL) |
| 246 | return NULL; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 247 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 248 | if (cur->alloc != 0) { |
| 249 | # if defined(MBEDTLS_MEMORY_DEBUG) |
| 250 | mbedtls_fprintf(stderr, "FATAL: block in free_list but allocated " |
| 251 | "data\n"); |
| 252 | # endif |
| 253 | mbedtls_exit(1); |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 254 | } |
| 255 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 256 | # if defined(MBEDTLS_MEMORY_DEBUG) |
Manuel Pégourié-Gonnard | 6c967b9 | 2015-05-27 20:18:39 +0200 | [diff] [blame] | 257 | heap.alloc_count++; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 258 | # endif |
Paul Bakker | 891998e | 2013-07-03 14:45:05 +0200 | [diff] [blame] | 259 | |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 260 | // Found location, split block if > memory_header + 4 room left |
| 261 | // |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 262 | if (cur->size - len < |
| 263 | sizeof(memory_header) + MBEDTLS_MEMORY_ALIGN_MULTIPLE) { |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 264 | cur->alloc = 1; |
| 265 | |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 266 | // Remove from free_list |
| 267 | // |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 268 | if (cur->prev_free != NULL) |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 269 | cur->prev_free->next_free = cur->next_free; |
| 270 | else |
| 271 | heap.first_free = cur->next_free; |
| 272 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 273 | if (cur->next_free != NULL) |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 274 | cur->next_free->prev_free = cur->prev_free; |
| 275 | |
| 276 | cur->prev_free = NULL; |
| 277 | cur->next_free = NULL; |
| 278 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 279 | # if defined(MBEDTLS_MEMORY_DEBUG) |
Paul Bakker | 891998e | 2013-07-03 14:45:05 +0200 | [diff] [blame] | 280 | heap.total_used += cur->size; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 281 | if (heap.total_used > heap.maximum_used) |
Paul Bakker | 891998e | 2013-07-03 14:45:05 +0200 | [diff] [blame] | 282 | heap.maximum_used = heap.total_used; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 283 | # endif |
| 284 | # if defined(MBEDTLS_MEMORY_BACKTRACE) |
| 285 | trace_cnt = backtrace(trace_buffer, MAX_BT); |
| 286 | cur->trace = backtrace_symbols(trace_buffer, trace_cnt); |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 287 | cur->trace_count = trace_cnt; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 288 | # endif |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 289 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 290 | if ((heap.verify & MBEDTLS_MEMORY_VERIFY_ALLOC) && verify_chain() != 0) |
| 291 | mbedtls_exit(1); |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 292 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 293 | ret = (unsigned char *)cur + sizeof(memory_header); |
| 294 | memset(ret, 0, original_len); |
Manuel Pégourié-Gonnard | 200e731 | 2015-05-26 17:42:13 +0200 | [diff] [blame] | 295 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 296 | return ret; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 297 | } |
| 298 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 299 | p = ((unsigned char *)cur) + sizeof(memory_header) + len; |
| 300 | new = (memory_header *)p; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 301 | |
| 302 | new->size = cur->size - len - sizeof(memory_header); |
| 303 | new->alloc = 0; |
| 304 | new->prev = cur; |
| 305 | new->next = cur->next; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 306 | # if defined(MBEDTLS_MEMORY_BACKTRACE) |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 307 | new->trace = NULL; |
| 308 | new->trace_count = 0; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 309 | # endif |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 310 | new->magic1 = MAGIC1; |
| 311 | new->magic2 = MAGIC2; |
| 312 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 313 | if (new->next != NULL) |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 314 | new->next->prev = new; |
| 315 | |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 316 | // Replace cur with new in free_list |
| 317 | // |
| 318 | new->prev_free = cur->prev_free; |
| 319 | new->next_free = cur->next_free; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 320 | if (new->prev_free != NULL) |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 321 | new->prev_free->next_free = new; |
| 322 | else |
| 323 | heap.first_free = new; |
| 324 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 325 | if (new->next_free != NULL) |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 326 | new->next_free->prev_free = new; |
| 327 | |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 328 | cur->alloc = 1; |
| 329 | cur->size = len; |
| 330 | cur->next = new; |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 331 | cur->prev_free = NULL; |
| 332 | cur->next_free = NULL; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 333 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 334 | # if defined(MBEDTLS_MEMORY_DEBUG) |
Paul Bakker | 891998e | 2013-07-03 14:45:05 +0200 | [diff] [blame] | 335 | heap.header_count++; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 336 | if (heap.header_count > heap.maximum_header_count) |
Manuel Pégourié-Gonnard | 70896a0 | 2013-12-30 18:06:41 +0100 | [diff] [blame] | 337 | heap.maximum_header_count = heap.header_count; |
Paul Bakker | 891998e | 2013-07-03 14:45:05 +0200 | [diff] [blame] | 338 | heap.total_used += cur->size; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 339 | if (heap.total_used > heap.maximum_used) |
Paul Bakker | 891998e | 2013-07-03 14:45:05 +0200 | [diff] [blame] | 340 | heap.maximum_used = heap.total_used; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 341 | # endif |
| 342 | # if defined(MBEDTLS_MEMORY_BACKTRACE) |
| 343 | trace_cnt = backtrace(trace_buffer, MAX_BT); |
| 344 | cur->trace = backtrace_symbols(trace_buffer, trace_cnt); |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 345 | cur->trace_count = trace_cnt; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 346 | # endif |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 347 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 348 | if ((heap.verify & MBEDTLS_MEMORY_VERIFY_ALLOC) && verify_chain() != 0) |
| 349 | mbedtls_exit(1); |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 350 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 351 | ret = (unsigned char *)cur + sizeof(memory_header); |
| 352 | memset(ret, 0, original_len); |
Manuel Pégourié-Gonnard | 200e731 | 2015-05-26 17:42:13 +0200 | [diff] [blame] | 353 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 354 | return ret; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 355 | } |
| 356 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 357 | static void buffer_alloc_free(void *ptr) |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 358 | { |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 359 | memory_header *hdr, *old = NULL; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 360 | unsigned char *p = (unsigned char *)ptr; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 361 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 362 | if (ptr == NULL || heap.buf == NULL || heap.first == NULL) |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 363 | return; |
| 364 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 365 | if (p < heap.buf || p >= heap.buf + heap.len) { |
| 366 | # if defined(MBEDTLS_MEMORY_DEBUG) |
| 367 | mbedtls_fprintf(stderr, "FATAL: mbedtls_free() outside of managed " |
| 368 | "space\n"); |
| 369 | # endif |
| 370 | mbedtls_exit(1); |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 371 | } |
| 372 | |
| 373 | p -= sizeof(memory_header); |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 374 | hdr = (memory_header *)p; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 375 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 376 | if (verify_header(hdr) != 0) |
| 377 | mbedtls_exit(1); |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 378 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 379 | if (hdr->alloc != 1) { |
| 380 | # if defined(MBEDTLS_MEMORY_DEBUG) |
| 381 | mbedtls_fprintf(stderr, "FATAL: mbedtls_free() on unallocated " |
| 382 | "data\n"); |
| 383 | # endif |
| 384 | mbedtls_exit(1); |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 385 | } |
| 386 | |
| 387 | hdr->alloc = 0; |
| 388 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 389 | # if defined(MBEDTLS_MEMORY_DEBUG) |
Paul Bakker | 891998e | 2013-07-03 14:45:05 +0200 | [diff] [blame] | 390 | heap.free_count++; |
| 391 | heap.total_used -= hdr->size; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 392 | # endif |
Paul Bakker | 891998e | 2013-07-03 14:45:05 +0200 | [diff] [blame] | 393 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 394 | # if defined(MBEDTLS_MEMORY_BACKTRACE) |
| 395 | free(hdr->trace); |
SimonB | 4225611 | 2016-05-02 01:05:22 +0100 | [diff] [blame] | 396 | hdr->trace = NULL; |
| 397 | hdr->trace_count = 0; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 398 | # endif |
SimonB | 4225611 | 2016-05-02 01:05:22 +0100 | [diff] [blame] | 399 | |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 400 | // Regroup with block before |
| 401 | // |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 402 | if (hdr->prev != NULL && hdr->prev->alloc == 0) { |
| 403 | # if defined(MBEDTLS_MEMORY_DEBUG) |
Paul Bakker | 891998e | 2013-07-03 14:45:05 +0200 | [diff] [blame] | 404 | heap.header_count--; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 405 | # endif |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 406 | hdr->prev->size += sizeof(memory_header) + hdr->size; |
| 407 | hdr->prev->next = hdr->next; |
| 408 | old = hdr; |
| 409 | hdr = hdr->prev; |
| 410 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 411 | if (hdr->next != NULL) |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 412 | hdr->next->prev = hdr; |
| 413 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 414 | memset(old, 0, sizeof(memory_header)); |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 415 | } |
| 416 | |
| 417 | // Regroup with block after |
| 418 | // |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 419 | if (hdr->next != NULL && hdr->next->alloc == 0) { |
| 420 | # if defined(MBEDTLS_MEMORY_DEBUG) |
Paul Bakker | 891998e | 2013-07-03 14:45:05 +0200 | [diff] [blame] | 421 | heap.header_count--; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 422 | # endif |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 423 | hdr->size += sizeof(memory_header) + hdr->next->size; |
| 424 | old = hdr->next; |
| 425 | hdr->next = hdr->next->next; |
| 426 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 427 | if (hdr->prev_free != NULL || hdr->next_free != NULL) { |
| 428 | if (hdr->prev_free != NULL) |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 429 | hdr->prev_free->next_free = hdr->next_free; |
| 430 | else |
| 431 | heap.first_free = hdr->next_free; |
| 432 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 433 | if (hdr->next_free != NULL) |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 434 | hdr->next_free->prev_free = hdr->prev_free; |
| 435 | } |
| 436 | |
| 437 | hdr->prev_free = old->prev_free; |
| 438 | hdr->next_free = old->next_free; |
| 439 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 440 | if (hdr->prev_free != NULL) |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 441 | hdr->prev_free->next_free = hdr; |
| 442 | else |
| 443 | heap.first_free = hdr; |
| 444 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 445 | if (hdr->next_free != NULL) |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 446 | hdr->next_free->prev_free = hdr; |
| 447 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 448 | if (hdr->next != NULL) |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 449 | hdr->next->prev = hdr; |
| 450 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 451 | memset(old, 0, sizeof(memory_header)); |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 452 | } |
| 453 | |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 454 | // Prepend to free_list if we have not merged |
| 455 | // (Does not have to stay in same order as prev / next list) |
| 456 | // |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 457 | if (old == NULL) { |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 458 | hdr->next_free = heap.first_free; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 459 | if (heap.first_free != NULL) |
Manuel Pégourié-Gonnard | 547ff66 | 2014-11-26 15:42:16 +0100 | [diff] [blame] | 460 | heap.first_free->prev_free = hdr; |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 461 | heap.first_free = hdr; |
| 462 | } |
| 463 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 464 | if ((heap.verify & MBEDTLS_MEMORY_VERIFY_FREE) && verify_chain() != 0) |
| 465 | mbedtls_exit(1); |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 466 | } |
| 467 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 468 | void mbedtls_memory_buffer_set_verify(int verify) |
Paul Bakker | bf796ac | 2013-09-28 11:06:38 +0200 | [diff] [blame] | 469 | { |
| 470 | heap.verify = verify; |
| 471 | } |
| 472 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 473 | int mbedtls_memory_buffer_alloc_verify(void) |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 474 | { |
| 475 | return verify_chain(); |
| 476 | } |
| 477 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 478 | # if defined(MBEDTLS_MEMORY_DEBUG) |
| 479 | void mbedtls_memory_buffer_alloc_status(void) |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 480 | { |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 481 | mbedtls_fprintf(stderr, |
| 482 | "Current use: %zu blocks / %zu bytes, max: %zu blocks / " |
| 483 | "%zu bytes (total %zu bytes), alloc / free: %zu / %zu\n", |
| 484 | heap.header_count, heap.total_used, |
| 485 | heap.maximum_header_count, heap.maximum_used, |
| 486 | heap.maximum_header_count * sizeof(memory_header) + |
| 487 | heap.maximum_used, |
| 488 | heap.alloc_count, heap.free_count); |
Paul Bakker | 891998e | 2013-07-03 14:45:05 +0200 | [diff] [blame] | 489 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 490 | if (heap.first->next == NULL) { |
| 491 | mbedtls_fprintf(stderr, "All memory de-allocated in stack buffer\n"); |
| 492 | } else { |
| 493 | mbedtls_fprintf(stderr, "Memory currently allocated:\n"); |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 494 | debug_chain(); |
| 495 | } |
| 496 | } |
Manuel Pégourié-Gonnard | 50da048 | 2014-12-19 12:10:37 +0100 | [diff] [blame] | 497 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 498 | void mbedtls_memory_buffer_alloc_max_get(size_t *max_used, size_t *max_blocks) |
Manuel Pégourié-Gonnard | 50da048 | 2014-12-19 12:10:37 +0100 | [diff] [blame] | 499 | { |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 500 | *max_used = heap.maximum_used; |
Manuel Pégourié-Gonnard | 50da048 | 2014-12-19 12:10:37 +0100 | [diff] [blame] | 501 | *max_blocks = heap.maximum_header_count; |
| 502 | } |
| 503 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 504 | void mbedtls_memory_buffer_alloc_max_reset(void) |
Manuel Pégourié-Gonnard | 50da048 | 2014-12-19 12:10:37 +0100 | [diff] [blame] | 505 | { |
| 506 | heap.maximum_used = 0; |
| 507 | heap.maximum_header_count = 0; |
| 508 | } |
| 509 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 510 | void mbedtls_memory_buffer_alloc_cur_get(size_t *cur_used, size_t *cur_blocks) |
Manuel Pégourié-Gonnard | 50da048 | 2014-12-19 12:10:37 +0100 | [diff] [blame] | 511 | { |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 512 | *cur_used = heap.total_used; |
Manuel Pégourié-Gonnard | 50da048 | 2014-12-19 12:10:37 +0100 | [diff] [blame] | 513 | *cur_blocks = heap.header_count; |
| 514 | } |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 515 | # endif /* MBEDTLS_MEMORY_DEBUG */ |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 516 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 517 | # if defined(MBEDTLS_THREADING_C) |
| 518 | static void *buffer_alloc_calloc_mutexed(size_t n, size_t size) |
Paul Bakker | 1337aff | 2013-09-29 14:45:34 +0200 | [diff] [blame] | 519 | { |
| 520 | void *buf; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 521 | if (mbedtls_mutex_lock(&heap.mutex) != 0) |
| 522 | return NULL; |
| 523 | buf = buffer_alloc_calloc(n, size); |
| 524 | if (mbedtls_mutex_unlock(&heap.mutex)) |
| 525 | return NULL; |
| 526 | return buf; |
Paul Bakker | 1337aff | 2013-09-29 14:45:34 +0200 | [diff] [blame] | 527 | } |
| 528 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 529 | static void buffer_alloc_free_mutexed(void *ptr) |
Paul Bakker | 1337aff | 2013-09-29 14:45:34 +0200 | [diff] [blame] | 530 | { |
Manuel Pégourié-Gonnard | bdd7828 | 2015-04-24 14:42:53 +0200 | [diff] [blame] | 531 | /* We have to good option here, but corrupting the heap seems |
| 532 | * worse than loosing memory. */ |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 533 | if (mbedtls_mutex_lock(&heap.mutex)) |
Manuel Pégourié-Gonnard | bdd7828 | 2015-04-24 14:42:53 +0200 | [diff] [blame] | 534 | return; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 535 | buffer_alloc_free(ptr); |
| 536 | (void)mbedtls_mutex_unlock(&heap.mutex); |
Paul Bakker | 1337aff | 2013-09-29 14:45:34 +0200 | [diff] [blame] | 537 | } |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 538 | # endif /* MBEDTLS_THREADING_C */ |
Paul Bakker | 1337aff | 2013-09-29 14:45:34 +0200 | [diff] [blame] | 539 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 540 | void mbedtls_memory_buffer_alloc_init(unsigned char *buf, size_t len) |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 541 | { |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 542 | memset(&heap, 0, sizeof(buffer_alloc_ctx)); |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 543 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 544 | # if defined(MBEDTLS_THREADING_C) |
| 545 | mbedtls_mutex_init(&heap.mutex); |
| 546 | mbedtls_platform_set_calloc_free(buffer_alloc_calloc_mutexed, |
| 547 | buffer_alloc_free_mutexed); |
| 548 | # else |
| 549 | mbedtls_platform_set_calloc_free(buffer_alloc_calloc, buffer_alloc_free); |
| 550 | # endif |
Paul Bakker | 1337aff | 2013-09-29 14:45:34 +0200 | [diff] [blame] | 551 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 552 | if (len < sizeof(memory_header) + MBEDTLS_MEMORY_ALIGN_MULTIPLE) |
Andres AG | 9cf1f96 | 2017-01-30 14:34:25 +0000 | [diff] [blame] | 553 | return; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 554 | else if ((size_t)buf % MBEDTLS_MEMORY_ALIGN_MULTIPLE) { |
Manuel Pégourié-Gonnard | 5dd28ea | 2014-11-27 13:57:42 +0100 | [diff] [blame] | 555 | /* Adjust len first since buf is used in the computation */ |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 556 | len -= MBEDTLS_MEMORY_ALIGN_MULTIPLE - |
| 557 | (size_t)buf % MBEDTLS_MEMORY_ALIGN_MULTIPLE; |
| 558 | buf += MBEDTLS_MEMORY_ALIGN_MULTIPLE - |
| 559 | (size_t)buf % MBEDTLS_MEMORY_ALIGN_MULTIPLE; |
Manuel Pégourié-Gonnard | 82a5de7 | 2014-05-05 14:05:24 +0200 | [diff] [blame] | 560 | } |
| 561 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 562 | memset(buf, 0, len); |
Andres AG | 9cf1f96 | 2017-01-30 14:34:25 +0000 | [diff] [blame] | 563 | |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 564 | heap.buf = buf; |
| 565 | heap.len = len; |
| 566 | |
Andres AG | 9cf1f96 | 2017-01-30 14:34:25 +0000 | [diff] [blame] | 567 | heap.first = (memory_header *)buf; |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 568 | heap.first->size = len - sizeof(memory_header); |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 569 | heap.first->magic1 = MAGIC1; |
| 570 | heap.first->magic2 = MAGIC2; |
Paul Bakker | 1ef120f | 2013-07-03 17:20:39 +0200 | [diff] [blame] | 571 | heap.first_free = heap.first; |
Paul Bakker | 6e339b5 | 2013-07-03 13:37:05 +0200 | [diff] [blame] | 572 | } |
| 573 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 574 | void mbedtls_memory_buffer_alloc_free(void) |
Paul Bakker | 1337aff | 2013-09-29 14:45:34 +0200 | [diff] [blame] | 575 | { |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 576 | # if defined(MBEDTLS_THREADING_C) |
| 577 | mbedtls_mutex_free(&heap.mutex); |
| 578 | # endif |
| 579 | mbedtls_platform_zeroize(&heap, sizeof(buffer_alloc_ctx)); |
Paul Bakker | 1337aff | 2013-09-29 14:45:34 +0200 | [diff] [blame] | 580 | } |
| 581 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 582 | # if defined(MBEDTLS_SELF_TEST) |
| 583 | static int check_pointer(void *p) |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 584 | { |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 585 | if (p == NULL) |
| 586 | return -1; |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 587 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 588 | if ((size_t)p % MBEDTLS_MEMORY_ALIGN_MULTIPLE != 0) |
| 589 | return -1; |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 590 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 591 | return 0; |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 592 | } |
| 593 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 594 | static int check_all_free(void) |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 595 | { |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 596 | if ( |
| 597 | # if defined(MBEDTLS_MEMORY_DEBUG) |
Manuel Pégourié-Gonnard | 491a3fe | 2015-02-05 12:08:47 +0100 | [diff] [blame] | 598 | heap.total_used != 0 || |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 599 | # endif |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 600 | heap.first != heap.first_free || |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 601 | (void *)heap.first != (void *)heap.buf) { |
| 602 | return -1; |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 603 | } |
| 604 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 605 | return 0; |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 606 | } |
| 607 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 608 | # define TEST_ASSERT(condition) \ |
| 609 | if (!(condition)) { \ |
| 610 | if (verbose != 0) \ |
| 611 | mbedtls_printf("failed\n"); \ |
| 612 | \ |
| 613 | ret = 1; \ |
| 614 | goto cleanup; \ |
| 615 | } |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 616 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 617 | int mbedtls_memory_buffer_alloc_self_test(int verbose) |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 618 | { |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 619 | unsigned char buf[1024]; |
Manuel Pégourié-Gonnard | 5dd28ea | 2014-11-27 13:57:42 +0100 | [diff] [blame] | 620 | unsigned char *p, *q, *r, *end; |
| 621 | int ret = 0; |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 622 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 623 | if (verbose != 0) |
| 624 | mbedtls_printf(" MBA test #1 (basic alloc-free cycle): "); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 625 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 626 | mbedtls_memory_buffer_alloc_init(buf, sizeof(buf)); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 627 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 628 | p = mbedtls_calloc(1, 1); |
| 629 | q = mbedtls_calloc(1, 128); |
| 630 | r = mbedtls_calloc(1, 16); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 631 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 632 | TEST_ASSERT(check_pointer(p) == 0 && check_pointer(q) == 0 && |
| 633 | check_pointer(r) == 0); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 634 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 635 | mbedtls_free(r); |
| 636 | mbedtls_free(q); |
| 637 | mbedtls_free(p); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 638 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 639 | TEST_ASSERT(check_all_free() == 0); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 640 | |
Manuel Pégourié-Gonnard | 5dd28ea | 2014-11-27 13:57:42 +0100 | [diff] [blame] | 641 | /* Memorize end to compare with the next test */ |
| 642 | end = heap.buf + heap.len; |
| 643 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 644 | mbedtls_memory_buffer_alloc_free(); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 645 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 646 | if (verbose != 0) |
| 647 | mbedtls_printf("passed\n"); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 648 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 649 | if (verbose != 0) |
| 650 | mbedtls_printf(" MBA test #2 (buf not aligned): "); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 651 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 652 | mbedtls_memory_buffer_alloc_init(buf + 1, sizeof(buf) - 1); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 653 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 654 | TEST_ASSERT(heap.buf + heap.len == end); |
Manuel Pégourié-Gonnard | 5dd28ea | 2014-11-27 13:57:42 +0100 | [diff] [blame] | 655 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 656 | p = mbedtls_calloc(1, 1); |
| 657 | q = mbedtls_calloc(1, 128); |
| 658 | r = mbedtls_calloc(1, 16); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 659 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 660 | TEST_ASSERT(check_pointer(p) == 0 && check_pointer(q) == 0 && |
| 661 | check_pointer(r) == 0); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 662 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 663 | mbedtls_free(r); |
| 664 | mbedtls_free(q); |
| 665 | mbedtls_free(p); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 666 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 667 | TEST_ASSERT(check_all_free() == 0); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 668 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 669 | mbedtls_memory_buffer_alloc_free(); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 670 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 671 | if (verbose != 0) |
| 672 | mbedtls_printf("passed\n"); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 673 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 674 | if (verbose != 0) |
| 675 | mbedtls_printf(" MBA test #3 (full): "); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 676 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 677 | mbedtls_memory_buffer_alloc_init(buf, sizeof(buf)); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 678 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 679 | p = mbedtls_calloc(1, sizeof(buf) - sizeof(memory_header)); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 680 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 681 | TEST_ASSERT(check_pointer(p) == 0); |
| 682 | TEST_ASSERT(mbedtls_calloc(1, 1) == NULL); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 683 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 684 | mbedtls_free(p); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 685 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 686 | p = mbedtls_calloc(1, sizeof(buf) - 2 * sizeof(memory_header) - 16); |
| 687 | q = mbedtls_calloc(1, 16); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 688 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 689 | TEST_ASSERT(check_pointer(p) == 0 && check_pointer(q) == 0); |
| 690 | TEST_ASSERT(mbedtls_calloc(1, 1) == NULL); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 691 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 692 | mbedtls_free(q); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 693 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 694 | TEST_ASSERT(mbedtls_calloc(1, 17) == NULL); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 695 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 696 | mbedtls_free(p); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 697 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 698 | TEST_ASSERT(check_all_free() == 0); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 699 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 700 | mbedtls_memory_buffer_alloc_free(); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 701 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 702 | if (verbose != 0) |
| 703 | mbedtls_printf("passed\n"); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 704 | |
| 705 | cleanup: |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 706 | mbedtls_memory_buffer_alloc_free(); |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 707 | |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 708 | return ret; |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 709 | } |
Mateusz Starzyk | c0eabdc | 2021-08-03 14:09:02 +0200 | [diff] [blame^] | 710 | # endif /* MBEDTLS_SELF_TEST */ |
Manuel Pégourié-Gonnard | 5ba1d52 | 2014-11-27 11:33:55 +0100 | [diff] [blame] | 711 | |
Manuel Pégourié-Gonnard | 2cf5a7c | 2015-04-08 12:49:31 +0200 | [diff] [blame] | 712 | #endif /* MBEDTLS_MEMORY_BUFFER_ALLOC_C */ |