test/test.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2016, Olivier MATZ <zer0@droids-corp.org>
   3  */
   4
   5 #include <stdlib.h>
   6 #include <stdio.h>
   7 #include <assert.h>
   8 #include <getopt.h>
   9 #include <limits.h>
  10 #include <execinfo.h>
  11 #include <errno.h>
  12
  13 #include <ecoli_init.h>
  14 #include <ecoli_log.h>
  15 #include <ecoli_test.h>
  16 #include <ecoli_malloc.h>
  17
  18 /* LCOV_EXCL_START */
  19 EC_LOG_TYPE_REGISTER(main);
  20
  21 #define COUNT_OF(x) ((sizeof(x)/sizeof(0[x])) / \
  22                 ((size_t)(!(sizeof(x) % sizeof(0[x])))))
  23
  24 static int log_level = EC_LOG_INFO;
  25 static int alloc_fail_proba = 0;
  26 static int seed = 0;
  27 static size_t alloc_success = 0;
  28
  29 static const char ec_short_options[] =
  30         "h"  /* help */
  31         "l:" /* log-level */
  32         "r:" /* random-alloc-fail */
  33         "s:" /* seed */
  34         ;
  35
  36 #define EC_OPT_HELP "help"
  37 #define EC_OPT_LOG_LEVEL "log-level"
  38 #define EC_OPT_RANDOM_ALLOC_FAIL "random-alloc-fail"
  39 #define EC_OPT_SEED "seed"
  40
  41 static const struct option ec_long_options[] = {
  42         {EC_OPT_HELP, 0, NULL, 'h'},
  43         {EC_OPT_LOG_LEVEL, 1, NULL, 'l'},
  44         {EC_OPT_RANDOM_ALLOC_FAIL, 1, NULL, 'r'},
  45         {EC_OPT_SEED, 1, NULL, 's'},
  46         {NULL, 0, NULL, 0}
  47 };
  48
  49 static void usage(const char *prgname)
  50 {
  51         fprintf(stderr, "%s [options] [test1 test2 test3...]\n"
  52                 "  -h\n"
  53                 "  --"EC_OPT_HELP"\n"
  54                 "      Show this help.\n"
  55                 "  -l <level>\n"
  56                 "  --"EC_OPT_LOG_LEVEL"=<level>\n"
  57                 "      Set log level (0 = no log, 7 = verbose).\n"
  58                 "  -r <probability>\n"
  59                 "  --"EC_OPT_RANDOM_ALLOC_FAIL"=<probability>\n"
  60                 "      Cause malloc to fail randomly. This helps to debug\n"
  61                 "      leaks or crashes in error cases. The probability is\n"
  62                 "      between 0 and 100.\n"
  63                 "  -s <seed>\n"
  64                 "  --seed=<seed>\n"
  65                 "      Seeds the random number generator. Default is 0.\n"
  66                 , prgname);
  67 }
  68
  69 static int
  70 parse_int(const char *s, int min, int max, int *ret, unsigned int base)
  71 {
  72         char *end = NULL;
  73         long long n;
  74
  75         n = strtoll(s, &end, base);
  76         if ((s[0] == '\0') || (end == NULL) || (*end != '\0'))
  77                 return -1;
  78         if (n < min)
  79                 return -1;
  80         if (n > max)
  81                 return -1;
  82
  83         *ret = n;
  84         return 0;
  85 }
  86
  87 static int parse_args(int argc, char **argv)
  88 {
  89         int ret, opt;
  90
  91         while ((opt = getopt_long(argc, argv, ec_short_options,
  92                                 ec_long_options, NULL)) != EOF) {
  93
  94                 switch (opt) {
  95                 case 'h': /* help */
  96                         usage(argv[0]);
  97                         exit(0);
  98
  99                 case 'l': /* log-level */
 100                         if (parse_int(optarg, EC_LOG_EMERG,
 101                                         EC_LOG_DEBUG, &log_level, 10) < 0) {
 102                                 printf("Invalid log value\n");
 103                                 usage(argv[0]);
 104                                 exit(1);
 105                         }
 106                         break;
 107
 108                 case 'r': /* random-alloc-fail */
 109                         if (parse_int(optarg, 0, 100, &alloc_fail_proba,
 110                                         10) < 0) {
 111                                 printf("Invalid probability value\n");
 112                                 usage(argv[0]);
 113                                 exit(1);
 114                         }
 115                         break;
 116
 117                 case 's': /* seed */
 118                         if (parse_int(optarg, 0, INT_MAX, &seed, 10) < 0) {
 119                                 printf("Invalid seed value\n");
 120                                 usage(argv[0]);
 121                                 exit(1);
 122                         }
 123                         break;
 124
 125                 default:
 126                         usage(argv[0]);
 127                         return -1;
 128                 }
 129         }
 130
 131         ret = optind - 1;
 132         optind = 1;
 133
 134         return ret;
 135 }
 136
 137 TAILQ_HEAD(debug_alloc_hdr_list, debug_alloc_hdr);
 138 static struct debug_alloc_hdr_list debug_alloc_hdr_list =
 139         TAILQ_HEAD_INITIALIZER(debug_alloc_hdr_list);
 140
 141 #define STACK_SZ 16
 142 struct debug_alloc_hdr {
 143         TAILQ_ENTRY(debug_alloc_hdr) next;
 144         const char *file;
 145         unsigned int seq;
 146         unsigned int line;
 147         size_t size;
 148         void *stack[STACK_SZ];
 149         int stacklen;
 150         unsigned int cookie;
 151 };
 152
 153 struct debug_alloc_ftr {
 154         unsigned int cookie;
 155 } __attribute__((packed));
 156
 157 static int malloc_seq;
 158
 159 static void *debug_malloc(size_t size, const char *file, unsigned int line)
 160 {
 161         struct debug_alloc_hdr *hdr;
 162         struct debug_alloc_ftr *ftr;
 163         size_t new_size = size + sizeof(*hdr) + sizeof(*ftr);
 164         void *ret;
 165         int r = random();
 166
 167         if (alloc_fail_proba != 0 && (r % 100) < alloc_fail_proba)
 168                 hdr = NULL;
 169         else
 170                 hdr = malloc(new_size);
 171
 172         if (hdr == NULL) {
 173                 ret = NULL;
 174         } else {
 175                 hdr->seq = malloc_seq;
 176                 hdr->file = file;
 177                 hdr->line = line;
 178                 hdr->size = size;
 179                 hdr->stacklen = backtrace(hdr->stack, COUNT_OF(hdr->stack));
 180                 hdr->cookie = 0x12345678;
 181                 TAILQ_INSERT_TAIL(&debug_alloc_hdr_list, hdr, next);
 182                 ret = hdr + 1;
 183                 ftr = (struct debug_alloc_ftr *)(
 184                         (char *)hdr + size + sizeof(*hdr));
 185                 ftr->cookie = 0x87654321;
 186         }
 187
 188         EC_LOG(EC_LOG_DEBUG, "%s:%d: info: malloc(%zd) -> %p seq=%d\n",
 189                 file, line, size, ret, malloc_seq++);
 190
 191         if (ret)
 192                 alloc_success++;
 193         return ret;
 194 }
 195
 196 static void debug_free(void *ptr, const char *file, unsigned int line)
 197 {
 198         struct debug_alloc_hdr *hdr, *h;
 199         struct debug_alloc_ftr *ftr;
 200
 201         (void)file;
 202         (void)line;
 203
 204         EC_LOG(EC_LOG_DEBUG, "%s:%d: info: free(%p)\n", file, line, ptr);
 205
 206         if (ptr == NULL)
 207                 return;
 208
 209         hdr = (ptr - sizeof(*hdr));
 210         if (hdr->cookie != 0x12345678) {
 211                 EC_LOG(EC_LOG_ERR, "%s:%d: error: free(%p): bad start cookie\n",
 212                         file, line, ptr);
 213                 abort();
 214         }
 215
 216         ftr = (ptr + hdr->size);
 217         if (ftr->cookie != 0x87654321) {
 218                 EC_LOG(EC_LOG_ERR, "%s:%d: error: free(%p): bad end cookie\n",
 219                         file, line, ptr);
 220                 abort();
 221         }
 222
 223         TAILQ_FOREACH(h, &debug_alloc_hdr_list, next) {
 224                 if (h == hdr)
 225                         break;
 226         }
 227
 228         if (h == NULL) {
 229                 EC_LOG(EC_LOG_ERR, "%s:%d: error: free(%p): bad ptr\n",
 230                         file, line, ptr);
 231                 abort();
 232         }
 233
 234         TAILQ_REMOVE(&debug_alloc_hdr_list, hdr, next);
 235         free(hdr);
 236 }
 237
 238 static void *debug_realloc(void *ptr, size_t size, const char *file,
 239         unsigned int line)
 240 {
 241         struct debug_alloc_hdr *hdr, *h;
 242         struct debug_alloc_ftr *ftr;
 243         size_t new_size = size + sizeof(*hdr) + sizeof(unsigned int);
 244         void *ret;
 245
 246         if (ptr != NULL) {
 247                 hdr =  (ptr - sizeof(*hdr));
 248                 if (hdr->cookie != 0x12345678) {
 249                         EC_LOG(EC_LOG_ERR,
 250                                 "%s:%d: error: realloc(%p): bad start cookie\n",
 251                                 file, line, ptr);
 252                         abort();
 253                 }
 254
 255                 ftr = (ptr + hdr->size);
 256                 if (ftr->cookie != 0x87654321) {
 257                         EC_LOG(EC_LOG_ERR,
 258                                 "%s:%d: error: realloc(%p): bad end cookie\n",
 259                                 file, line, ptr);
 260                         abort();
 261                 }
 262
 263                 TAILQ_FOREACH(h, &debug_alloc_hdr_list, next) {
 264                         if (h == hdr)
 265                                 break;
 266                 }
 267
 268                 if (h == NULL) {
 269                         EC_LOG(EC_LOG_ERR, "%s:%d: error: realloc(%p): bad ptr\n",
 270                                 file, line, ptr);
 271                         abort();
 272                 }
 273
 274                 TAILQ_REMOVE(&debug_alloc_hdr_list, h, next);
 275                 hdr = realloc(hdr, new_size);
 276                 if (hdr == NULL) {
 277                         TAILQ_INSERT_TAIL(&debug_alloc_hdr_list, h, next);
 278                         ret = NULL;
 279                 } else {
 280                         ret = hdr + 1;
 281                 }
 282         } else {
 283                 hdr = realloc(NULL, new_size);
 284                 if (hdr == NULL)
 285                         ret = NULL;
 286                 else
 287                         ret = hdr + 1;
 288         }
 289
 290         if (hdr != NULL) {
 291                 hdr->seq = malloc_seq;
 292                 hdr->file = file;
 293                 hdr->line = line;
 294                 hdr->size = size;
 295                 hdr->stacklen = backtrace(hdr->stack, COUNT_OF(hdr->stack));
 296                 hdr->cookie = 0x12345678;
 297                 TAILQ_INSERT_TAIL(&debug_alloc_hdr_list, hdr, next);
 298                 ftr = (struct debug_alloc_ftr *)(
 299                         (char *)hdr + size + sizeof(*hdr));
 300                 ftr->cookie = 0x87654321;
 301         }
 302
 303         EC_LOG(EC_LOG_DEBUG, "%s:%d: info: realloc(%p, %zd) -> %p seq=%d\n",
 304                 file, line, ptr, size, ret, malloc_seq++);
 305
 306         if (ret)
 307                 alloc_success++;
 308         return ret;
 309 }
 310
 311 static int debug_alloc_dump_leaks(void)
 312 {
 313         struct debug_alloc_hdr *hdr;
 314         int i;
 315         char **buffer;
 316
 317         EC_LOG(EC_LOG_INFO, "%zd successful allocations\n", alloc_success);
 318
 319         if (TAILQ_EMPTY(&debug_alloc_hdr_list))
 320                 return 0;
 321
 322         TAILQ_FOREACH(hdr, &debug_alloc_hdr_list, next) {
 323                 EC_LOG(EC_LOG_ERR,
 324                         "%s:%d: error: memory leak seq=%u size=%zd ptr=%p\n",
 325                         hdr->file, hdr->line, hdr->seq, hdr->size, hdr + 1);
 326                 buffer = backtrace_symbols(hdr->stack, hdr->stacklen);
 327                 if (buffer == NULL) {
 328                         for (i = 0; i < hdr->stacklen; i++)
 329                                 EC_LOG(EC_LOG_ERR, "  %p\n", hdr->stack[i]);
 330                 } else {
 331                         for (i = 0; i < hdr->stacklen; i++)
 332                                 EC_LOG(EC_LOG_ERR, "  %s\n",
 333                                         buffer ? buffer[i] : "unknown");
 334                 }
 335                 free(buffer);
 336         }
 337
 338         EC_LOG(EC_LOG_ERR,
 339                 "  missing static syms, use: addr2line -f -e <prog> <addr>\n");
 340
 341         return -1;
 342 }
 343
 344 static int debug_log(int type, unsigned int level, void *opaque,
 345                 const char *str)
 346 {
 347         (void)type;
 348         (void)opaque;
 349
 350         if (level > (unsigned int)log_level)
 351                 return 0;
 352
 353         if (printf("%s", str) < 0)
 354                 return -1;
 355
 356         return 0;
 357 }
 358
 359 int main(int argc, char **argv)
 360 {
 361         int i, ret = 0, leaks;
 362
 363         ret = parse_args(argc, argv);
 364         if (ret < 0)
 365                 return 1;
 366
 367         argc -= ret;
 368         argv += ret;
 369
 370         srandom(seed);
 371
 372         /* register a new malloc to track memleaks */
 373         TAILQ_INIT(&debug_alloc_hdr_list);
 374         if (ec_malloc_register(debug_malloc, debug_free, debug_realloc) < 0) {
 375                 EC_LOG(EC_LOG_ERR, "cannot register new malloc\n");
 376                 return 1;
 377         }
 378
 379         if (ec_init() < 0) {
 380                 fprintf(stderr, "cannot init ecoli: %s\n", strerror(errno));
 381                 return 1;
 382         }
 383         ec_log_fct_register(debug_log, NULL);
 384
 385         ret = 0;
 386         if (argc <= 1) {
 387                 ret = ec_test_all();
 388         } else {
 389                 for (i = 1; i < argc; i++)
 390                         ret |= ec_test_one(argv[i]);
 391         }
 392
 393         ec_exit();
 394
 395         leaks = debug_alloc_dump_leaks();
 396
 397         if (alloc_fail_proba == 0 && ret != 0) {
 398                 printf("tests failed\n");
 399                 return 1;
 400         } else if (alloc_fail_proba != 0 && leaks != 0) {
 401                 printf("tests failed (memory leak)\n");
 402                 return 1;
 403         }
 404
 405         printf("\ntests ok\n");
 406
 407         return 0;
 408 }
 409 /* LCOV_EXCL_STOP */