mud-memory.c File Reference

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <windows.h>
#include <winsock.h>
#include <richedit.h>
#include "mud-client.h"
#include <assert.h>

Include dependency graph for mud-memory.c:

Go to the source code of this file.

Defines
#define	DEBUG
#define	MALLOC_LOG
#define	MINEFIELD
#define	PAGESIZE   4096
#define	PAGESIZE   4096
Functions
void	debug_memdump (void *buf, int len, int L)
void	dprintf (char *fmt,...)
void	dputs (char *buf)
void	minefield_admin_hide (int hide)
void *	minefield_alloc (int size)
void	minefield_bomb (void)
void	minefield_c_free (void *p)
void *	minefield_c_malloc (size_t size)
void *	minefield_c_realloc (void *p, size_t size)
void	minefield_free (void *ptr)
int	minefield_get_size (void *ptr)
void	minefield_init (void)
void	mlog (char *file, int line)
void	safefree (void *ptr)
void *	safemalloc (size_t size)
void *	saferealloc (void *ptr, size_t size)
Variables
FILE *	debug_fp = NULL
int	debug_got_console = 0
FILE *	fp = NULL
unsigned short *	minefield_admin = NULL
long	minefield_curpos = 0
int	minefield_initialised = 0
long	minefield_npages = 0
void *	minefield_pages = NULL
void *	minefield_region = NULL
long	minefield_size = 0
char *	mlog_file = NULL
int	mlog_line = 0

---

Define Documentation

#define DEBUG

Definition at line 21 of file mud-memory.c.

#define MALLOC_LOG

Definition at line 19 of file mud-memory.c.

#define MINEFIELD

Definition at line 17 of file mud-memory.c.

#define PAGESIZE   4096

Definition at line 37 of file mud-memory.c.

#define PAGESIZE   4096

Definition at line 37 of file mud-memory.c. Referenced by minefield_alloc(), minefield_free(), minefield_get_size(), and minefield_init().

---

Function Documentation

void debug_memdump (  void *  buf, int  len, int  L )

Definition at line 396 of file mud-memory.c. References dprintf(), and dputs(). { int i; unsigned char *p = buf; char foo[17]; if (L) { int delta; dprintf("\t%d (0x%x) bytes:\n", len, len); delta = 15 & (int) p; p -= delta; len += delta; } for (; 0 < len; p += 16, len -= 16) { dputs(" "); if (L) dprintf("%p: ", p); strcpy(foo, "................"); /* sixteen dots */ for (i = 0; i < 16 && i < len; ++i) { if (&p[i] < (unsigned char *) buf) { dputs(" "); /* 3 spaces */ foo[i] = ' '; } else { dprintf("%c%02.2x", &p[i] != (unsigned char *) buf && i % 4 ? '.' : ' ', p[i] ); if (p[i] >= ' ' && p[i] <= '~') foo[i] = (char) p[i]; } } foo[i] = '\0'; dprintf("%*s%s\n", (16 - i) * 3 + 2, "", foo); } }

Here is the call graph for this function:

void dprintf (  char *  fmt,   ... )

Definition at line 384 of file mud-memory.c. References dputs(). Referenced by debug_memdump(). { char buf[2048]; va_list ap; va_start(ap, fmt); vsprintf(buf, fmt, ap); dputs(buf); va_end(ap); }

Here is the call graph for this function:

void dputs (  char *  buf  )  [static]

Definition at line 365 of file mud-memory.c. References debug_fp, and debug_got_console. Referenced by debug_memdump(), and dprintf(). { DWORD dw; if (!debug_got_console) { AllocConsole(); debug_got_console = 1; } if (!debug_fp) { debug_fp = fopen("debug.log", "w"); } WriteFile(GetStdHandle(STD_OUTPUT_HANDLE), buf, strlen(buf), &dw, NULL); fputs(buf, debug_fp); fflush(debug_fp); }

void minefield_admin_hide (  int  hide  )  [static]

Definition at line 62 of file mud-memory.c. References minefield_admin, and minefield_npages. Referenced by minefield_alloc(), minefield_free(), minefield_get_size(), and minefield_init(). { int access = hide ? PAGE_NOACCESS : PAGE_READWRITE; VirtualProtect(minefield_admin, minefield_npages * 2, access, NULL); }

void* minefield_alloc (  int  size  )  [static]

Definition at line 117 of file mud-memory.c. References minefield_admin, minefield_admin_hide(), minefield_curpos, minefield_pages, PAGESIZE, and pos. Referenced by minefield_c_malloc(), and minefield_c_realloc(). { int npages; int pos, lim, region_end, region_start; int start; int i; npages = (size + PAGESIZE - 1) / PAGESIZE; minefield_admin_hide(0); /* * Search from current position until we find a contiguous * bunch of npages+2 unused pages. */ pos = minefield_curpos; lim = minefield_npages; while (1) { /* Skip over used pages. */ while (pos < lim && minefield_admin[pos] != 0xFFFF) pos++; /* Count unused pages. */ start = pos; while (pos < lim && pos - start < npages + 2 && minefield_admin[pos] == 0xFFFF) pos++; if (pos - start == npages + 2) break; /* If we've reached the limit, reset the limit or stop. */ if (pos >= lim) { if (lim == minefield_npages) { /* go round and start again at zero */ lim = minefield_curpos; pos = 0; } else { minefield_admin_hide(1); return NULL; } } } minefield_curpos = pos - 1; /* * We have npages+2 unused pages starting at start. We leave * the first and last of these alone and use the rest. */ region_end = (start + npages + 1) * PAGESIZE; region_start = region_end - size; /* FIXME: could align here if we wanted */ /* * Update the admin region. */ for (i = start + 2; i < start + npages + 1; i++) minefield_admin[i] = 0xFFFE; /* used but no region starts here */ minefield_admin[start + 1] = region_start % PAGESIZE; minefield_admin_hide(1); VirtualAlloc((char *) minefield_pages + region_start, size, MEM_COMMIT, PAGE_READWRITE); return (char *) minefield_pages + region_start; }

Here is the call graph for this function:

void minefield_bomb (  void   )  [static]

Definition at line 112 of file mud-memory.c. References minefield_pages. Referenced by minefield_free(), and minefield_get_size(). { div(1, *(int *) minefield_pages); }

void minefield_c_free (  void *  p  )  [static]

Definition at line 227 of file mud-memory.c. References minefield_free(), and minefield_init(). Referenced by safefree(). { if (!minefield_initialised) minefield_init(); minefield_free(p); }

Here is the call graph for this function:

void* minefield_c_malloc (  size_t  size  )  [static]

Definition at line 220 of file mud-memory.c. References minefield_alloc(), and minefield_init(). Referenced by safemalloc(), and saferealloc(). { if (!minefield_initialised) minefield_init(); return minefield_alloc(size); }

Here is the call graph for this function:

void* minefield_c_realloc (  void *  p, size_t  size )  [static]

Definition at line 238 of file mud-memory.c. References minefield_alloc(), minefield_free(), minefield_get_size(), and minefield_init(). Referenced by saferealloc(). { size_t oldsize; void *q; if (!minefield_initialised) minefield_init(); q = minefield_alloc(size); oldsize = minefield_get_size(p); memcpy(q, p, (oldsize < size ? oldsize : size)); minefield_free(p); return q; }

Here is the call graph for this function:

void minefield_free (  void *  ptr  )  [static]

Definition at line 182 of file mud-memory.c. References minefield_admin, minefield_admin_hide(), minefield_bomb(), minefield_npages, and PAGESIZE. Referenced by minefield_c_free(), and minefield_c_realloc(). { int region_start, i, j; minefield_admin_hide(0); region_start = (char *) ptr - (char *) minefield_pages; i = region_start / PAGESIZE; if (i < 0 || i >= minefield_npages || minefield_admin[i] != region_start % PAGESIZE) minefield_bomb(); for (j = i; j < minefield_npages && minefield_admin[j] != 0xFFFF; j++) { minefield_admin[j] = 0xFFFF; } VirtualFree(ptr, j * PAGESIZE - region_start, MEM_DECOMMIT); minefield_admin_hide(1); }

Here is the call graph for this function:

int minefield_get_size (  void *  ptr  )  [static]

Definition at line 202 of file mud-memory.c. References minefield_admin, minefield_admin_hide(), minefield_bomb(), minefield_npages, and PAGESIZE. Referenced by minefield_c_realloc(). { int region_start, i, j; minefield_admin_hide(0); region_start = (char *) ptr - (char *) minefield_pages; i = region_start / PAGESIZE; if (i < 0 || i >= minefield_npages || minefield_admin[i] != region_start % PAGESIZE) minefield_bomb(); for (j = i; j < minefield_npages && minefield_admin[j] != 0xFFFF; j++); minefield_admin_hide(1); return j * PAGESIZE - region_start; }

Here is the call graph for this function:

void minefield_init (  void   )  [static]

Definition at line 68 of file mud-memory.c. References minefield_admin, minefield_admin_hide(), minefield_initialised, minefield_npages, minefield_pages, minefield_region, minefield_size, and PAGESIZE. Referenced by minefield_c_free(), minefield_c_malloc(), and minefield_c_realloc(). { int size; int admin_size; int i; for (size = 0x40000000; size > 0; size = ((size >> 3) * 7) & ~0xFFF) { minefield_region = VirtualAlloc(NULL, size, MEM_RESERVE, PAGE_NOACCESS); if (minefield_region) break; } minefield_size = size; /* * Firstly, allocate a section of that to be the admin block. * We'll need a two-byte field for each page. */ minefield_admin = minefield_region; minefield_npages = minefield_size / PAGESIZE; admin_size = (minefield_npages * 2 + PAGESIZE - 1) & ~(PAGESIZE - 1); minefield_npages = (minefield_size - admin_size) / PAGESIZE; minefield_pages = (char *) minefield_region + admin_size; /* * Commit the admin region. */ VirtualAlloc(minefield_admin, minefield_npages * 2, MEM_COMMIT, PAGE_READWRITE); /* * Mark all pages as unused (0xFFFF). */ for (i = 0; i < minefield_npages; i++) minefield_admin[i] = 0xFFFF; /* * Hide the admin region. */ minefield_admin_hide(1); minefield_initialised = 1; }

Here is the call graph for this function:

void mlog (  char *  file, int  line )

Definition at line 259 of file mud-memory.c. References fp, mlog_file, and mlog_line. { mlog_file = file; mlog_line = line; if (!fp) { fp = fopen("Mud-client_mem.log", "w"); setvbuf(fp, NULL, _IONBF, BUFSIZ); } if (fp) fprintf(fp, "%s:%d: ", file, line); }

void safefree (  void *  ptr  )

Definition at line 338 of file mud-memory.c. References fp, free, and minefield_c_free(). { if (ptr) { #ifdef MALLOC_LOG if (fp) fprintf(fp, "free(%p)\n", ptr); #endif #ifdef MINEFIELD minefield_c_free(ptr); #else free(ptr); #endif } #ifdef MALLOC_LOG else if (fp) fprintf(fp, "freeing null pointer - no action taken\n"); #endif }

Here is the call graph for this function:

void* safemalloc (  size_t  size  )

Definition at line 272 of file mud-memory.c. References fp, malloc, minefield_c_malloc(), mlog_file, and mlog_line. { void *p; #ifdef MINEFIELD p = minefield_c_malloc(size); #else p = malloc(size); #endif if (!p) { char str[200]; #ifdef MALLOC_LOG sprintf(str, "Out of memory! (%s:%d, size=%d)", mlog_file, mlog_line, size); fprintf(fp, "*** %s\n", str); fclose(fp); #else strcpy(str, "Out of memory!"); #endif MessageBox(NULL, str, "Mud-client Fatal Error", MB_SYSTEMMODAL | MB_ICONERROR | MB_OK); } #ifdef MALLOC_LOG if (fp) fprintf(fp, "malloc(%d) returns %p\n", size, p); #endif return p; }

Here is the call graph for this function:

void* saferealloc (  void *  ptr, size_t  size )

Definition at line 301 of file mud-memory.c. References fp, malloc, minefield_c_malloc(), minefield_c_realloc(), mlog_file, mlog_line, and realloc. { void *p; if (!ptr) { #ifdef MINEFIELD p = minefield_c_malloc(size); #else p = malloc(size); #endif } else { #ifdef MINEFIELD p = minefield_c_realloc(ptr, size); #else p = realloc(ptr, size); #endif } if (!p) { char str[200]; #ifdef MALLOC_LOG sprintf(str, "Out of memory! (%s:%d, size=%d)", mlog_file, mlog_line, size); fprintf(fp, "*** %s\n", str); fclose(fp); #else strcpy(str, "Out of memory!"); #endif MessageBox(NULL, str, "Mud-client Fatal Error", MB_SYSTEMMODAL | MB_ICONERROR | MB_OK); } #ifdef MALLOC_LOG if (fp) fprintf(fp, "realloc(%p,%d) returns %p\n", ptr, size, p); #endif return p; }

Here is the call graph for this function:

---

Variable Documentation

FILE* debug_fp = NULL [static]

Definition at line 362 of file mud-memory.c. Referenced by dputs().

int debug_got_console = 0 [static]

Definition at line 363 of file mud-memory.c. Referenced by dputs().

FILE* fp = NULL [static]

Definition at line 254 of file mud-memory.c. Referenced by mlog(), safefree(), safemalloc(), and saferealloc().

unsigned short* minefield_admin = NULL [static]

Definition at line 59 of file mud-memory.c. Referenced by minefield_admin_hide(), minefield_alloc(), minefield_free(), minefield_get_size(), and minefield_init().

long minefield_curpos = 0 [static]

Definition at line 58 of file mud-memory.c. Referenced by minefield_alloc().

int minefield_initialised = 0 [static]

Definition at line 54 of file mud-memory.c. Referenced by minefield_init().

long minefield_npages = 0 [static]

Definition at line 57 of file mud-memory.c. Referenced by minefield_admin_hide(), minefield_free(), minefield_get_size(), and minefield_init().

void* minefield_pages = NULL [static]

Definition at line 60 of file mud-memory.c. Referenced by minefield_alloc(), minefield_bomb(), and minefield_init().

void* minefield_region = NULL [static]

Definition at line 55 of file mud-memory.c. Referenced by minefield_init().

long minefield_size = 0 [static]

Definition at line 56 of file mud-memory.c. Referenced by minefield_init().

char* mlog_file = NULL [static]

Definition at line 256 of file mud-memory.c. Referenced by mlog(), safemalloc(), and saferealloc().

int mlog_line = 0 [static]

Definition at line 257 of file mud-memory.c. Referenced by mlog(), safemalloc(), and saferealloc().

---