Source code
Revision control
Copy as Markdown
Other Tools
/* -*- 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
/***********************************************************************
**
** 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,
0);
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;
}