]> git.sur5r.net Git - openldap/blob - servers/slapd/sl_malloc.c
Don't do pointer arithmetic on void pointers.
[openldap] / servers / slapd / sl_malloc.c
1 /* sl_malloc.c - malloc routines using a per-thread slab */
2 /* $OpenLDAP$ */
3 /*
4  * Copyright 2003 The OpenLDAP Foundation, All Rights Reserved.
5  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
6  */
7
8 #include "portable.h"
9
10 #include <stdio.h>
11 #include <ac/string.h>
12
13 #include "slap.h"
14
15 struct slab_heap {
16         void *h_base;
17         void *h_last;
18         void *h_end;
19 };
20
21 void
22 sl_mem_destroy(
23         void *key,
24         void *data
25 )
26 {
27         struct slab_heap *sh = data;
28
29         ber_memfree_x(sh->h_base, NULL);
30         ber_memfree_x(sh, NULL);
31 }
32
33 BER_MEMALLOC_FN sl_malloc;
34 BER_MEMCALLOC_FN sl_calloc;
35 BER_MEMREALLOC_FN sl_realloc;
36 BER_MEMFREE_FN sl_free;
37
38
39 BerMemoryFunctions sl_mfuncs =
40         { sl_malloc, sl_calloc, sl_realloc, sl_free };
41
42 void
43 sl_mem_init()
44 {
45         ber_set_option( NULL, LBER_OPT_MEMORY_FNS, &sl_mfuncs );
46 }
47
48 void *
49 sl_mem_create(
50         ber_len_t size,
51         void *ctx
52 )
53 {
54         struct slab_heap *sh = NULL;
55         int pad = 2*sizeof(int)-1;
56
57         ldap_pvt_thread_pool_getkey( ctx, sl_mem_init, (void **)&sh, NULL );
58
59         /* round up to doubleword boundary */
60         size += pad;
61         size &= ~pad;
62
63         if (!sh) {
64                 sh = ch_malloc( sizeof(struct slab_heap) );
65                 sh->h_base = ch_malloc( size );
66                 ldap_pvt_thread_pool_setkey( ctx, sl_mem_init, (void *)sh, sl_mem_destroy );
67         } else if ( size > (char *) sh->h_end - (char *) sh->h_base ) {
68                 sh->h_base = ch_realloc( sh->h_base, size );
69         }
70         sh->h_last = sh->h_base;
71         sh->h_end = (char *) sh->h_base + size;
72         return sh;
73 }
74
75 void
76 sl_mem_detach(
77         void *ctx,
78         void *memctx
79 )
80 {
81         struct slab_heap *sh = memctx;
82         int size = (char *) sh->h_end - (char *) sh->h_base;
83
84         sh->h_base = ch_realloc( sh->h_base, size );
85
86         ldap_pvt_thread_pool_setkey( ctx, sl_mem_init, NULL, NULL );
87 }
88
89 void *
90 sl_malloc(
91     ber_len_t   size,
92     void *ctx
93 )
94 {
95         struct slab_heap *sh = ctx;
96         int pad = 2*sizeof(int)-1;
97         ber_len_t *new;
98
99         /* ber_set_option calls us like this */
100         if (!ctx) return ber_memalloc_x( size, NULL );
101
102         /* round up to doubleword boundary */
103         size += pad + sizeof( ber_len_t );
104         size &= ~pad;
105
106         if ((char *) sh->h_last + size >= (char *) sh->h_end ) {
107 #ifdef NEW_LOGGING
108                 LDAP_LOG( OPERATION, INFO, 
109                            "sl_malloc of %lu bytes failed, using ch_malloc\n", (long)size, 0,0 );
110 #else
111                 Debug( LDAP_DEBUG_TRACE,
112                            "sl_malloc of %lu bytes failed, using ch_malloc\n", (long)size, 0,0 );
113 #endif
114                 return ch_malloc( size );
115         }
116         new = sh->h_last;
117         *new++ = size - sizeof(ber_len_t);
118         sh->h_last = (char *) sh->h_last + size;
119         
120         return( (void *)new );
121 }
122
123 void *
124 sl_calloc( ber_len_t n, ber_len_t size, void *ctx )
125 {
126         void *new;
127
128         new = sl_malloc( n*size, ctx );
129         if ( new ) {
130                 memset( new, 0, n*size );
131         }
132         return new;
133 }
134
135 void *
136 sl_realloc( void *ptr, ber_len_t size, void *ctx )
137 {
138         struct slab_heap *sh = ctx;
139         int pad = 2*sizeof(int)-1;
140         ber_len_t *p = (ber_len_t *)ptr;
141         ber_len_t *new;
142
143         if ( ptr == NULL ) return sl_malloc( size, ctx );
144
145         /* Not our memory? */
146         if ( !sh || ptr < sh->h_base || ptr >= sh->h_end ) {
147                 /* duplicate of ch_realloc behavior, oh well */
148                 new = ber_memrealloc_x( ptr, size, NULL );
149                 if (new ) {
150                         return new;
151                 }
152 #ifdef NEW_LOGGING
153                 LDAP_LOG( OPERATION, ERR, 
154                            "ch_realloc: reallocation of %lu bytes failed\n", (long)size, 0,0 );
155 #else
156                 Debug( LDAP_DEBUG_ANY, "ch_realloc of %lu bytes failed\n",
157                         (long) size, 0, 0 );
158 #endif
159                 assert( 0 );
160                 exit( EXIT_FAILURE );
161         }
162
163         if ( size == 0 ) {
164                 sl_free( ptr, ctx );
165                 return NULL;
166         }
167
168         /* round up to doubleword boundary */
169         size += pad + sizeof( ber_len_t );
170         size &= ~pad;
171
172         /* Never shrink blocks */
173         if (size <= p[-1]) {
174                 new = p;
175         
176         /* If reallocing the last block, we can grow it */
177         } else if ( (char *)ptr + p[-1] == sh->h_last ) {
178                 new = p;
179                 sh->h_last = (char *) sh->h_last + size - p[-1];
180                 p[-1] = size;
181         
182         /* Nowhere to grow, need to alloc and copy */
183         } else {
184                 new = sl_malloc( size, ctx );
185                 AC_MEMCPY( new, ptr, p[-1] );
186         }
187         return new;
188 }
189
190 void
191 sl_free( void *ptr, void *ctx )
192 {
193         struct slab_heap *sh = ctx;
194         ber_len_t *p = (ber_len_t *)ptr;
195
196         if ( !sh || ptr < sh->h_base || ptr >= sh->h_end ) {
197                 ber_memfree_x( ptr, NULL );
198         } else if ( (char *)ptr + p[-1] == sh->h_last ) {
199                 p--;
200                 sh->h_last = p;
201         }
202 }
203
204 void
205 sl_release( void *ptr, void *ctx )
206 {
207         struct slab_heap *sh = ctx;
208
209         if ( sh && ptr >= sh->h_base && ptr <= sh->h_end ) {
210                 sh->h_last = ptr;
211         }
212 }
213
214 void *
215 sl_mark( void *ctx )
216 {
217         struct slab_heap *sh = ctx;
218         void *ret = NULL;
219
220         if (sh) ret = sh->h_last;
221
222         return ret;
223 }
224
225 void *
226 sl_context( void *ptr )
227 {
228         struct slab_heap *sh = NULL;
229         void *ctx;
230
231         ctx = ldap_pvt_thread_pool_context();
232
233         ldap_pvt_thread_pool_getkey( ctx, sl_mem_init, (void **)&sh, NULL );
234
235         if ( sh && ptr >= sh->h_base && ptr <= sh->h_end ) {
236                 return sh;
237         }
238         return NULL;
239 }