You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
327 lines
7.0 KiB
327 lines
7.0 KiB
/*-
|
|
* See the file LICENSE for redistribution information.
|
|
*
|
|
* Copyright (c) 1997, 1998, 1999
|
|
* Sleepycat Software. All rights reserved.
|
|
*/
|
|
|
|
#include "db_config.h"
|
|
|
|
#ifndef lint
|
|
static const char sccsid[] = "@(#)os_alloc.c 11.6 (Sleepycat) 11/9/99";
|
|
#endif /* not lint */
|
|
|
|
#ifndef NO_SYSTEM_INCLUDES
|
|
#include <sys/types.h>
|
|
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#include <stdlib.h>
|
|
#endif
|
|
|
|
#include "db_int.h"
|
|
#include "os_jump.h"
|
|
|
|
#ifdef DIAGNOSTIC
|
|
static void __os_guard __P((void));
|
|
#endif
|
|
|
|
/*
|
|
* !!!
|
|
* Correct for systems that return NULL when you allocate 0 bytes of memory.
|
|
* There are several places in DB where we allocate the number of bytes held
|
|
* by the key/data item, and it can be 0. Correct here so that malloc never
|
|
* returns a NULL for that reason (which behavior is permitted by ANSI). We
|
|
* could make these calls macros on non-Alpha architectures (that's where we
|
|
* saw the problem), but it's probably not worth the autoconf complexity.
|
|
*
|
|
* !!!
|
|
* Correct for systems that don't set errno when malloc and friends fail.
|
|
*
|
|
* Out of memory.
|
|
* We wish to hold the whole sky,
|
|
* But we never will.
|
|
*/
|
|
|
|
/*
|
|
* CDB___os_strdup --
|
|
* The strdup(3) function for DB.
|
|
*
|
|
* PUBLIC: int CDB___os_strdup __P((const char *, void *));
|
|
*/
|
|
int
|
|
CDB___os_strdup(str, storep)
|
|
const char *str;
|
|
void *storep;
|
|
{
|
|
size_t size;
|
|
int ret;
|
|
void *p;
|
|
|
|
*(void **)storep = NULL;
|
|
|
|
size = strlen(str) + 1;
|
|
if ((ret = CDB___os_malloc(size, NULL, &p)) != 0)
|
|
return (ret);
|
|
|
|
memcpy(p, str, size);
|
|
|
|
*(void **)storep = p;
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* CDB___os_calloc --
|
|
* The calloc(3) function for DB.
|
|
*
|
|
* PUBLIC: int CDB___os_calloc __P((size_t, size_t, void *));
|
|
*/
|
|
int
|
|
CDB___os_calloc(num, size, storep)
|
|
size_t num, size;
|
|
void *storep;
|
|
{
|
|
void *p;
|
|
int ret;
|
|
|
|
size *= num;
|
|
if ((ret = CDB___os_malloc(size, NULL, &p)) != 0)
|
|
return (ret);
|
|
|
|
memset(p, 0, size);
|
|
|
|
*(void **)storep = p;
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* CDB___os_malloc --
|
|
* The malloc(3) function for DB.
|
|
*
|
|
* PUBLIC: int CDB___os_malloc __P((size_t, void *(*)(size_t), void *));
|
|
*/
|
|
int
|
|
CDB___os_malloc(size, db_malloc, storep)
|
|
size_t size;
|
|
void *(*db_malloc) __P((size_t)), *storep;
|
|
{
|
|
void *p;
|
|
|
|
*(void **)storep = NULL;
|
|
|
|
/* Never allocate 0 bytes -- some C libraries don't like it. */
|
|
if (size == 0)
|
|
++size;
|
|
#ifdef DIAGNOSTIC
|
|
else
|
|
++size; /* Add room for a guard byte. */
|
|
#endif
|
|
|
|
/* Some C libraries don't correctly set errno when malloc(3) fails. */
|
|
CDB___os_set_errno(0);
|
|
if (db_malloc != NULL)
|
|
p = db_malloc(size);
|
|
else if (CDB___db_jump.j_malloc != NULL)
|
|
p = CDB___db_jump.j_malloc(size);
|
|
else
|
|
p = malloc(size);
|
|
if (p == NULL) {
|
|
if (CDB___os_get_errno() == 0)
|
|
CDB___os_set_errno(ENOMEM);
|
|
return (CDB___os_get_errno());
|
|
}
|
|
|
|
#ifdef DIAGNOSTIC
|
|
/*
|
|
* Guard bytes: if #DIAGNOSTIC is defined, we allocate an additional
|
|
* byte after the memory and set it to a special value that we check
|
|
* for when the memory is free'd. This is fine for structures, but
|
|
* not quite so fine for strings. There are places in DB where memory
|
|
* is allocated sufficient to hold the largest possible string that
|
|
* we'll see, and then only some subset of the memory is used. To
|
|
* support this usage, the CDB___os_freestr() function checks the byte
|
|
* after the string's nul, which may or may not be the last byte in
|
|
* the originally allocated memory.
|
|
*/
|
|
memset(p, CLEAR_BYTE, size); /* Initialize guard byte. */
|
|
#endif
|
|
*(void **)storep = p;
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* CDB___os_realloc --
|
|
* The realloc(3) function for DB.
|
|
*
|
|
* PUBLIC: int CDB___os_realloc __P((size_t, void *(*)(void *, size_t), void *));
|
|
*/
|
|
int
|
|
CDB___os_realloc(size, db_realloc, storep)
|
|
size_t size;
|
|
void *(*db_realloc) __P((void *, size_t)), *storep;
|
|
{
|
|
void *p, *ptr;
|
|
|
|
ptr = *(void **)storep;
|
|
|
|
/* If we haven't yet allocated anything yet, simply call malloc. */
|
|
if (ptr == NULL && db_realloc == NULL)
|
|
return (CDB___os_malloc(size, NULL, storep));
|
|
|
|
/* Never allocate 0 bytes -- some C libraries don't like it. */
|
|
if (size == 0)
|
|
++size;
|
|
#ifdef DIAGNOSTIC
|
|
else
|
|
++size; /* Add room for a guard byte. */
|
|
#endif
|
|
|
|
/*
|
|
* Some C libraries don't correctly set errno when realloc(3) fails.
|
|
*
|
|
* Don't overwrite the original pointer, there are places in DB we
|
|
* try to continue after realloc fails.
|
|
*/
|
|
CDB___os_set_errno(0);
|
|
if (db_realloc != NULL)
|
|
p = db_realloc(ptr, size);
|
|
if (CDB___db_jump.j_realloc != NULL)
|
|
p = CDB___db_jump.j_realloc(ptr, size);
|
|
else
|
|
p = realloc(ptr, size);
|
|
if (p == NULL) {
|
|
if (CDB___os_get_errno() == 0)
|
|
CDB___os_set_errno(ENOMEM);
|
|
return (CDB___os_get_errno());
|
|
}
|
|
|
|
#ifdef DIAGNOSTIC
|
|
((u_int8_t *)p)[size - 1] = CLEAR_BYTE; /* Initialize guard byte. */
|
|
#endif
|
|
|
|
*(void **)storep = p;
|
|
|
|
return (0);
|
|
}
|
|
|
|
/*
|
|
* CDB___os_free --
|
|
* The free(3) function for DB.
|
|
*
|
|
* PUBLIC: void CDB___os_free __P((void *, size_t));
|
|
*/
|
|
void
|
|
CDB___os_free(ptr, size)
|
|
void *ptr;
|
|
size_t size;
|
|
{
|
|
#ifdef DIAGNOSTIC
|
|
if (size != 0) {
|
|
/*
|
|
* Check that the guard byte (one past the end of the memory) is
|
|
* still CLEAR_BYTE.
|
|
*/
|
|
if (((u_int8_t *)ptr)[size] != CLEAR_BYTE)
|
|
__os_guard();
|
|
|
|
/* Clear memory. */
|
|
if (size != 0)
|
|
memset(ptr, CLEAR_BYTE, size);
|
|
}
|
|
#else
|
|
COMPQUIET(size, 0);
|
|
#endif
|
|
|
|
if (CDB___db_jump.j_free != NULL)
|
|
CDB___db_jump.j_free(ptr);
|
|
else
|
|
free(ptr);
|
|
}
|
|
|
|
/*
|
|
* CDB___os_freestr --
|
|
* The free(3) function for DB, freeing a string.
|
|
*
|
|
* PUBLIC: void CDB___os_freestr __P((void *));
|
|
*/
|
|
void
|
|
CDB___os_freestr(ptr)
|
|
void *ptr;
|
|
{
|
|
#ifdef DIAGNOSTIC
|
|
size_t size;
|
|
|
|
size = strlen(ptr) + 1;
|
|
|
|
/*
|
|
* Check that the guard byte (one past the end of the memory) is
|
|
* still CLEAR_BYTE.
|
|
*/
|
|
if (((u_int8_t *)ptr)[size] != CLEAR_BYTE)
|
|
__os_guard();
|
|
|
|
/* Clear memory. */
|
|
memset(ptr, CLEAR_BYTE, size);
|
|
#endif
|
|
|
|
if (CDB___db_jump.j_free != NULL)
|
|
CDB___db_jump.j_free(ptr);
|
|
else
|
|
free(ptr);
|
|
}
|
|
|
|
#ifdef DIAGNOSTIC
|
|
/*
|
|
* __os_guard --
|
|
* Complain and abort.
|
|
*/
|
|
static void
|
|
__os_guard()
|
|
{
|
|
/*
|
|
* Eventually, once we push a DB_ENV handle down to these
|
|
* routines, we should use the standard output channels.
|
|
*/
|
|
fprintf(stderr, "Guard byte incorrect during free.\n");
|
|
abort();
|
|
/* NOTREACHED */
|
|
}
|
|
#endif
|
|
|
|
/*
|
|
* __ua_copy --
|
|
* Copy memory to memory without relying on any kind of alignment.
|
|
*
|
|
* There are places in DB that we have unaligned data, for example,
|
|
* when we've stored a structure in a log record as a DBT, and now
|
|
* we want to look at it. Unfortunately, if you have code like:
|
|
*
|
|
* struct a {
|
|
* int x;
|
|
* } *p;
|
|
*
|
|
* void *func_argument;
|
|
* int local;
|
|
*
|
|
* p = (struct a *)func_argument;
|
|
* memcpy(&local, p->x, sizeof(local));
|
|
*
|
|
* some compilers optimize to use instructions that require alignment.
|
|
* It's a compiler bug, but it's a pretty common one.
|
|
*
|
|
* Casting the memcpy arguments to (u_int8_t *) appears to work most
|
|
* of the time, but we've seen examples where it wasn't sufficient
|
|
* and there's nothing in ANSI C that requires it.
|
|
*
|
|
* PUBLIC: void *CDB___ua_memcpy __P((void *, const void *, size_t));
|
|
*/
|
|
void *
|
|
CDB___ua_memcpy(dst, src, len)
|
|
void *dst;
|
|
const void *src;
|
|
size_t len;
|
|
{
|
|
return (memcpy(dst, src, len));
|
|
}
|