1/* $NetBSD: umem.c,v 1.1 2009/08/07 20:57:56 haad Exp $ */ 2 3/* 4 * CDDL HEADER START 5 * 6 * The contents of this file are subject to the terms of the 7 * Common Development and Distribution License (the "License"). 8 * You may not use this file except in compliance with the License. 9 * 10 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 11 * or http://www.opensolaris.org/os/licensing. 12 * See the License for the specific language governing permissions 13 * and limitations under the License. 14 * 15 * When distributing Covered Code, include this CDDL HEADER in each 16 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 17 * If applicable, add the following below this CDDL HEADER, with the 18 * fields enclosed by brackets "[]" replaced with your own identifying 19 * information: Portions Copyright [yyyy] [name of copyright owner] 20 * 21 * CDDL HEADER END 22 */ 23/* 24 * Copyright 2006 Ricardo Correia. All rights reserved. 25 * Use is subject to license terms. 26 */ 27 28#include <umem.h> 29#include <stdlib.h> 30#include <assert.h> 31 32static umem_nofail_callback_t *nofail_cb = NULL; 33 34struct umem_cache { 35 umem_constructor_t *constructor; 36 umem_destructor_t *destructor; 37 void *callback_data; 38 size_t bufsize; 39}; 40 41/* 42 * Simple stub for umem_alloc(). The callback isn't expected to return. 43 */ 44void *umem_alloc(size_t size, int flags) 45{ 46 assert(flags == UMEM_DEFAULT || flags == UMEM_NOFAIL); 47 48 if(size == 0) 49 return NULL; 50 51 void *ret = malloc(size); 52 if(ret == NULL) { 53 if(!(flags & UMEM_NOFAIL)) 54 return NULL; 55 56 if(nofail_cb != NULL) 57 nofail_cb(); 58 abort(); 59 } 60 61 return ret; 62} 63 64/* 65 * Simple stub for umem_zalloc(). 66 */ 67void *umem_zalloc(size_t size, int flags) 68{ 69 assert(flags == UMEM_DEFAULT || flags == UMEM_NOFAIL); 70 71 if(size == 0) 72 return NULL; 73 74 void *ret = calloc(1, size); 75 if(ret == NULL) { 76 if(!(flags & UMEM_NOFAIL)) 77 return NULL; 78 79 if(nofail_cb != NULL) 80 nofail_cb(); 81 abort(); 82 } 83 84 return ret; 85} 86 87/* 88 * Simple stub for umem_free(). 89 */ 90void umem_free(void *buf, size_t size) 91{ 92 free(buf); 93} 94 95/* 96 * Simple stub for umem_nofail_callback(). 97 */ 98void umem_nofail_callback(umem_nofail_callback_t *callback) 99{ 100 nofail_cb = callback; 101} 102 103/* 104 * Simple stub for umem_cache_create(). 105 */ 106umem_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) 107{ 108 assert(source == NULL); 109 110 umem_cache_t *cache = malloc(sizeof(umem_cache_t)); 111 if(cache == NULL) 112 return NULL; 113 114 cache->constructor = constructor; 115 cache->destructor = destructor; 116 cache->callback_data = callback_data; 117 cache->bufsize = bufsize; 118 119 return cache; 120} 121 122/* 123 * Simple stub for umem_cache_alloc(). The nofail callback isn't expected to return. 124 */ 125void *umem_cache_alloc(umem_cache_t *cache, int flags) 126{ 127 void *buf = malloc(cache->bufsize); 128 if(buf == NULL) { 129 if(!(flags & UMEM_NOFAIL)) 130 return NULL; 131 132 if(nofail_cb != NULL) 133 nofail_cb(); 134 abort(); 135 } 136 137 if(cache->constructor != NULL) { 138 /* XXX NetBSD pool cache costructor has switched arguments. */ 139 if(cache->constructor(cache->callback_data, buf, flags) != 0) { 140 free(buf); 141 if(!(flags & UMEM_NOFAIL)) 142 return NULL; 143 144 if(nofail_cb != NULL) 145 nofail_cb(); 146 abort(); 147 } 148 } 149 150 return buf; 151} 152 153/* 154 * Simple stub for umem_cache_free(). 155 */ 156void umem_cache_free(umem_cache_t *cache, void *buffer) 157{ 158 if(cache->destructor != NULL) 159 /* XXX NetBSD pool cache costructor has switched arguments. */ 160 cache->destructor(cache->callback_data, buffer); 161 162 free(buffer); 163} 164 165/* 166 * Simple stub for umem_cache_destroy(). 167 */ 168void umem_cache_destroy(umem_cache_t *cache) 169{ 170 free(cache); 171} 172