Aren/haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
f4bd38257b
haiku/headers/posix/malloc_debug.h

38 lines
936 B
C
Raw Normal View History

* Adding malloc_debug.h that exposes the malloc_debug API. * Moving some functions around, removing and adding others for the public API. I've written a blog post at haiku-os.org to go as documentation for this introducing the API and the other helpful bits. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@35431 a95241bf-73f2-0310-859d-f6bbb57e9c96
2010-02-08 04:27:21 +03:00
/*
Updated copyright in headers. No functional change.
2012-07-19 22:11:40 +04:00
* Copyright 2010-2012 Haiku, Inc. All Rights Reserved.
* Adding malloc_debug.h that exposes the malloc_debug API. * Moving some functions around, removing and adding others for the public API. I've written a blog post at haiku-os.org to go as documentation for this introducing the API and the other helpful bits. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@35431 a95241bf-73f2-0310-859d-f6bbb57e9c96
2010-02-08 04:27:21 +03:00
* Distributed under the terms of the MIT License.
*/
#ifndef MALLOC_DEBUG_H
#define MALLOC_DEBUG_H
Updated posix headers to remove commas from copyright line, to match the preferred coding guidelines. Cleaned up some header style violations, making sure there are two blank lines after the header guards. This fixes the posix header part of #2191. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@39288 a95241bf-73f2-0310-859d-f6bbb57e9c96
2010-11-04 00:46:47 +03:00
* Add heap_debug_set_memory_reuse() which allows to disable memory reuse, keeping all returned heap memory in the 0xdeadbeef state (including the first sizeof(void *) bytes otherwise for the free list). While wasting a lot of memory it allows you to rely on 0xdeadbeef being always present as no future allocation will reuse the freed memory block. * Also added heap_debug_malloc_with_guard_page() which is intended to allocate a memory block so it is aligned that the start of invalid memory past the allocation is in an unmapped guard page. However the kernel backend that would guarantee this is not yet implemented, so right now this works only by chance if no other area happens to be allocated exactly past the created one. With a very specifc suspicion you can put that one allocation you get to good use though. It causes a crash when accessing memory past the allocation size so you actually get a backtrace from where the access happened instead of only after freeing/wall checking. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@35478 a95241bf-73f2-0310-859d-f6bbb57e9c96
2010-02-15 23:28:15 +03:00
#include <OS.h>
* Adding malloc_debug.h that exposes the malloc_debug API. * Moving some functions around, removing and adding others for the public API. I've written a blog post at haiku-os.org to go as documentation for this introducing the API and the other helpful bits. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@35431 a95241bf-73f2-0310-859d-f6bbb57e9c96
2010-02-08 04:27:21 +03:00
#ifdef __cplusplus
extern "C" {
#endif
* Add heap_debug_set_memory_reuse() which allows to disable memory reuse, keeping all returned heap memory in the 0xdeadbeef state (including the first sizeof(void *) bytes otherwise for the free list). While wasting a lot of memory it allows you to rely on 0xdeadbeef being always present as no future allocation will reuse the freed memory block. * Also added heap_debug_malloc_with_guard_page() which is intended to allocate a memory block so it is aligned that the start of invalid memory past the allocation is in an unmapped guard page. However the kernel backend that would guarantee this is not yet implemented, so right now this works only by chance if no other area happens to be allocated exactly past the created one. With a very specifc suspicion you can put that one allocation you get to good use though. It causes a crash when accessing memory past the allocation size so you actually get a backtrace from where the access happened instead of only after freeing/wall checking. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@35478 a95241bf-73f2-0310-859d-f6bbb57e9c96
2010-02-15 23:28:15 +03:00
status_t heap_debug_start_wall_checking(int msInterval);
status_t heap_debug_stop_wall_checking();
void heap_debug_set_memory_reuse(bool enabled);
void heap_debug_set_paranoid_validation(bool enabled);
Add heap_debug_set_debugger_calls() which allows to disable debugger calls for the heap debug panics. Instead syslog output is generated if turned off. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@35481 a95241bf-73f2-0310-859d-f6bbb57e9c96
2010-02-16 00:35:07 +03:00
void heap_debug_set_debugger_calls(bool enabled);
malloc_debug: Add default alignment option. This allows for something similar as was implemented in 217f090 but makes it optional and configurable. The MALLOC_DEBUG environment variable now can take "a<size>" to set the default alignment to the specified size. Note that not all alignments may be supported depending on the heap implementation.
2015-04-04 17:41:45 +03:00
void heap_debug_set_default_alignment(size_t defaultAlignment);
* Add heap_debug_set_memory_reuse() which allows to disable memory reuse, keeping all returned heap memory in the 0xdeadbeef state (including the first sizeof(void *) bytes otherwise for the free list). While wasting a lot of memory it allows you to rely on 0xdeadbeef being always present as no future allocation will reuse the freed memory block. * Also added heap_debug_malloc_with_guard_page() which is intended to allocate a memory block so it is aligned that the start of invalid memory past the allocation is in an unmapped guard page. However the kernel backend that would guarantee this is not yet implemented, so right now this works only by chance if no other area happens to be allocated exactly past the created one. With a very specifc suspicion you can put that one allocation you get to good use though. It causes a crash when accessing memory past the allocation size so you actually get a backtrace from where the access happened instead of only after freeing/wall checking. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@35478 a95241bf-73f2-0310-859d-f6bbb57e9c96
2010-02-15 23:28:15 +03:00
void heap_debug_validate_heaps();
void heap_debug_validate_walls();
* Adding malloc_debug.h that exposes the malloc_debug API. * Moving some functions around, removing and adding others for the public API. I've written a blog post at haiku-os.org to go as documentation for this introducing the API and the other helpful bits. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@35431 a95241bf-73f2-0310-859d-f6bbb57e9c96
2010-02-08 04:27:21 +03:00
* Add heap_debug_set_memory_reuse() which allows to disable memory reuse, keeping all returned heap memory in the 0xdeadbeef state (including the first sizeof(void *) bytes otherwise for the free list). While wasting a lot of memory it allows you to rely on 0xdeadbeef being always present as no future allocation will reuse the freed memory block. * Also added heap_debug_malloc_with_guard_page() which is intended to allocate a memory block so it is aligned that the start of invalid memory past the allocation is in an unmapped guard page. However the kernel backend that would guarantee this is not yet implemented, so right now this works only by chance if no other area happens to be allocated exactly past the created one. With a very specifc suspicion you can put that one allocation you get to good use though. It causes a crash when accessing memory past the allocation size so you actually get a backtrace from where the access happened instead of only after freeing/wall checking. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@35478 a95241bf-73f2-0310-859d-f6bbb57e9c96
2010-02-15 23:28:15 +03:00
void heap_debug_dump_allocations(bool statsOnly, thread_id thread);
void heap_debug_dump_heaps(bool dumpAreas, bool dumpBins);
* Adding malloc_debug.h that exposes the malloc_debug API. * Moving some functions around, removing and adding others for the public API. I've written a blog post at haiku-os.org to go as documentation for this introducing the API and the other helpful bits. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@35431 a95241bf-73f2-0310-859d-f6bbb57e9c96
2010-02-08 04:27:21 +03:00
* Add heap_debug_set_memory_reuse() which allows to disable memory reuse, keeping all returned heap memory in the 0xdeadbeef state (including the first sizeof(void *) bytes otherwise for the free list). While wasting a lot of memory it allows you to rely on 0xdeadbeef being always present as no future allocation will reuse the freed memory block. * Also added heap_debug_malloc_with_guard_page() which is intended to allocate a memory block so it is aligned that the start of invalid memory past the allocation is in an unmapped guard page. However the kernel backend that would guarantee this is not yet implemented, so right now this works only by chance if no other area happens to be allocated exactly past the created one. With a very specifc suspicion you can put that one allocation you get to good use though. It causes a crash when accessing memory past the allocation size so you actually get a backtrace from where the access happened instead of only after freeing/wall checking. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@35478 a95241bf-73f2-0310-859d-f6bbb57e9c96
2010-02-15 23:28:15 +03:00
void *heap_debug_malloc_with_guard_page(size_t size);
* Adding malloc_debug.h that exposes the malloc_debug API. * Moving some functions around, removing and adding others for the public API. I've written a blog post at haiku-os.org to go as documentation for this introducing the API and the other helpful bits. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@35431 a95241bf-73f2-0310-859d-f6bbb57e9c96
2010-02-08 04:27:21 +03:00
Add heap_debug_get_allocation_info() to retrieve the size of the allocation as well as the thread allocating it. Can for example be used to verify that an object or buffer is as large as expected. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@35480 a95241bf-73f2-0310-859d-f6bbb57e9c96
2010-02-15 23:57:52 +03:00
status_t heap_debug_get_allocation_info(void *address, size_t *size,
thread_id *thread);
* Adding malloc_debug.h that exposes the malloc_debug API. * Moving some functions around, removing and adding others for the public API. I've written a blog post at haiku-os.org to go as documentation for this introducing the API and the other helpful bits. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@35431 a95241bf-73f2-0310-859d-f6bbb57e9c96
2010-02-08 04:27:21 +03:00
#ifdef __cplusplus
}
#endif
#endif /* MALLOC_DEBUG_H */
Reference in New Issue Copy Permalink