nsprpub/pr/tests/dbmalloc.c

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 /***********************************************************************
   7 **
   8 ** Name: dbmalloc.c
   9 **
  10 ** Description: Testing malloc (OBSOLETE)
  11 **
  12 ** Modification History:
  13 ** 14-May-97 AGarcia- Converted the test to accomodate the debug_mode flag.
  14 **           The debug mode will print all of the printfs associated with this test.
  15 **           The regress mode will be the default mode. Since the regress tool limits
  16 **           the output to a one line status:PASS or FAIL,all of the printf statements
  17 **           have been handled with an if (debug_mode) statement.
  18 ***********************************************************************/
  19 #include <stdio.h>
  20 #include <stdlib.h>
  21 #include <time.h>
  22 #include <string.h>
  23 #include "nspr.h"
  24
  25 void
  26 usage
  27 (
  28     void
  29 )
  30 {
  31     fprintf(stderr, "Usage: dbmalloc ('-m'|'-s') '-f' num_fails ('-d'|'-n') filename [...]\n");
  32     exit(0);
  33 }
  34
  35 typedef struct node_struct
  36 {
  37     struct node_struct *next, *prev;
  38     int line;
  39     char value[4];
  40 }
  41 node_t,
  42 *node_pt;
  43
  44 node_pt get_node(const char *line)
  45 {
  46     node_pt rv;
  47     int l = strlen(line);
  48     rv = (node_pt)PR_MALLOC(sizeof(node_t) + l + 1 - 4);
  49     if( (node_pt)0 == rv ) {
  50         return (node_pt)0;
  51     }
  52     memcpy(&rv->value[0], line, l+1);
  53     rv->next = rv->prev = (node_pt)0;
  54     return rv;
  55 }
  56
  57 void
  58 dump
  59 (
  60     const char *name,
  61     node_pt     node,
  62     int         mf,
  63     int         debug
  64 )
  65 {
  66     if( (node_pt)0 != node->prev ) {
  67         dump(name, node->prev, mf, debug);
  68     }
  69     if( 0 != debug ) {
  70         printf("[%s]: %6d: %s", name, node->line, node->value);
  71     }
  72     if( node->line == mf ) {
  73         fprintf(stderr, "[%s]: Line %d was allocated!\n", name, node->line);
  74     }
  75     if( (node_pt)0 != node->next ) {
  76         dump(name, node->next, mf, debug);
  77     }
  78     return;
  79 }
  80
  81 void
  82 release
  83 (
  84     node_pt node
  85 )
  86 {
  87     if( (node_pt)0 != node->prev ) {
  88         release(node->prev);
  89     }
  90     if( (node_pt)0 != node->next ) {
  91         release(node->next);
  92     }
  93     PR_DELETE(node);
  94 }
  95
  96 int
  97 t2
  98 (
  99     const char *name,
 100     int         mf,
 101     int         debug
 102 )
 103 {
 104     int rv;
 105     FILE *fp;
 106     int l = 0;
 107     node_pt head = (node_pt)0;
 108     char buffer[ BUFSIZ ];
 109
 110     fp = fopen(name, "r");
 111     if( (FILE *)0 == fp )
 112     {
 113         fprintf(stderr, "[%s]: Cannot open \"%s.\"\n", name, name);
 114         return -1;
 115     }
 116
 117     /* fgets mallocs a buffer, first time through. */
 118     if( (char *)0 == fgets(buffer, BUFSIZ, fp) )
 119     {
 120         fprintf(stderr, "[%s]: \"%s\" is empty.\n", name, name);
 121         (void)fclose(fp);
 122         return -1;
 123     }
 124
 125     rewind(fp);
 126
 127     if( PR_SUCCESS != PR_ClearMallocCount() )
 128     {
 129         fprintf(stderr, "[%s]: Cannot clear malloc count.\n", name);
 130         (void)fclose(fp);
 131         return -1;
 132     }
 133
 134     if( PR_SUCCESS != PR_SetMallocCountdown(mf) )
 135     {
 136         fprintf(stderr, "[%s]: Cannot set malloc countdown to %d\n", name, mf);
 137         (void)fclose(fp);
 138         return -1;
 139     }
 140
 141     while( fgets(buffer, BUFSIZ, fp) )
 142     {
 143         node_pt n;
 144         node_pt *w = &head;
 145
 146         if( (strlen(buffer) == (BUFSIZ-1)) && (buffer[BUFSIZ-2] != '\n') ) {
 147             buffer[BUFSIZ-2] == '\n';
 148         }
 149
 150         l++;
 151
 152         n = get_node(buffer);
 153         if( (node_pt)0 == n )
 154         {
 155             printf("[%s]: Line %d: malloc failure!\n", name, l);
 156             continue;
 157         }
 158
 159         n->line = l;
 160
 161         while( 1 )
 162         {
 163             int comp;
 164
 165             if( (node_pt)0 == *w )
 166             {
 167                 *w = n;
 168                 break;
 169             }
 170
 171             comp = strcmp((*w)->value, n->value);
 172             if( comp < 0 ) {
 173                 w = &(*w)->next;
 174             }
 175             else {
 176                 w = &(*w)->prev;
 177             }
 178         }
 179     }
 180
 181     (void)fclose(fp);
 182
 183     dump(name, head, mf, debug);
 184
 185     rv = PR_GetMallocCount();
 186     PR_ClearMallocCountdown();
 187
 188     release(head);
 189
 190     return rv;
 191 }
 192
 193 int nf = 0;
 194 int debug = 0;
 195
 196 void
 197 test
 198 (
 199     const char *name
 200 )
 201 {
 202     int n, i;
 203
 204     extern int nf, debug;
 205
 206     printf("[%s]: starting test 0\n", name);
 207     n = t2(name, 0, debug);
 208     if( -1 == n ) {
 209         return;
 210     }
 211     printf("[%s]: test 0 had %ld allocations.\n", name, n);
 212
 213     if( 0 >= n ) {
 214         return;
 215     }
 216
 217     for( i = 0; i < nf; i++ )
 218     {
 219         int which = rand() % n;
 220         if( 0 == which ) {
 221             printf("[%s]: starting test %d -- no allocation should fail\n", name, i+1);
 222         }
 223         else {
 224             printf("[%s]: starting test %d -- allocation %d should fail\n", name, i+1, which);
 225         }
 226         (void)t2(name, which, debug);
 227         printf("[%s]: test %d done.\n", name, i+1);
 228     }
 229
 230     return;
 231 }
 232
 233 int main(int argc, char **argv)
 234 {
 235     int okay = 0;
 236     int multithread = 0;
 237
 238     struct threadlist
 239     {
 240         struct threadlist *next;
 241         PRThread *thread;
 242     }
 243     *threadhead = (struct threadlist *)0;
 244
 245     extern int nf, debug;
 246
 247     srand(time(0));
 248
 249     PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
 250     PR_STDIO_INIT();
 251
 252     printf("[main]: We %s using the debugging malloc.\n",
 253            PR_IsDebuggingMalloc() ? "ARE" : "ARE NOT");
 254
 255     while( argv++, --argc )
 256     {
 257         if( '-' == argv[0][0] )
 258         {
 259             switch( argv[0][1] )
 260             {
 261                 case 'f':
 262                     nf = atoi(argv[0][2] ? &argv[0][2] :
 263                               --argc ? *++argv : "0");
 264                     break;
 265                 case 'd':
 266                     debug = 1;
 267                     break;
 268                 case 'n':
 269                     debug = 0;
 270                     break;
 271                 case 'm':
 272                     multithread = 1;
 273                     break;
 274                 case 's':
 275                     multithread = 0;
 276                     break;
 277                 default:
 278                     usage();
 279                     break;
 280             }
 281         }
 282         else
 283         {
 284             FILE *fp = fopen(*argv, "r");
 285             if( (FILE *)0 == fp )
 286             {
 287                 fprintf(stderr, "Cannot open \"%s.\"\n", *argv);
 288                 continue;
 289             }
 290
 291             okay++;
 292             (void)fclose(fp);
 293             if( multithread )
 294             {
 295                 struct threadlist *n;
 296
 297                 n = (struct threadlist *)malloc(sizeof(struct threadlist));
 298                 if( (struct threadlist *)0 == n )
 299                 {
 300                     fprintf(stderr, "This is getting tedious. \"%s\"\n", *argv);
 301                     continue;
 302                 }
 303
 304                 n->next = threadhead;
 305                 n->thread = PR_CreateThread(PR_USER_THREAD, (void (*)(void *))test,
 306                                             *argv, PR_PRIORITY_NORMAL,
 307                                             PR_LOCAL_THREAD, PR_JOINABLE_THREAD,
 308                                             0);
 309                 if( (PRThread *)0 == n->thread )
 310                 {
 311                     fprintf(stderr, "Can't create thread for \"%s.\"\n", *argv);
 312                     continue;
 313                 }
 314                 else
 315                 {
 316                     threadhead = n;
 317                 }
 318             }
 319             else
 320             {
 321                 test(*argv);
 322             }
 323         }
 324     }
 325
 326     if( okay == 0 ) {
 327         usage();
 328     }
 329     else while( (struct threadlist *)0 != threadhead )
 330         {
 331             struct threadlist *x = threadhead->next;
 332             (void)PR_JoinThread(threadhead->thread);
 333             PR_DELETE(threadhead);
 334             threadhead = x;
 335         }
 336
 337     return 0;
 338 }
 339