duk_alloc_torture.c File Reference

#include "duktape.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>

Go to the source code of this file.

Data Structures
struct	alloc_hdr

Macros
#define	RED_ZONE_SIZE   16
#define	RED_ZONE_BYTE   0x5a
#define	INIT_BYTE   0xa5
#define	WIPE_BYTE   0x27

Functions
static void	check_red_zone (alloc_hdr *hdr)
void *	duk_alloc_torture (void *udata, duk_size_t size)
void *	duk_realloc_torture (void *udata, void *ptr, duk_size_t size)
void	duk_free_torture (void *udata, void *ptr)

Macro Definition Documentation

INIT_BYTE

#define INIT_BYTE   0xa5

Definition at line 22 of file duktape-1.5.2/examples/alloc-torture/duk_alloc_torture.c.

Referenced by duk_alloc_torture(), and duk_realloc_torture().

RED_ZONE_BYTE

#define RED_ZONE_BYTE   0x5a

Definition at line 21 of file duktape-1.5.2/examples/alloc-torture/duk_alloc_torture.c.

Referenced by check_red_zone(), duk_alloc_torture(), and duk_realloc_torture().

RED_ZONE_SIZE

#define RED_ZONE_SIZE   16

Definition at line 20 of file duktape-1.5.2/examples/alloc-torture/duk_alloc_torture.c.

Referenced by check_red_zone(), duk_alloc_torture(), duk_free_torture(), and duk_realloc_torture().

WIPE_BYTE

#define WIPE_BYTE   0x27

Definition at line 23 of file duktape-1.5.2/examples/alloc-torture/duk_alloc_torture.c.

Referenced by duk_free_torture(), and duk_realloc_torture().

Function Documentation

check_red_zone()

static void check_red_zone ( alloc_hdr * hdr )

static

Definition at line 36 of file duktape-1.5.2/examples/alloc-torture/duk_alloc_torture.c.

                                           {
    size_t size;
    int i;
    int err;
    unsigned char *p;
    unsigned char *userptr;
 
    size = hdr->u.sz;
    userptr = (unsigned char *) hdr + sizeof(alloc_hdr) + RED_ZONE_SIZE;
 
    err = 0;
    p = (unsigned char *) hdr + sizeof(alloc_hdr);
    for (i = 0; i < RED_ZONE_SIZE; i++) {
        if (p[i] != RED_ZONE_BYTE) {
            err = 1;
        }
    }
    if (err) {
        fprintf(stderr, "RED ZONE CORRUPTED BEFORE ALLOC: hdr=%p ptr=%p size=%ld\n",
                (void *) hdr, (void *) userptr, (long) size);
        fflush(stderr);
    }
 
    err = 0;
    p = (unsigned char *) hdr + sizeof(alloc_hdr) + RED_ZONE_SIZE + size;
    for (i = 0; i < RED_ZONE_SIZE; i++) {
        if (p[i] != RED_ZONE_BYTE) {
            err = 1;
        }
    }
    if (err) {
        fprintf(stderr, "RED ZONE CORRUPTED AFTER ALLOC: hdr=%p ptr=%p size=%ld\n",
                (void *) hdr, (void *) userptr, (long) size);
        fflush(stderr);
    }
}

References RED_ZONE_BYTE, RED_ZONE_SIZE, alloc_hdr::sz, and alloc_hdr::u.

Referenced by duk_free_torture(), and duk_realloc_torture().

duk_alloc_torture()

void * duk_alloc_torture	(	void *	udata,
		duk_size_t	size )

Definition at line 73 of file duktape-1.5.2/examples/alloc-torture/duk_alloc_torture.c.

                                                      {
    unsigned char *p;
 
    (void) udata;  /* Suppress warning. */
 
    if (size == 0) {
        return NULL;
    }
 
    p = (unsigned char *) malloc(size + sizeof(alloc_hdr) + 2 * RED_ZONE_SIZE);
    if (!p) {
        return NULL;
    }
 
    ((alloc_hdr *) (void *) p)->u.sz = size;
    p += sizeof(alloc_hdr);
    memset((void *) p, RED_ZONE_BYTE, RED_ZONE_SIZE);
    p += RED_ZONE_SIZE;
    memset((void *) p, INIT_BYTE, size);
    p += size;
    memset((void *) p, RED_ZONE_BYTE, RED_ZONE_SIZE);
    p -= size;
    return (void *) p;
}

References INIT_BYTE, malloc, NULL, RED_ZONE_BYTE, and RED_ZONE_SIZE.

Referenced by create_duktape_heap(), and create_duktape_heap().

duk_free_torture()

void duk_free_torture	(	void *	udata,
		void *	ptr )

Definition at line 166 of file duktape-1.5.2/examples/alloc-torture/duk_alloc_torture.c.

                                              {
    unsigned char *p;
    size_t old_size;
 
    (void) udata;  /* Suppress warning. */
 
    if (!ptr) {
        return;
    }
 
    p = (unsigned char *) ptr - sizeof(alloc_hdr) - RED_ZONE_SIZE;
    old_size = ((alloc_hdr *) (void *) p)->u.sz;
 
    check_red_zone((alloc_hdr *) (void *) p);
    memset((void *) p, WIPE_BYTE, old_size + sizeof(alloc_hdr) + 2 * RED_ZONE_SIZE);
    free((void *) p);
}

References check_red_zone(), free, RED_ZONE_SIZE, and WIPE_BYTE.

Referenced by create_duktape_heap(), and create_duktape_heap().

duk_realloc_torture()

void * duk_realloc_torture	(	void *	udata,
		void *	ptr,
		duk_size_t	size )

Definition at line 98 of file duktape-1.5.2/examples/alloc-torture/duk_alloc_torture.c.

                                                                   {
    unsigned char *p, *old_p;
    size_t old_size;
 
    (void) udata;  /* Suppress warning. */
 
    /* Handle the ptr-NULL vs. size-zero cases explicitly to minimize
     * platform assumptions.  You can get away with much less in specific
     * well-behaving environments.
     */
 
    if (ptr) {
        old_p = (unsigned char *) ptr - sizeof(alloc_hdr) - RED_ZONE_SIZE;
        old_size = ((alloc_hdr *) (void *) old_p)->u.sz;
        check_red_zone((alloc_hdr *) (void *) old_p);
 
        if (size == 0) {
            memset((void *) old_p, WIPE_BYTE, old_size + sizeof(alloc_hdr) + 2 * RED_ZONE_SIZE);
            free((void *) old_p);
            return NULL;
        } else {
            /* Force address change on every realloc. */
            p = (unsigned char *) malloc(size + sizeof(alloc_hdr) + 2 * RED_ZONE_SIZE);
            if (!p) {
                return NULL;
            }
 
            ((alloc_hdr *) (void *) p)->u.sz = size;
            p += sizeof(alloc_hdr);
            memset((void *) p, RED_ZONE_BYTE, RED_ZONE_SIZE);
            p += RED_ZONE_SIZE;
            if (size > old_size) {
                memcpy((void *) p, (void *) (old_p + sizeof(alloc_hdr) + RED_ZONE_SIZE), old_size);
                memset((void *) (p + old_size), INIT_BYTE, size - old_size);
            } else {
                memcpy((void *) p, (void *) (old_p + sizeof(alloc_hdr) + RED_ZONE_SIZE), size);
            }
            p += size;
            memset((void *) p, RED_ZONE_BYTE, RED_ZONE_SIZE);
            p -= size;
 
            memset((void *) old_p, WIPE_BYTE, old_size + sizeof(alloc_hdr) + 2 * RED_ZONE_SIZE);
            free((void *) old_p);
 
            return (void *) p;
        }
    } else {
        if (size == 0) {
            return NULL;
        } else {
            p = (unsigned char *) malloc(size + sizeof(alloc_hdr) + 2 * RED_ZONE_SIZE);
            if (!p) {
                return NULL;
            }
 
            ((alloc_hdr *) (void *) p)->u.sz = size;
            p += sizeof(alloc_hdr);
            memset((void *) p, RED_ZONE_BYTE, RED_ZONE_SIZE);
            p += RED_ZONE_SIZE;
            memset((void *) p, INIT_BYTE, size);
            p += size;
            memset((void *) p, RED_ZONE_BYTE, RED_ZONE_SIZE);
            p -= size;
            return (void *) p;
        }
    }
}

References check_red_zone(), free, INIT_BYTE, malloc, NULL, RED_ZONE_BYTE, RED_ZONE_SIZE, and WIPE_BYTE.

Referenced by create_duktape_heap(), and create_duktape_heap().