The Tor Browser: nsprpub/pr/tests/dbmalloc.c@b8a032363ba2 (annotated)

nsprpub/pr/tests/dbmalloc.c@b8a032363ba2 (annotated)

nsprpub/pr/tests/dbmalloc.c

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 /***********************************************************************
 **
 ** Name: dbmalloc.c
 **
 ** Description: Testing malloc (OBSOLETE)
 **
 ** Modification History:
 ** 14-May-97 AGarcia- Converted the test to accomodate the debug_mode flag.
 **	         The debug mode will print all of the printfs associated with this test.
 **			 The regress mode will be the default mode. Since the regress tool limits
 **           the output to a one line status:PASS or FAIL,all of the printf statements
 **			 have been handled with an if (debug_mode) statement.
 ***********************************************************************/
 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 #include <string.h>
 #include "nspr.h"
 void
 usage
 (
     void
 )
 {
     fprintf(stderr, "Usage: dbmalloc ('-m'|'-s') '-f' num_fails ('-d'|'-n') filename [...]\n");
     exit(0);
 }
 typedef struct node_struct
 {
     struct node_struct *next, *prev;
     int line;
     char value[4];
 }
     node_t,
    *node_pt;
 node_pt get_node(const char *line)
 {
     node_pt rv;
     int l = strlen(line);
     rv = (node_pt)PR_MALLOC(sizeof(node_t) + l + 1 - 4);
     if( (node_pt)0 == rv ) return (node_pt)0;
     memcpy(&rv->value[0], line, l+1);
     rv->next = rv->prev = (node_pt)0;
     return rv;
 }
 void
 dump
 (
     const char *name,
     node_pt     node,
     int         mf,
     int         debug
 )
 {
     if( (node_pt)0 != node->prev ) dump(name, node->prev, mf, debug);
     if( 0 != debug ) printf("[%s]: %6d: %s", name, node->line, node->value);
     if( node->line == mf ) fprintf(stderr, "[%s]: Line %d was allocated!\n", name, node->line);
     if( (node_pt)0 != node->next ) dump(name, node->next, mf, debug);
     return;
 }
 void
 release
 (
     node_pt node
 )
 {
     if( (node_pt)0 != node->prev ) release(node->prev);
     if( (node_pt)0 != node->next ) release(node->next);
     PR_DELETE(node);
 }
 int
 t2
 (
     const char *name,
     int         mf,
     int         debug
 )
 {
     int rv;
     FILE *fp;
     int l = 0;
     node_pt head = (node_pt)0;
     char buffer[ BUFSIZ ];
     fp = fopen(name, "r");
     if( (FILE *)0 == fp )
     {
         fprintf(stderr, "[%s]: Cannot open \"%s.\"\n", name, name);
         return -1;
     }
     /* fgets mallocs a buffer, first time through. */
     if( (char *)0 == fgets(buffer, BUFSIZ, fp) )
     {
         fprintf(stderr, "[%s]: \"%s\" is empty.\n", name, name);
         (void)fclose(fp);
         return -1;
     }
     rewind(fp);
     if( PR_SUCCESS != PR_ClearMallocCount() )
     {
         fprintf(stderr, "[%s]: Cannot clear malloc count.\n", name);
         (void)fclose(fp);
         return -1;
     }
     if( PR_SUCCESS != PR_SetMallocCountdown(mf) )
     {
         fprintf(stderr, "[%s]: Cannot set malloc countdown to %d\n", name, mf);
         (void)fclose(fp);
         return -1;
     }
     while( fgets(buffer, BUFSIZ, fp) )
     {
         node_pt n;
         node_pt *w = &head;
         if( (strlen(buffer) == (BUFSIZ-1)) && (buffer[BUFSIZ-2] != '\n') )
             buffer[BUFSIZ-2] == '\n';
         l++;
         n = get_node(buffer);
         if( (node_pt)0 == n )
         {
             printf("[%s]: Line %d: malloc failure!\n", name, l);
             continue;
         }
         n->line = l;
         while( 1 )
         {
             int comp;
             if( (node_pt)0 == *w )
             {
                 *w = n;
                 break;
             }
             comp = strcmp((*w)->value, n->value);
             if( comp < 0 ) w = &(*w)->next;
             else w = &(*w)->prev;
         }
     }
     (void)fclose(fp);
     dump(name, head, mf, debug);
     rv = PR_GetMallocCount();
     PR_ClearMallocCountdown();
     release(head);
     return rv;
 }
 int nf = 0;
 int debug = 0;
 void
 test
 (
     const char *name
 )
 {
     int n, i;
     extern int nf, debug;
     printf("[%s]: starting test 0\n", name);
     n = t2(name, 0, debug);
     if( -1 == n ) return;
     printf("[%s]: test 0 had %ld allocations.\n", name, n);
     if( 0 >= n ) return;
     for( i = 0; i < nf; i++ )
     {
         int which = rand() % n;
         if( 0 == which ) printf("[%s]: starting test %d -- no allocation should fail\n", name, i+1);
         else printf("[%s]: starting test %d -- allocation %d should fail\n", name, i+1, which);
         (void)t2(name, which, debug);
         printf("[%s]: test %d done.\n", name, i+1);
     }
     return;
 }
 int main(int argc, char **argv)
 {
     int okay = 0;
     int multithread = 0;
     struct threadlist
     {
         struct threadlist *next;
         PRThread *thread;
     }
         *threadhead = (struct threadlist *)0;
     extern int nf, debug;
     srand(time(0));
     PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);
     PR_STDIO_INIT();
     printf("[main]: We %s using the debugging malloc.\n",
            PR_IsDebuggingMalloc() ? "ARE" : "ARE NOT");
     while( argv++, --argc )
     {
         if( '-' == argv[0][0] )
         {
             switch( argv[0][1] )
             {
                 case 'f':
                     nf = atoi(argv[0][2] ? &argv[0][2] :
                               --argc ? *++argv : "0");
                     break;
                 case 'd':
                     debug = 1;
                     break;
                 case 'n':
                     debug = 0;
                     break;
                 case 'm':
                     multithread = 1;
                     break;
                 case 's':
                     multithread = 0;
                     break;
                 default:
                     usage();
                     break;
             }
         }
         else
         {
             FILE *fp = fopen(*argv, "r");
             if( (FILE *)0 == fp )
             {
                 fprintf(stderr, "Cannot open \"%s.\"\n", *argv);
                 continue;
             }
             okay++;
             (void)fclose(fp);
             if( multithread )
             {
                 struct threadlist *n;
                 n = (struct threadlist *)malloc(sizeof(struct threadlist));
                 if( (struct threadlist *)0 == n )
                 {
                     fprintf(stderr, "This is getting tedious. \"%s\"\n", *argv);
                     continue;
                 }
                 n->next = threadhead;
                 n->thread = PR_CreateThread(PR_USER_THREAD, (void (*)(void *))test,
                                             *argv, PR_PRIORITY_NORMAL,
                                             PR_LOCAL_THREAD, PR_JOINABLE_THREAD,
 );
                 if( (PRThread *)0 == n->thread )
                 {
                     fprintf(stderr, "Can't create thread for \"%s.\"\n", *argv);
                     continue;
                 }
                 else
                 {
                     threadhead = n;
                 }
             }
             else
             {
                 test(*argv);
             }
         }
     }
     if( okay == 0 ) usage();
     else while( (struct threadlist *)0 != threadhead )
     {
         struct threadlist *x = threadhead->next;
         (void)PR_JoinThread(threadhead->thread);
         PR_DELETE(threadhead);
         threadhead = x;
     }
     return 0;
 }

The Tor Browser / annotate

nsprpub/pr/tests/dbmalloc.c@b8a032363ba2 (annotated)

nsprpub/pr/tests/dbmalloc.c