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;
}