diff options
Diffstat (limited to 'cddl/compat/opensolaris/lib')
| -rw-r--r-- | cddl/compat/opensolaris/lib/libumem/umem.c | 167 | ||||
| -rw-r--r-- | cddl/compat/opensolaris/lib/libumem/umem.h | 85 |
2 files changed, 252 insertions, 0 deletions
diff --git a/cddl/compat/opensolaris/lib/libumem/umem.c b/cddl/compat/opensolaris/lib/libumem/umem.c new file mode 100644 index 000000000000..e9662ce3c1e8 --- /dev/null +++ b/cddl/compat/opensolaris/lib/libumem/umem.c @@ -0,0 +1,167 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License (the "License"). + * You may not use this file except in compliance with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2006 Ricardo Correia. All rights reserved. + * Use is subject to license terms. + */ + +#include <umem.h> +#include <stdlib.h> +#include <assert.h> + +static umem_nofail_callback_t *nofail_cb = NULL; + +struct umem_cache { + umem_constructor_t *constructor; + umem_destructor_t *destructor; + void *callback_data; + size_t bufsize; +}; + +/* + * Simple stub for umem_alloc(). The callback isn't expected to return. + */ +void *umem_alloc(size_t size, int flags) +{ + assert(flags == UMEM_DEFAULT || flags == UMEM_NOFAIL); + + if(size == 0) + return NULL; + + void *ret = malloc(size); + if(ret == NULL) { + if(!(flags & UMEM_NOFAIL)) + return NULL; + + if(nofail_cb != NULL) + nofail_cb(); + abort(); + } + + return ret; +} + +/* + * Simple stub for umem_zalloc(). + */ +void *umem_zalloc(size_t size, int flags) +{ + assert(flags == UMEM_DEFAULT || flags == UMEM_NOFAIL); + + if(size == 0) + return NULL; + + void *ret = calloc(1, size); + if(ret == NULL) { + if(!(flags & UMEM_NOFAIL)) + return NULL; + + if(nofail_cb != NULL) + nofail_cb(); + abort(); + } + + return ret; +} + +/* + * Simple stub for umem_free(). + */ +void umem_free(void *buf, size_t size) +{ + free(buf); +} + +/* + * Simple stub for umem_nofail_callback(). + */ +void umem_nofail_callback(umem_nofail_callback_t *callback) +{ + nofail_cb = callback; +} + +/* + * Simple stub for umem_cache_create(). + */ +umem_cache_t *umem_cache_create(char *debug_name, size_t bufsize, size_t align, umem_constructor_t *constructor, umem_destructor_t *destructor, umem_reclaim_t *reclaim, void *callback_data, void *source, int cflags) +{ + assert(source == NULL); + + umem_cache_t *cache = malloc(sizeof(umem_cache_t)); + if(cache == NULL) + return NULL; + + cache->constructor = constructor; + cache->destructor = destructor; + cache->callback_data = callback_data; + cache->bufsize = bufsize; + + return cache; +} + +/* + * Simple stub for umem_cache_alloc(). The nofail callback isn't expected to return. + */ +void *umem_cache_alloc(umem_cache_t *cache, int flags) +{ + void *buf = malloc(cache->bufsize); + if(buf == NULL) { + if(!(flags & UMEM_NOFAIL)) + return NULL; + + if(nofail_cb != NULL) + nofail_cb(); + abort(); + } + + if(cache->constructor != NULL) { + if(cache->constructor(buf, cache->callback_data, flags) != 0) { + free(buf); + if(!(flags & UMEM_NOFAIL)) + return NULL; + + if(nofail_cb != NULL) + nofail_cb(); + abort(); + } + } + + return buf; +} + +/* + * Simple stub for umem_cache_free(). + */ +void umem_cache_free(umem_cache_t *cache, void *buffer) +{ + if(cache->destructor != NULL) + cache->destructor(buffer, cache->callback_data); + + free(buffer); +} + +/* + * Simple stub for umem_cache_destroy(). + */ +void umem_cache_destroy(umem_cache_t *cache) +{ + free(cache); +} diff --git a/cddl/compat/opensolaris/lib/libumem/umem.h b/cddl/compat/opensolaris/lib/libumem/umem.h new file mode 100644 index 000000000000..971cde36e1b2 --- /dev/null +++ b/cddl/compat/opensolaris/lib/libumem/umem.h @@ -0,0 +1,85 @@ +/* + * CDDL HEADER START + * + * The contents of this file are subject to the terms of the + * Common Development and Distribution License, Version 1.0 only + * (the "License"). You may not use this file except in compliance + * with the License. + * + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE + * or http://www.opensolaris.org/os/licensing. + * See the License for the specific language governing permissions + * and limitations under the License. + * + * When distributing Covered Code, include this CDDL HEADER in each + * file and include the License file at usr/src/OPENSOLARIS.LICENSE. + * If applicable, add the following below this CDDL HEADER, with the + * fields enclosed by brackets "[]" replaced with your own identifying + * information: Portions Copyright [yyyy] [name of copyright owner] + * + * CDDL HEADER END + */ +/* + * Copyright 2004 Sun Microsystems, Inc. All rights reserved. + * Use is subject to license terms. + */ + +#ifndef _UMEM_H +#define _UMEM_H + + + +#include <sys/types.h> +#include <stdlib.h> + +#ifdef __cplusplus +extern "C" { +#endif + +#define UMEM_DEFAULT 0x0000 /* normal -- may fail */ +#define UMEM_NOFAIL 0x0100 /* Never fails -- may call exit(2) */ + +#define UMEM_FLAGS 0xffff /* all settable umem flags */ + +extern void *umem_alloc(size_t, int); +extern void *umem_alloc_align(size_t, size_t, int); +extern void *umem_zalloc(size_t, int); +extern void umem_free(void *, size_t); +extern void umem_free_align(void *, size_t); + +/* + * Flags for umem_cache_create() + */ +#define UMC_NOTOUCH 0x00010000 +#define UMC_NODEBUG 0x00020000 +#define UMC_NOMAGAZINE 0x00040000 +#define UMC_NOHASH 0x00080000 + +struct umem_cache; /* cache structure is opaque to umem clients */ + +typedef struct umem_cache umem_cache_t; +typedef int umem_constructor_t(void *, void *, int); +typedef void umem_destructor_t(void *, void *); +typedef void umem_reclaim_t(void *); + +typedef int umem_nofail_callback_t(void); +#define UMEM_CALLBACK_RETRY 0 +#define UMEM_CALLBACK_EXIT(status) (0x100 | ((status) & 0xFF)) + +extern void umem_nofail_callback(umem_nofail_callback_t *); + +extern umem_cache_t *umem_cache_create(char *, size_t, + size_t, umem_constructor_t *, umem_destructor_t *, umem_reclaim_t *, + void *, void *, int); +extern void umem_cache_destroy(umem_cache_t *); + +extern void *umem_cache_alloc(umem_cache_t *, int); +extern void umem_cache_free(umem_cache_t *, void *); + +extern void umem_reap(void); + +#ifdef __cplusplus +} +#endif + +#endif /* _UMEM_H */ |