Menu
▾
▴
[Valgrind-developers] valgrind
|
From: Robert W. <rj...@du...> - 2004-06-19 18:12:52
|
CVS commit by rjwalsh:
Memory pool support.
A memcheck/tests/mempool.c 1.1 [no copyright]
A memcheck/tests/mempool.stderr.exp 1.1
A memcheck/tests/mempool.vgtest 1.1
M +5 -1 addrcheck/ac_main.c 1.62
M +17 -0 coregrind/docs/coregrind_core.html 1.29
M +37 -0 include/valgrind.h 1.26
M +138 -17 memcheck/mac_malloc_wrappers.c 1.11
M +70 -4 memcheck/mac_needs.c 1.27
M +31 -5 memcheck/mac_shared.h 1.18
M +36 -1 memcheck/mc_clientreqs.c 1.20
M +4 -2 memcheck/tests/Makefile.am 1.36
--- valgrind/addrcheck/ac_main.c #1.61:1.62
@@ -1186,5 +1186,9 @@ Bool SK_(handle_client_request) ( Thread
if (!VG_IS_SKIN_USERREQ('M','C',arg[0])
&& VG_USERREQ__MALLOCLIKE_BLOCK != arg[0]
- && VG_USERREQ__FREELIKE_BLOCK != arg[0])
+ && VG_USERREQ__FREELIKE_BLOCK != arg[0]
+ && VG_USERREQ__CREATE_MEMPOOL != arg[0]
+ && VG_USERREQ__DESTROY_MEMPOOL != arg[0]
+ && VG_USERREQ__MEMPOOL_ALLOC != arg[0]
+ && VG_USERREQ__MEMPOOL_FREE != arg[0])
return False;
--- valgrind/coregrind/docs/coregrind_core.html #1.28:1.29
@@ -985,4 +985,21 @@
<code>memcheck/memcheck.h</code> for information on how to use it.
<p>
+<li><code>VALGRIND_CREATE_MEMPOOL</code>: This is similar to
+ <code>VALGRIND_MALLOCLIKE_BLOCK</code>, but is tailored towards code
+ that uses memory pools. See the comments in <code>valgrind.h</code>
+ for information on how to use it.
+<p>
+<li><code>VALGRIND_DESTROY_MEMPOOL</code>: This should be used in
+ conjunction with <code>VALGRIND_CREATE_MEMPOOL</code> Again, see the
+ comments in <code>valgrind.h</code> for information on how to use it.
+<p>
+<li><code>VALGRIND_MEMPOOL_ALLOC</code>: This should be used in
+ conjunction with <code>VALGRIND_CREATE_MEMPOOL</code> Again, see the
+ comments in <code>valgrind.h</code> for information on how to use it.
+<p>
+<li><code>VALGRIND_MEMPOOL_FREE</code>: This should be used in
+ conjunction with <code>VALGRIND_CREATE_MEMPOOL</code> Again, see the
+ comments in <code>valgrind.h</code> for information on how to use it.
+<p>
<li><code>VALGRIND_NON_SIMD_CALL[0123]</code>: executes a function of 0, 1, 2
or 3 args in the client program on the <i>real</i> CPU, not the virtual
--- valgrind/include/valgrind.h #1.25:1.26
@@ -164,4 +164,9 @@ typedef
VG_USERREQ__MALLOCLIKE_BLOCK = 0x1301,
VG_USERREQ__FREELIKE_BLOCK = 0x1302,
+ /* Memory pool support. */
+ VG_USERREQ__CREATE_MEMPOOL = 0x1303,
+ VG_USERREQ__DESTROY_MEMPOOL = 0x1304,
+ VG_USERREQ__MEMPOOL_ALLOC = 0x1305,
+ VG_USERREQ__MEMPOOL_FREE = 0x1306,
/* Allow printfs to valgrind log. */
@@ -323,3 +328,35 @@ VALGRIND_PRINTF_BACKTRACE(const char *fo
}
+/* Create a memory pool. */
+#define VALGRIND_CREATE_MEMPOOL(pool, rzB, is_zeroed) \
+ {unsigned int _qzz_res; \
+ VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
+ VG_USERREQ__CREATE_MEMPOOL, \
+ pool, rzB, is_zeroed, 0); \
+ }
+
+/* Destroy a memory pool. */
+#define VALGRIND_DESTROY_MEMPOOL(pool) \
+ {unsigned int _qzz_res; \
+ VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
+ VG_USERREQ__DESTROY_MEMPOOL, \
+ pool, 0, 0, 0); \
+ }
+
+/* Associate a piece of memory with a memory pool. */
+#define VALGRIND_MEMPOOL_ALLOC(pool, addr, size) \
+ {unsigned int _qzz_res; \
+ VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
+ VG_USERREQ__MEMPOOL_ALLOC, \
+ pool, addr, size, 0); \
+ }
+
+/* Disassociate a piece of memory from a memory pool. */
+#define VALGRIND_MEMPOOL_FREE(pool, addr) \
+ {unsigned int _qzz_res; \
+ VALGRIND_MAGIC_SEQUENCE(_qzz_res, 0, \
+ VG_USERREQ__MEMPOOL_FREE, \
+ pool, addr, 0, 0); \
+ }
+
#endif /* __VALGRIND_H */
--- valgrind/memcheck/mac_malloc_wrappers.c #1.10:1.11
@@ -63,4 +63,8 @@ Bool (*MAC_(check_noaccess))( Addr a, UI
VgHashTable MAC_(malloc_list) = NULL;
+/* Memory pools. Nb: Addrcheck and Memcheck construct this separately
+ in their respective initialisation functions. */
+VgHashTable MAC_(mempool_list) = NULL;
+
/* Records blocks after freeing. */
static MAC_Chunk* freed_list_start = NULL;
@@ -128,5 +132,6 @@ MAC_Chunk* MAC_(first_matching_freed_MAC
/* Allocate its shadow chunk, put it on the appropriate list. */
static
-void add_MAC_Chunk ( Addr p, UInt size, MAC_AllocKind kind )
+MAC_Chunk* add_MAC_Chunk ( Addr p, UInt size, MAC_AllocKind kind,
+ VgHashTable table)
{
MAC_Chunk* mc;
@@ -147,5 +152,7 @@ void add_MAC_Chunk ( Addr p, UInt size,
}
- VG_(HT_add_node)( MAC_(malloc_list), (VgHashNode*)mc );
+ VG_(HT_add_node)( table, (VgHashNode*)mc );
+
+ return mc;
}
@@ -156,7 +163,10 @@ void add_MAC_Chunk ( Addr p, UInt size,
/* Allocate memory and note change in memory available */
__inline__
-void MAC_(new_block) ( Addr p, UInt size,
- UInt rzB, Bool is_zeroed, MAC_AllocKind kind )
+MAC_Chunk* MAC_(new_block) ( Addr p, UInt size,
+ UInt rzB, Bool is_zeroed, MAC_AllocKind kind,
+ VgHashTable table)
{
+ MAC_Chunk *mc;
+
VGP_PUSHCC(VgpCliMalloc);
@@ -164,5 +174,5 @@ void MAC_(new_block) ( Addr p, UInt size
cmalloc_bs_mallocd += size;
- add_MAC_Chunk( p, size, kind );
+ mc = add_MAC_Chunk( p, size, kind, table );
MAC_(ban_mem_heap)( p-rzB, rzB );
@@ -171,4 +181,6 @@ void MAC_(new_block) ( Addr p, UInt size
VGP_POPCC(VgpCliMalloc);
+
+ return mc;
}
@@ -181,5 +193,6 @@ void* SK_(malloc) ( Int n )
Addr p = (Addr)VG_(cli_malloc)( VG_(clo_alignment), n );
MAC_(new_block) ( p, n, VG_(vg_malloc_redzone_szB),
- /*is_zeroed*/False, MAC_AllocMalloc );
+ /*is_zeroed*/False, MAC_AllocMalloc,
+ MAC_(malloc_list));
return (void*)p;
}
@@ -194,5 +207,6 @@ void* SK_(__builtin_new) ( Int n )
Addr p = (Addr)VG_(cli_malloc)( VG_(clo_alignment), n );
MAC_(new_block) ( p, n, VG_(vg_malloc_redzone_szB),
- /*is_zeroed*/False, MAC_AllocNew );
+ /*is_zeroed*/False, MAC_AllocNew,
+ MAC_(malloc_list));
return (void*)p;
}
@@ -208,5 +222,6 @@ void* SK_(__builtin_vec_new) ( Int n )
Addr p = (Addr)VG_(cli_malloc)( VG_(clo_alignment), n );
MAC_(new_block) ( p, n, VG_(vg_malloc_redzone_szB),
- /*is_zeroed*/False, MAC_AllocNewVec );
+ /*is_zeroed*/False, MAC_AllocNewVec,
+ MAC_(malloc_list));
return (void*)p;
}
@@ -221,5 +236,6 @@ void* SK_(memalign) ( Int align, Int n )
Addr p = (Addr)VG_(cli_malloc)( align, n );
MAC_(new_block) ( p, n, VG_(vg_malloc_redzone_szB),
- /*is_zeroed*/False, MAC_AllocMalloc );
+ /*is_zeroed*/False, MAC_AllocMalloc,
+ MAC_(malloc_list));
return (void*)p;
}
@@ -239,5 +255,6 @@ void* SK_(calloc) ( Int nmemb, Int size1
Addr p = (Addr)VG_(cli_malloc)( VG_(clo_alignment), n );
MAC_(new_block) ( p, n, VG_(vg_malloc_redzone_szB),
- /*is_zeroed*/True, MAC_AllocMalloc );
+ /*is_zeroed*/True, MAC_AllocMalloc,
+ MAC_(malloc_list));
for (i = 0; i < n; i++)
((UChar*)p)[i] = 0;
@@ -262,11 +279,10 @@ void die_and_free_mem ( MAC_Chunk* mc,
*prev_chunks_next_ptr = mc->next;
+ /* Put it out of harm's way for a while, if not from a client request */
+ if (MAC_AllocCustom != mc->allockind) {
/* Record where freed */
mc->where = VG_(get_ExeContext) ( VG_(get_current_or_recent_tid)() );
-
- /* Put it out of harm's way for a while, if not from a client request */
- if (MAC_AllocCustom != mc->allockind)
add_to_freed_queue ( mc );
- else
+ } else
VG_(free) ( mc );
}
@@ -393,5 +408,5 @@ void* SK_(realloc) ( void* p, Int new_si
former succeeds in shorting out the new block, not the
old, in the case when both are on the same list. */
- add_MAC_Chunk ( p_new, new_size, MAC_AllocMalloc );
+ add_MAC_Chunk ( p_new, new_size, MAC_AllocMalloc, MAC_(malloc_list) );
VGP_POPCC(VgpCliMalloc);
@@ -400,4 +415,110 @@ void* SK_(realloc) ( void* p, Int new_si
}
+/* Memory pool stuff. */
+
+void MAC_(create_mempool)(Addr pool, UInt rzB, Bool is_zeroed)
+{
+ MAC_Mempool* mp;
+
+ mp = VG_(malloc)(sizeof(MAC_Mempool));
+ mp->pool = pool;
+ mp->rzB = rzB;
+ mp->is_zeroed = is_zeroed;
+ mp->chunks = VG_(HT_construct)();
+
+ /* Paranoia ... ensure this area is off-limits to the client, so
+ the mp->data field isn't visible to the leak checker. If memory
+ management is working correctly, anything pointer returned by
+ VG_(malloc) should be noaccess as far as the client is
+ concerned. */
+ if (!MAC_(check_noaccess)( (Addr)mp, sizeof(MAC_Mempool), NULL )) {
+ VG_(skin_panic)("MAC_(create_mempool): shadow area is accessible");
+ }
+
+ VG_(HT_add_node)( MAC_(mempool_list), (VgHashNode*)mp );
+
+}
+
+void MAC_(destroy_mempool)(Addr pool)
+{
+ MAC_Mempool* mp;
+ MAC_Mempool** prev_next;
+
+ void nuke_chunk(VgHashNode *node)
+ {
+ MAC_Chunk *mc = (MAC_Chunk *)node;
+
+ /* Note: ban redzones again -- just in case user de-banned them
+ with a client request... */
+ MAC_(ban_mem_heap)(mc->data-mp->rzB, mp->rzB );
+ MAC_(die_mem_heap)(mc->data, mc->size );
+ MAC_(ban_mem_heap)(mc->data+mc->size, mp->rzB );
+ }
+
+ mp = (MAC_Mempool*)VG_(HT_get_node) ( MAC_(mempool_list), (UInt)pool,
+ (VgHashNode***)&prev_next );
+
+ if (mp == NULL) {
+ ThreadId tid = VG_(get_current_or_recent_tid)();
+
+ MAC_(record_illegal_mempool_error) ( tid, pool );
+ return;
+ }
+
+ *prev_next = mp->next;
+ VG_(HT_apply_to_all_nodes)(mp->chunks, nuke_chunk);
+ VG_(HT_destruct)(mp->chunks);
+
+ VG_(free)(mp);
+}
+
+void MAC_(mempool_alloc)(Addr pool, Addr addr, UInt size)
+{
+ MAC_Mempool* mp;
+ MAC_Mempool** prev_next;
+ MAC_Chunk* mc;
+
+ mp = (MAC_Mempool*)VG_(HT_get_node) ( MAC_(mempool_list), (UInt)pool,
+ (VgHashNode***)&prev_next );
+
+ if (mp == NULL) {
+ ThreadId tid = VG_(get_current_or_recent_tid)();
+
+ MAC_(record_illegal_mempool_error) ( tid, pool );
+ return;
+ }
+
+ mc = MAC_(new_block)(addr, size, mp->rzB, mp->is_zeroed, MAC_AllocCustom,
+ mp->chunks);
+}
+
+void MAC_(mempool_free)(Addr pool, Addr addr)
+{
+ MAC_Mempool* mp;
+ MAC_Mempool** prev_pool;
+ MAC_Chunk* mc;
+ MAC_Chunk** prev_chunk;
+ ThreadId tid = VG_(get_current_or_recent_tid)();
+
+
+ mp = (MAC_Mempool*)VG_(HT_get_node)(MAC_(mempool_list), (UInt)pool,
+ (VgHashNode***)&prev_pool);
+
+ if (mp == NULL) {
+ MAC_(record_illegal_mempool_error)(tid, pool);
+ return;
+ }
+
+ mc = (MAC_Chunk*)VG_(HT_get_node)(mp->chunks, (UInt)addr,
+ (VgHashNode***)&prev_chunk);
+
+ if (mc == NULL) {
+ MAC_(record_free_error)(tid, (Addr)addr);
+ return;
+ }
+
+ die_and_free_mem(mc, prev_chunk, mp->rzB);
+}
+
void MAC_(print_malloc_stats) ( void )
{
--- valgrind/memcheck/mac_needs.c #1.26:1.27
@@ -197,4 +197,7 @@ Bool SK_(eq_SkinError) ( VgRes res, Erro
"since it's handled with VG_(unique_error)()!");
+ case IllegalMempoolErr:
+ return True;
+
default:
VG_(printf)("Error:\n unknown error code %d\n",
@@ -224,7 +227,13 @@ void MAC_(pp_AddrInfo) ( Addr a, AddrInf
}
break;
- case Freed: case Mallocd: case UserG: {
+ case Freed: case Mallocd: case UserG: case Mempool: {
UInt delta;
UChar* relative;
+ UChar* kind;
+ if (ai->akind == Mempool) {
+ kind = "mempool";
+ } else {
+ kind = "block";
+ }
if (ai->rwoffset < 0) {
delta = (UInt)(- ai->rwoffset);
@@ -238,6 +247,6 @@ void MAC_(pp_AddrInfo) ( Addr a, AddrInf
}
VG_(message)(Vg_UserMsg,
- " Address 0x%x is %d bytes %s a block of size %d %s",
- a, delta, relative,
+ " Address 0x%x is %d bytes %s a %s of size %d %s",
+ a, delta, relative, kind,
ai->blksize,
ai->akind==Mallocd ? "alloc'd"
@@ -315,4 +324,10 @@ void MAC_(pp_shared_SkinError) ( Error*
}
+ case IllegalMempoolErr:
+ VG_(message)(Vg_UserMsg, "Illegal memory pool address");
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ MAC_(pp_AddrInfo)(VG_(get_error_address)(err), &err_extra->addrinfo);
+ break;
+
default:
VG_(printf)("Error:\n unknown Memcheck/Addrcheck error code %d\n",
@@ -471,4 +486,14 @@ void MAC_(record_free_error) ( ThreadId
}
+void MAC_(record_illegal_mempool_error) ( ThreadId tid, Addr a )
+{
+ MAC_Error err_extra;
+
+ sk_assert(VG_INVALID_THREADID != tid);
+ MAC_(clear_MAC_Error)( &err_extra );
+ err_extra.addrinfo.akind = Undescribed;
+ VG_(maybe_record_error)( tid, IllegalMempoolErr, a, /*s*/NULL, &err_extra );
+}
+
void MAC_(record_freemismatch_error) ( ThreadId tid, Addr a )
{
@@ -500,4 +525,5 @@ UInt SK_(update_extra)( Error* err )
case UserErr:
case FreeErr:
+ case IllegalMempoolErr:
case FreeMismatchErr: {
MAC_Error* extra = (MAC_Error*)VG_(get_error_extra)(err);
@@ -534,4 +560,5 @@ Bool MAC_(shared_recognised_suppression)
else if (VG_STREQ(name, "Leak")) skind = LeakSupp;
else if (VG_STREQ(name, "Overlap")) skind = OverlapSupp;
+ else if (VG_STREQ(name, "Mempool")) skind = MempoolSupp;
else
return False;
@@ -596,4 +623,7 @@ Bool SK_(error_matches_suppression)(Erro
return (ekind == LeakErr);
+ case MempoolSupp:
+ return (ekind == IllegalMempoolErr);
+
default:
VG_(printf)("Error:\n"
@@ -612,4 +642,5 @@ Char* SK_(get_error_name) ( Error* err )
case UserErr: return NULL; /* Can't suppress User errors */
case FreeMismatchErr: return "Free";
+ case IllegalMempoolErr: return "Mempool";
case FreeErr: return "Free";
case AddrErr:
@@ -785,4 +816,5 @@ void MAC_(common_pre_clo_init)(void)
{
MAC_(malloc_list) = VG_(HT_construct)();
+ MAC_(mempool_list) = VG_(HT_construct)();
init_prof_mem();
}
@@ -845,5 +877,6 @@ Bool MAC_(handle_common_client_requests)
Bool is_zeroed = (Bool)arg[4];
- MAC_(new_block) ( p, sizeB, rzB, is_zeroed, MAC_AllocCustom );
+ MAC_(new_block) ( p, sizeB, rzB, is_zeroed, MAC_AllocCustom,
+ MAC_(malloc_list) );
return True;
}
@@ -860,4 +893,37 @@ Bool MAC_(handle_common_client_requests)
return True;
+ case VG_USERREQ__CREATE_MEMPOOL: {
+ Addr pool = (Addr)arg[1];
+ UInt rzB = arg[2];
+ Bool is_zeroed = (Bool)arg[3];
+
+ MAC_(create_mempool) ( pool, rzB, is_zeroed );
+ return True;
+ }
+
+ case VG_USERREQ__DESTROY_MEMPOOL: {
+ Addr pool = (Addr)arg[1];
+
+ MAC_(destroy_mempool) ( pool );
+ return True;
+ }
+
+ case VG_USERREQ__MEMPOOL_ALLOC: {
+ Addr pool = (Addr)arg[1];
+ Addr addr = (Addr)arg[2];
+ UInt size = arg[3];
+
+ MAC_(mempool_alloc) ( pool, addr, size );
+ return True;
+ }
+
+ case VG_USERREQ__MEMPOOL_FREE: {
+ Addr pool = (Addr)arg[1];
+ Addr addr = (Addr)arg[2];
+
+ MAC_(mempool_free) ( pool, addr );
+ return True;
+ }
+
default:
return False;
--- valgrind/memcheck/mac_shared.h #1.17:1.18
@@ -52,5 +52,6 @@ typedef
Unknown, /* classification yielded nothing useful */
Freed, Mallocd,
- UserG /* in a user-defined block; Addrcheck & Memcheck only */
+ UserG, /* in a user-defined block; Addrcheck & Memcheck only */
+ Mempool, /* in a mempool; Addrcheck & Memcheck only */
}
AddrKind;
@@ -89,5 +90,7 @@ typedef
OverlapSupp,
/* Something to be suppressed in a leak check. */
- LeakSupp
+ LeakSupp,
+ /* Memory pool suppression. */
+ MempoolSupp,
}
MAC_SuppKind;
@@ -101,5 +104,6 @@ typedef
FreeErr, FreeMismatchErr,
OverlapErr,
- LeakErr
+ LeakErr,
+ IllegalMempoolErr,
}
MAC_ErrorKind;
@@ -154,4 +158,16 @@ typedef
MAC_Chunk;
+/* Memory pool. Nb: first two fields must match core's VgHashNode. */
+typedef
+ struct _MAC_Mempool {
+ struct _MAC_Mempool* next;
+ Addr pool; /* pool identifier */
+ UInt rzB; /* pool red-zone size */
+ Bool is_zeroed; /* allocations from this pool are zeroed */
+ VgHashTable chunks; /* chunks associated with this pool */
+ }
+ MAC_Mempool;
+
+
/*------------------------------------------------------------*/
/*--- Profiling of tools and memory events ---*/
@@ -271,4 +287,7 @@ extern void MAC_(print_common_debug_usag
extern VgHashTable MAC_(malloc_list);
+/* For tracking memory pools. */
+extern VgHashTable MAC_(mempool_list);
+
/* Function pointers for the two tools to track interesting events. */
extern void (*MAC_(new_mem_heap)) ( Addr a, UInt len, Bool is_inited );
@@ -299,8 +318,14 @@ extern void MAC_(clear_MAC_Error)
extern Bool MAC_(shared_recognised_suppression) ( Char* name, Supp* su );
-extern void MAC_(new_block) ( Addr p, UInt size, UInt rzB,
- Bool is_zeroed, MAC_AllocKind kind );
+extern MAC_Chunk* MAC_(new_block) ( Addr p, UInt size, UInt rzB,
+ Bool is_zeroed, MAC_AllocKind kind,
+ VgHashTable table);
extern void MAC_(handle_free) ( Addr p, UInt rzB, MAC_AllocKind kind );
+extern void MAC_(create_mempool)(Addr pool, UInt rzB, Bool is_zeroed);
+extern void MAC_(destroy_mempool)(Addr pool);
+extern void MAC_(mempool_alloc)(Addr pool, Addr addr, UInt size);
+extern void MAC_(mempool_free)(Addr pool, Addr addr);
+
extern void MAC_(record_address_error) ( ThreadId tid, Addr a,
Int size, Bool isWrite );
@@ -313,4 +338,5 @@ extern void MAC_(record_free_error)
extern void MAC_(record_freemismatch_error)( ThreadId tid, Addr a );
extern void MAC_(record_overlap_error) ( Char* function, OverlapExtra* oe );
+extern void MAC_(record_illegal_mempool_error) ( ThreadId tid, Addr pool );
extern void MAC_(pp_shared_SkinError) ( Error* err);
--- valgrind/memcheck/mc_clientreqs.c #1.19:1.20
@@ -135,4 +135,35 @@ Bool MC_(client_perm_maybe_describe)( Ad
continue;
if (VG_(addr_is_in_block)(a, vg_cgbs[i].start, vg_cgbs[i].size)) {
+ MAC_Mempool **d, *mp;
+
+ /* OK - maybe it's a mempool, too? */
+ mp = (MAC_Mempool*)VG_(HT_get_node)(MAC_(mempool_list),
+ (UInt)vg_cgbs[i].start,
+ (VgHashNode***)&d);
+ if(mp != NULL) {
+ if(mp->chunks != NULL) {
+ MAC_Chunk *mc;
+
+ Bool find_addr(VgHashNode* sh_ch)
+ {
+ MAC_Chunk *m = (MAC_Chunk*)sh_ch;
+ return VG_(addr_is_in_block)(a, m->data, m->size);
+ }
+
+ mc = (MAC_Chunk*)VG_(HT_first_match)(mp->chunks, find_addr);
+ if(mc != NULL) {
+ ai->akind = UserG;
+ ai->blksize = mc->size;
+ ai->rwoffset = (Int)(a) - (Int)mc->data;
+ ai->lastchange = mc->where;
+ return True;
+ }
+ }
+ ai->akind = Mempool;
+ ai->blksize = vg_cgbs[i].size;
+ ai->rwoffset = (Int)(a) - (Int)(vg_cgbs[i].start);
+ ai->lastchange = vg_cgbs[i].where;
+ return True;
+ }
ai->akind = UserG;
ai->blksize = vg_cgbs[i].size;
@@ -153,5 +184,9 @@ Bool SK_(handle_client_request) ( Thread
if (!VG_IS_SKIN_USERREQ('M','C',arg[0])
&& VG_USERREQ__MALLOCLIKE_BLOCK != arg[0]
- && VG_USERREQ__FREELIKE_BLOCK != arg[0])
+ && VG_USERREQ__FREELIKE_BLOCK != arg[0]
+ && VG_USERREQ__CREATE_MEMPOOL != arg[0]
+ && VG_USERREQ__DESTROY_MEMPOOL != arg[0]
+ && VG_USERREQ__MEMPOOL_ALLOC != arg[0]
+ && VG_USERREQ__MEMPOOL_FREE != arg[0])
return False;
--- valgrind/memcheck/tests/Makefile.am #1.35:1.36
@@ -44,4 +44,5 @@
memalign_test.stderr.exp memalign_test.vgtest \
memcmptest.stderr.exp memcmptest.stdout.exp memcmptest.vgtest \
+ mempool.stderr.exp mempool.vgtest \
mismatches.stderr.exp mismatches.vgtest \
mmaptest.stderr.exp mmaptest.vgtest \
@@ -79,6 +80,6 @@
fpeflags fprw fwrite inits inline \
malloc1 malloc2 malloc3 manuel1 manuel2 manuel3 \
- memalign_test memcmptest mmaptest nanoleak new_nothrow null_socket \
- overlap pushfpopf \
+ memalign_test memcmptest mempool mmaptest nanoleak new_nothrow \
+ null_socket overlap pushfpopf \
realloc1 realloc2 realloc3 sigaltstack signal2 supp1 supp2 suppfree \
trivialleak tronical weirdioctl \
@@ -118,4 +119,5 @@
memalign_test_SOURCES = memalign_test.c
memcmptest_SOURCES = memcmptest.c
+mempool_SOURCES = mempool.c
nanoleak_SOURCES = nanoleak.c
null_socket_SOURCES = null_socket.c
|
