src/xmalloc.c

   1 /*
   2  * nao-ulib
   3  * Copyright 2011 Daniel Borkmann <dborkma@tik.ee.ethz.ch>
   4  * Subject to the GPL.
   5  * Nao-Team HTWK,
   6  * Faculty of Computer Science, Mathematics and Natural Sciences,
   7  * Leipzig University of Applied Sciences (HTWK Leipzig)
   8  */
   9
  10 /*
  11  * Copyright (C) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland,
  12  *                    All rights reserved
  13  * Copyright (C) 2010 Daniel Borkmann <daniel@netyack.org>,
  14  *                    Ported from SSH and added several other functions and
  15  *                    heap consistency checks
  16  *
  17  * Versions of malloc and friends that check their results, and never return
  18  * failure (they call fatal if they encounter an error).
  19  *
  20  * As far as I am concerned, the code I have written for this software
  21  * can be used freely for any purpose.  Any derived versions of this
  22  * software must be clearly marked as such, and if the derived work is
  23  * incompatible with the protocol description in the RFC file, it must be
  24  * called by a name other than "ssh" or "Secure Shell".
  25  */
  26
  27 #define _GNU_SOURCE
  28 #include <stdarg.h>
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <signal.h>
  33 #include <mcheck.h>
  34 #include <unistd.h>
  35 #include <malloc.h>
  36 #include <sys/ioctl.h>
  37
  38 #ifndef SIZE_T_MAX
  39 # define SIZE_T_MAX  ((size_t) ~0)
  40 #endif
  41
  42 #include "comp_x86.h"
  43 #include "cache_x86.h"
  44 #include "xmalloc.h"
  45 #include "strlcpy.h"
  46 #include "die.h"
  47 #include "stacktrace.h"
  48
  49 static void mcheck_abort(enum mcheck_status stat)
  50 {
  51         if (stat != MCHECK_OK)
  52                 panic("mcheck: mem inconsistency detected: %d\n", stat);
  53 }
  54
  55 static void xmalloc_mcheck_init(void)
  56 {
  57         /*
  58          * If we would use mcheck_pedantic() here, then libloudmouth
  59          * is not able to perform SSL/TLS authentication. Weird.
  60          */
  61         int ret = mcheck(mcheck_abort);
  62         if (ret < 0)
  63                 panic("xmalloc: cannot init mcheck! bug\n");
  64
  65         mtrace();
  66 }
  67
  68 static void xmalloc_init_hook(void)
  69 {
  70         xmalloc_mcheck_init();
  71 }
  72
  73 void (*__malloc_initialize_hook)(void) = xmalloc_init_hook;
  74
  75 __hidden void muntrace_handler(int signal)
  76 {
  77         if (signal != SIGSEGV) {
  78                 muntrace();
  79                 return;
  80         }
  81
  82         info("Oops, SIGSEGV received!\n");
  83         info("Stacktrace:\n");
  84         stacktrace();
  85         info("@('_')@ __.-<^*Panic!*^>\n");
  86         sync_o();
  87         muntrace();
  88         abort();
  89 }
  90
  91 __hidden int xmem_used(void)
  92 {
  93         struct mallinfo mi = mallinfo();
  94         return mi.uordblks;
  95 }
  96
  97 __hidden int xmem_free(void)
  98 {
  99         struct mallinfo mi = mallinfo();
 100         return mi.fordblks;
 101 }
 102
 103 __hidden int xmem_totalarena(void)
 104 {
 105         struct mallinfo mi = mallinfo();
 106         return mi.arena;
 107 }
 108
 109 __hidden void *xmalloc(size_t size)
 110 {
 111         void *ptr;
 112         enum mcheck_status stat;
 113
 114         if (size == 0)
 115                 panic("xmalloc: zero size\n");
 116
 117         ptr = malloc(size);
 118         if (ptr == NULL)
 119                 panic("xmalloc: out of memory (allocating %lu bytes)\n",
 120                       (u_long) size);
 121         stat = mprobe(ptr);
 122         if (stat != MCHECK_OK)
 123                 panic("xmalloc: mem inconsistency detected: %d\n", stat);
 124
 125         debug("%p: %zu", ptr, size);
 126         return ptr;
 127 }
 128
 129 __hidden void *xvalloc(size_t size)
 130 {
 131         void *ptr;
 132         enum mcheck_status stat;
 133
 134         if (size == 0)
 135                 panic("xmalloc: zero size\n");
 136
 137         ptr = valloc(size);
 138         if (ptr == NULL)
 139                 panic("xvalloc: out of memory (allocating %lu bytes)\n",
 140                       (u_long) size);
 141         stat = mprobe(ptr);
 142         if (stat != MCHECK_OK)
 143                 panic("xvalloc: mem inconsistency detected: %d\n", stat);
 144
 145         debug("%p: %zu", ptr, size);
 146         return ptr;
 147 }
 148
 149 __hidden void *xzmalloc(size_t size)
 150 {
 151         void *ptr;
 152         enum mcheck_status stat;
 153
 154         if (size == 0)
 155                 panic("xzmalloc: zero size\n");
 156
 157         ptr = malloc(size);
 158         if (ptr == NULL)
 159                 panic("xzmalloc: out of memory (allocating %lu bytes)\n",
 160                       (u_long) size);
 161         stat = mprobe(ptr);
 162         if (stat != MCHECK_OK)
 163                 panic("xzmalloc: mem inconsistency detected: %d\n", stat);
 164         memset(ptr, 0, size);
 165
 166         debug("%p: %zu", ptr, size);
 167         return ptr;
 168 }
 169
 170 __hidden void *xmalloc_aligned(size_t size, size_t alignment)
 171 {
 172         int ret;
 173         void *ptr;
 174         enum mcheck_status stat;
 175
 176         if (size == 0)
 177                 panic("xmalloc_aligned: zero size\n");
 178
 179         ret = posix_memalign(&ptr, alignment, size);
 180         if (ret != 0)
 181                 panic("xmalloc_aligned: out of memory (allocating %lu bytes)\n",
 182                       (u_long) size);
 183         stat = mprobe(ptr);
 184         if (stat != MCHECK_OK)
 185                 panic("xmalloc_aligned: mem inconsistency detected: %d\n", stat);
 186
 187         debug("%p: %zu", ptr, size);
 188         return ptr;
 189 }
 190
 191 __hidden void *xmalloc_geode_l1_cl_aligned(size_t size)
 192 {
 193         return xmalloc_aligned(size, GEODE_CACHE_LINE_SIZE);
 194 }
 195
 196 __hidden void *xmalloc_geode_l2_cl_aligned(size_t size)
 197 {
 198         return xmalloc_aligned(size, GEODE_CACHE_LINE_SIZE);
 199 }
 200
 201 __hidden void *xmallocz(size_t size)
 202 {
 203         void *ptr;
 204
 205         if (size + 1 < size)
 206                 panic("xmallocz: data too large to fit into virtual "
 207                       "memory space\n");
 208
 209         ptr = xmalloc(size + 1);
 210         ((char*) ptr)[size] = 0;
 211
 212         return ptr;
 213 }
 214
 215 __hidden void *xmemdupz(const void *data, size_t len)
 216 {
 217         return memcpy(xmallocz(len), data, len);
 218 }
 219
 220 __hidden void *xcalloc(size_t nmemb, size_t size)
 221 {
 222         void *ptr;
 223         enum mcheck_status stat;
 224
 225         if (size == 0 || nmemb == 0)
 226                 panic("xcalloc: zero size\n");
 227         if (SIZE_T_MAX / nmemb < size)
 228                 panic("xcalloc: nmemb * size > SIZE_T_MAX\n");
 229
 230         ptr = calloc(nmemb, size);
 231         if (ptr == NULL)
 232                 panic("xcalloc: out of memory (allocating %lu bytes)\n",
 233                       (u_long) (size * nmemb));
 234         stat = mprobe(ptr);
 235         if (stat != MCHECK_OK)
 236                 panic("xcalloc: mem inconsistency detected: %d\n", stat);
 237
 238         debug("%p: %zu", ptr, size);
 239         return ptr;
 240 }
 241
 242 __hidden void *xrealloc(void *ptr, size_t nmemb, size_t size)
 243 {
 244         void *new_ptr;
 245         size_t new_size = nmemb * size;
 246         enum mcheck_status stat;
 247
 248         if (new_size == 0)
 249                 panic("xrealloc: zero size\n");
 250         if (SIZE_T_MAX / nmemb < size)
 251                 panic("xrealloc: nmemb * size > SIZE_T_MAX\n");
 252
 253         if (ptr == NULL)
 254                 new_ptr = malloc(new_size);
 255         else
 256                 new_ptr = realloc(ptr, new_size);
 257
 258         if (new_ptr == NULL)
 259                 panic("xrealloc: out of memory (new_size %lu bytes)\n",
 260                       (u_long) new_size);
 261         stat = mprobe(ptr);
 262         if (stat != MCHECK_OK)
 263                 panic("xrealloc: mem inconsistency detected: %d\n", stat);
 264
 265         debug("%p: %zu => %p: %zu", ptr, size, new_ptr, new_size);
 266         return new_ptr;
 267 }
 268
 269 __hidden void xfree(void *ptr)
 270 {
 271         enum mcheck_status stat;
 272
 273         if (ptr == NULL)
 274                 panic("xfree: NULL pointer given as argument\n");
 275
 276         stat = mprobe(ptr);
 277         if (stat != MCHECK_OK)
 278                 panic("xfree: mem inconsistency detected: %d\n", stat);
 279
 280         debug("%p => 0", ptr);
 281         free(ptr);
 282 }
 283
 284 __hidden char *xstrdup(const char *str)
 285 {
 286         size_t len;
 287         char *cp;
 288
 289         len = strlen(str) + 1;
 290         cp = xmalloc(len);
 291         strlcpy(cp, str, len);
 292
 293         return cp;
 294 }
 295
 296 __hidden char *xstrndup(const char *str, size_t size)
 297 {
 298         size_t len;
 299         char *cp;
 300
 301         len = strlen(str) + 1;
 302         if (size < len)
 303                 len = size;
 304
 305         cp = xmalloc(len);
 306         strlcpy(cp, str, len);
 307
 308         return cp;
 309 }
 310
 311 __hidden int xdup(int fd)
 312 {
 313         int ret = dup(fd);
 314         if (ret < 0)
 315                 panic("xdup: dup failed\n");
 316
 317         return ret;
 318 }
 319
 320 int __xioctl(int fd, int req, void *arg)
 321 {
 322         int ret;
 323
 324         do ret = ioctl(fd, req, arg);
 325         while (ret < 0 && EINTR == errno);
 326
 327         return ret;
 328 }
 329