mirror/btstack
1
0
Fork 0
mirror of https://github.com/bluekitchen/btstack.git synced 2025-03-28 08:37:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

btstack_memory: fix de-init

Browse Source
This commit is contained in:
Matthias Ringwald 2021-02-03 14:31:14 +01:00
parent 642d8b89ed
commit 798bd46f26
2 changed files with 156 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

236
src/btstack_memory.c
View File

@ -61,6 +61,11 @@ typedef struct btstack_memory_buffer {
struct btstack_memory_buffer * prev;
} btstack_memory_buffer_t;
typedef struct {
btstack_memory_buffer_t tracking;
void * pointer;
} test_buffer_t;
static btstack_memory_buffer_t * btstack_memory_malloc_buffers;
static uint32_t btstack_memory_malloc_counter;
@ -139,14 +144,14 @@ void btstack_memory_hci_connection_free(hci_connection_t *hci_connection){
#elif defined(HAVE_MALLOC)
typedef struct {
hci_connection_t data;
btstack_memory_buffer_t tracking;
hci_connection_t data;
} btstack_memory_hci_connection_t;
hci_connection_t * btstack_memory_hci_connection_get(void){
btstack_memory_hci_connection_t * buffer = (btstack_memory_hci_connection_t *) malloc(sizeof(btstack_memory_hci_connection_t));
if (buffer){
memset(buffer, 0, sizeof(hci_connection_t));
memset(buffer, 0, sizeof(btstack_memory_hci_connection_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -154,8 +159,9 @@ hci_connection_t * btstack_memory_hci_connection_get(void){
}
}
void btstack_memory_hci_connection_free(hci_connection_t *hci_connection){
btstack_memory_hci_connection_t * buffer = (btstack_memory_hci_connection_t *) hci_connection;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) hci_connection)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -196,14 +202,14 @@ void btstack_memory_l2cap_service_free(l2cap_service_t *l2cap_service){
#elif defined(HAVE_MALLOC)
typedef struct {
l2cap_service_t data;
btstack_memory_buffer_t tracking;
l2cap_service_t data;
} btstack_memory_l2cap_service_t;
l2cap_service_t * btstack_memory_l2cap_service_get(void){
btstack_memory_l2cap_service_t * buffer = (btstack_memory_l2cap_service_t *) malloc(sizeof(btstack_memory_l2cap_service_t));
if (buffer){
memset(buffer, 0, sizeof(l2cap_service_t));
memset(buffer, 0, sizeof(btstack_memory_l2cap_service_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -211,8 +217,9 @@ l2cap_service_t * btstack_memory_l2cap_service_get(void){
}
}
void btstack_memory_l2cap_service_free(l2cap_service_t *l2cap_service){
btstack_memory_l2cap_service_t * buffer = (btstack_memory_l2cap_service_t *) l2cap_service;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) l2cap_service)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -252,14 +259,14 @@ void btstack_memory_l2cap_channel_free(l2cap_channel_t *l2cap_channel){
#elif defined(HAVE_MALLOC)
typedef struct {
l2cap_channel_t data;
btstack_memory_buffer_t tracking;
l2cap_channel_t data;
} btstack_memory_l2cap_channel_t;
l2cap_channel_t * btstack_memory_l2cap_channel_get(void){
btstack_memory_l2cap_channel_t * buffer = (btstack_memory_l2cap_channel_t *) malloc(sizeof(btstack_memory_l2cap_channel_t));
if (buffer){
memset(buffer, 0, sizeof(l2cap_channel_t));
memset(buffer, 0, sizeof(btstack_memory_l2cap_channel_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -267,8 +274,9 @@ l2cap_channel_t * btstack_memory_l2cap_channel_get(void){
}
}
void btstack_memory_l2cap_channel_free(l2cap_channel_t *l2cap_channel){
btstack_memory_l2cap_channel_t * buffer = (btstack_memory_l2cap_channel_t *) l2cap_channel;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) l2cap_channel)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -310,14 +318,14 @@ void btstack_memory_rfcomm_multiplexer_free(rfcomm_multiplexer_t *rfcomm_multipl
#elif defined(HAVE_MALLOC)
typedef struct {
rfcomm_multiplexer_t data;
btstack_memory_buffer_t tracking;
rfcomm_multiplexer_t data;
} btstack_memory_rfcomm_multiplexer_t;
rfcomm_multiplexer_t * btstack_memory_rfcomm_multiplexer_get(void){
btstack_memory_rfcomm_multiplexer_t * buffer = (btstack_memory_rfcomm_multiplexer_t *) malloc(sizeof(btstack_memory_rfcomm_multiplexer_t));
if (buffer){
memset(buffer, 0, sizeof(rfcomm_multiplexer_t));
memset(buffer, 0, sizeof(btstack_memory_rfcomm_multiplexer_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -325,8 +333,9 @@ rfcomm_multiplexer_t * btstack_memory_rfcomm_multiplexer_get(void){
}
}
void btstack_memory_rfcomm_multiplexer_free(rfcomm_multiplexer_t *rfcomm_multiplexer){
btstack_memory_rfcomm_multiplexer_t * buffer = (btstack_memory_rfcomm_multiplexer_t *) rfcomm_multiplexer;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) rfcomm_multiplexer)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -366,14 +375,14 @@ void btstack_memory_rfcomm_service_free(rfcomm_service_t *rfcomm_service){
#elif defined(HAVE_MALLOC)
typedef struct {
rfcomm_service_t data;
btstack_memory_buffer_t tracking;
rfcomm_service_t data;
} btstack_memory_rfcomm_service_t;
rfcomm_service_t * btstack_memory_rfcomm_service_get(void){
btstack_memory_rfcomm_service_t * buffer = (btstack_memory_rfcomm_service_t *) malloc(sizeof(btstack_memory_rfcomm_service_t));
if (buffer){
memset(buffer, 0, sizeof(rfcomm_service_t));
memset(buffer, 0, sizeof(btstack_memory_rfcomm_service_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -381,8 +390,9 @@ rfcomm_service_t * btstack_memory_rfcomm_service_get(void){
}
}
void btstack_memory_rfcomm_service_free(rfcomm_service_t *rfcomm_service){
btstack_memory_rfcomm_service_t * buffer = (btstack_memory_rfcomm_service_t *) rfcomm_service;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) rfcomm_service)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -422,14 +432,14 @@ void btstack_memory_rfcomm_channel_free(rfcomm_channel_t *rfcomm_channel){
#elif defined(HAVE_MALLOC)
typedef struct {
rfcomm_channel_t data;
btstack_memory_buffer_t tracking;
rfcomm_channel_t data;
} btstack_memory_rfcomm_channel_t;
rfcomm_channel_t * btstack_memory_rfcomm_channel_get(void){
btstack_memory_rfcomm_channel_t * buffer = (btstack_memory_rfcomm_channel_t *) malloc(sizeof(btstack_memory_rfcomm_channel_t));
if (buffer){
memset(buffer, 0, sizeof(rfcomm_channel_t));
memset(buffer, 0, sizeof(btstack_memory_rfcomm_channel_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -437,8 +447,9 @@ rfcomm_channel_t * btstack_memory_rfcomm_channel_get(void){
}
}
void btstack_memory_rfcomm_channel_free(rfcomm_channel_t *rfcomm_channel){
btstack_memory_rfcomm_channel_t * buffer = (btstack_memory_rfcomm_channel_t *) rfcomm_channel;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) rfcomm_channel)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -479,14 +490,14 @@ void btstack_memory_btstack_link_key_db_memory_entry_free(btstack_link_key_db_me
#elif defined(HAVE_MALLOC)
typedef struct {
btstack_link_key_db_memory_entry_t data;
btstack_memory_buffer_t tracking;
btstack_link_key_db_memory_entry_t data;
} btstack_memory_btstack_link_key_db_memory_entry_t;
btstack_link_key_db_memory_entry_t * btstack_memory_btstack_link_key_db_memory_entry_get(void){
btstack_memory_btstack_link_key_db_memory_entry_t * buffer = (btstack_memory_btstack_link_key_db_memory_entry_t *) malloc(sizeof(btstack_memory_btstack_link_key_db_memory_entry_t));
if (buffer){
memset(buffer, 0, sizeof(btstack_link_key_db_memory_entry_t));
memset(buffer, 0, sizeof(btstack_memory_btstack_link_key_db_memory_entry_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -494,8 +505,9 @@ btstack_link_key_db_memory_entry_t * btstack_memory_btstack_link_key_db_memory_e
}
}
void btstack_memory_btstack_link_key_db_memory_entry_free(btstack_link_key_db_memory_entry_t *btstack_link_key_db_memory_entry){
btstack_memory_btstack_link_key_db_memory_entry_t * buffer = (btstack_memory_btstack_link_key_db_memory_entry_t *) btstack_link_key_db_memory_entry;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) btstack_link_key_db_memory_entry)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -536,14 +548,14 @@ void btstack_memory_bnep_service_free(bnep_service_t *bnep_service){
#elif defined(HAVE_MALLOC)
typedef struct {
bnep_service_t data;
btstack_memory_buffer_t tracking;
bnep_service_t data;
} btstack_memory_bnep_service_t;
bnep_service_t * btstack_memory_bnep_service_get(void){
btstack_memory_bnep_service_t * buffer = (btstack_memory_bnep_service_t *) malloc(sizeof(btstack_memory_bnep_service_t));
if (buffer){
memset(buffer, 0, sizeof(bnep_service_t));
memset(buffer, 0, sizeof(btstack_memory_bnep_service_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -551,8 +563,9 @@ bnep_service_t * btstack_memory_bnep_service_get(void){
}
}
void btstack_memory_bnep_service_free(bnep_service_t *bnep_service){
btstack_memory_bnep_service_t * buffer = (btstack_memory_bnep_service_t *) bnep_service;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) bnep_service)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -592,14 +605,14 @@ void btstack_memory_bnep_channel_free(bnep_channel_t *bnep_channel){
#elif defined(HAVE_MALLOC)
typedef struct {
bnep_channel_t data;
btstack_memory_buffer_t tracking;
bnep_channel_t data;
} btstack_memory_bnep_channel_t;
bnep_channel_t * btstack_memory_bnep_channel_get(void){
btstack_memory_bnep_channel_t * buffer = (btstack_memory_bnep_channel_t *) malloc(sizeof(btstack_memory_bnep_channel_t));
if (buffer){
memset(buffer, 0, sizeof(bnep_channel_t));
memset(buffer, 0, sizeof(btstack_memory_bnep_channel_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -607,8 +620,9 @@ bnep_channel_t * btstack_memory_bnep_channel_get(void){
}
}
void btstack_memory_bnep_channel_free(bnep_channel_t *bnep_channel){
btstack_memory_bnep_channel_t * buffer = (btstack_memory_bnep_channel_t *) bnep_channel;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) bnep_channel)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -649,14 +663,14 @@ void btstack_memory_hfp_connection_free(hfp_connection_t *hfp_connection){
#elif defined(HAVE_MALLOC)
typedef struct {
hfp_connection_t data;
btstack_memory_buffer_t tracking;
hfp_connection_t data;
} btstack_memory_hfp_connection_t;
hfp_connection_t * btstack_memory_hfp_connection_get(void){
btstack_memory_hfp_connection_t * buffer = (btstack_memory_hfp_connection_t *) malloc(sizeof(btstack_memory_hfp_connection_t));
if (buffer){
memset(buffer, 0, sizeof(hfp_connection_t));
memset(buffer, 0, sizeof(btstack_memory_hfp_connection_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -664,8 +678,9 @@ hfp_connection_t * btstack_memory_hfp_connection_get(void){
}
}
void btstack_memory_hfp_connection_free(hfp_connection_t *hfp_connection){
btstack_memory_hfp_connection_t * buffer = (btstack_memory_hfp_connection_t *) hfp_connection;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) hfp_connection)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -706,14 +721,14 @@ void btstack_memory_service_record_item_free(service_record_item_t *service_reco
#elif defined(HAVE_MALLOC)
typedef struct {
service_record_item_t data;
btstack_memory_buffer_t tracking;
service_record_item_t data;
} btstack_memory_service_record_item_t;
service_record_item_t * btstack_memory_service_record_item_get(void){
btstack_memory_service_record_item_t * buffer = (btstack_memory_service_record_item_t *) malloc(sizeof(btstack_memory_service_record_item_t));
if (buffer){
memset(buffer, 0, sizeof(service_record_item_t));
memset(buffer, 0, sizeof(btstack_memory_service_record_item_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -721,8 +736,9 @@ service_record_item_t * btstack_memory_service_record_item_get(void){
}
}
void btstack_memory_service_record_item_free(service_record_item_t *service_record_item){
btstack_memory_service_record_item_t * buffer = (btstack_memory_service_record_item_t *) service_record_item;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) service_record_item)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -763,14 +779,14 @@ void btstack_memory_avdtp_stream_endpoint_free(avdtp_stream_endpoint_t *avdtp_st
#elif defined(HAVE_MALLOC)
typedef struct {
avdtp_stream_endpoint_t data;
btstack_memory_buffer_t tracking;
avdtp_stream_endpoint_t data;
} btstack_memory_avdtp_stream_endpoint_t;
avdtp_stream_endpoint_t * btstack_memory_avdtp_stream_endpoint_get(void){
btstack_memory_avdtp_stream_endpoint_t * buffer = (btstack_memory_avdtp_stream_endpoint_t *) malloc(sizeof(btstack_memory_avdtp_stream_endpoint_t));
if (buffer){
memset(buffer, 0, sizeof(avdtp_stream_endpoint_t));
memset(buffer, 0, sizeof(btstack_memory_avdtp_stream_endpoint_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -778,8 +794,9 @@ avdtp_stream_endpoint_t * btstack_memory_avdtp_stream_endpoint_get(void){
}
}
void btstack_memory_avdtp_stream_endpoint_free(avdtp_stream_endpoint_t *avdtp_stream_endpoint){
btstack_memory_avdtp_stream_endpoint_t * buffer = (btstack_memory_avdtp_stream_endpoint_t *) avdtp_stream_endpoint;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) avdtp_stream_endpoint)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -820,14 +837,14 @@ void btstack_memory_avdtp_connection_free(avdtp_connection_t *avdtp_connection){
#elif defined(HAVE_MALLOC)
typedef struct {
avdtp_connection_t data;
btstack_memory_buffer_t tracking;
avdtp_connection_t data;
} btstack_memory_avdtp_connection_t;
avdtp_connection_t * btstack_memory_avdtp_connection_get(void){
btstack_memory_avdtp_connection_t * buffer = (btstack_memory_avdtp_connection_t *) malloc(sizeof(btstack_memory_avdtp_connection_t));
if (buffer){
memset(buffer, 0, sizeof(avdtp_connection_t));
memset(buffer, 0, sizeof(btstack_memory_avdtp_connection_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -835,8 +852,9 @@ avdtp_connection_t * btstack_memory_avdtp_connection_get(void){
}
}
void btstack_memory_avdtp_connection_free(avdtp_connection_t *avdtp_connection){
btstack_memory_avdtp_connection_t * buffer = (btstack_memory_avdtp_connection_t *) avdtp_connection;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) avdtp_connection)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -877,14 +895,14 @@ void btstack_memory_avrcp_connection_free(avrcp_connection_t *avrcp_connection){
#elif defined(HAVE_MALLOC)
typedef struct {
avrcp_connection_t data;
btstack_memory_buffer_t tracking;
avrcp_connection_t data;
} btstack_memory_avrcp_connection_t;
avrcp_connection_t * btstack_memory_avrcp_connection_get(void){
btstack_memory_avrcp_connection_t * buffer = (btstack_memory_avrcp_connection_t *) malloc(sizeof(btstack_memory_avrcp_connection_t));
if (buffer){
memset(buffer, 0, sizeof(avrcp_connection_t));
memset(buffer, 0, sizeof(btstack_memory_avrcp_connection_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -892,8 +910,9 @@ avrcp_connection_t * btstack_memory_avrcp_connection_get(void){
}
}
void btstack_memory_avrcp_connection_free(avrcp_connection_t *avrcp_connection){
btstack_memory_avrcp_connection_t * buffer = (btstack_memory_avrcp_connection_t *) avrcp_connection;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) avrcp_connection)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -934,14 +953,14 @@ void btstack_memory_avrcp_browsing_connection_free(avrcp_browsing_connection_t *
#elif defined(HAVE_MALLOC)
typedef struct {
avrcp_browsing_connection_t data;
btstack_memory_buffer_t tracking;
avrcp_browsing_connection_t data;
} btstack_memory_avrcp_browsing_connection_t;
avrcp_browsing_connection_t * btstack_memory_avrcp_browsing_connection_get(void){
btstack_memory_avrcp_browsing_connection_t * buffer = (btstack_memory_avrcp_browsing_connection_t *) malloc(sizeof(btstack_memory_avrcp_browsing_connection_t));
if (buffer){
memset(buffer, 0, sizeof(avrcp_browsing_connection_t));
memset(buffer, 0, sizeof(btstack_memory_avrcp_browsing_connection_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -949,8 +968,9 @@ avrcp_browsing_connection_t * btstack_memory_avrcp_browsing_connection_get(void)
}
}
void btstack_memory_avrcp_browsing_connection_free(avrcp_browsing_connection_t *avrcp_browsing_connection){
btstack_memory_avrcp_browsing_connection_t * buffer = (btstack_memory_avrcp_browsing_connection_t *) avrcp_browsing_connection;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) avrcp_browsing_connection)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -993,14 +1013,14 @@ void btstack_memory_gatt_client_free(gatt_client_t *gatt_client){
#elif defined(HAVE_MALLOC)
typedef struct {
gatt_client_t data;
btstack_memory_buffer_t tracking;
gatt_client_t data;
} btstack_memory_gatt_client_t;
gatt_client_t * btstack_memory_gatt_client_get(void){
btstack_memory_gatt_client_t * buffer = (btstack_memory_gatt_client_t *) malloc(sizeof(btstack_memory_gatt_client_t));
if (buffer){
memset(buffer, 0, sizeof(gatt_client_t));
memset(buffer, 0, sizeof(btstack_memory_gatt_client_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -1008,8 +1028,9 @@ gatt_client_t * btstack_memory_gatt_client_get(void){
}
}
void btstack_memory_gatt_client_free(gatt_client_t *gatt_client){
btstack_memory_gatt_client_t * buffer = (btstack_memory_gatt_client_t *) gatt_client;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) gatt_client)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -1049,14 +1070,14 @@ void btstack_memory_whitelist_entry_free(whitelist_entry_t *whitelist_entry){
#elif defined(HAVE_MALLOC)
typedef struct {
whitelist_entry_t data;
btstack_memory_buffer_t tracking;
whitelist_entry_t data;
} btstack_memory_whitelist_entry_t;
whitelist_entry_t * btstack_memory_whitelist_entry_get(void){
btstack_memory_whitelist_entry_t * buffer = (btstack_memory_whitelist_entry_t *) malloc(sizeof(btstack_memory_whitelist_entry_t));
if (buffer){
memset(buffer, 0, sizeof(whitelist_entry_t));
memset(buffer, 0, sizeof(btstack_memory_whitelist_entry_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -1064,8 +1085,9 @@ whitelist_entry_t * btstack_memory_whitelist_entry_get(void){
}
}
void btstack_memory_whitelist_entry_free(whitelist_entry_t *whitelist_entry){
btstack_memory_whitelist_entry_t * buffer = (btstack_memory_whitelist_entry_t *) whitelist_entry;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) whitelist_entry)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -1105,14 +1127,14 @@ void btstack_memory_sm_lookup_entry_free(sm_lookup_entry_t *sm_lookup_entry){
#elif defined(HAVE_MALLOC)
typedef struct {
sm_lookup_entry_t data;
btstack_memory_buffer_t tracking;
sm_lookup_entry_t data;
} btstack_memory_sm_lookup_entry_t;
sm_lookup_entry_t * btstack_memory_sm_lookup_entry_get(void){
btstack_memory_sm_lookup_entry_t * buffer = (btstack_memory_sm_lookup_entry_t *) malloc(sizeof(btstack_memory_sm_lookup_entry_t));
if (buffer){
memset(buffer, 0, sizeof(sm_lookup_entry_t));
memset(buffer, 0, sizeof(btstack_memory_sm_lookup_entry_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -1120,8 +1142,9 @@ sm_lookup_entry_t * btstack_memory_sm_lookup_entry_get(void){
}
}
void btstack_memory_sm_lookup_entry_free(sm_lookup_entry_t *sm_lookup_entry){
btstack_memory_sm_lookup_entry_t * buffer = (btstack_memory_sm_lookup_entry_t *) sm_lookup_entry;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) sm_lookup_entry)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -1164,14 +1187,14 @@ void btstack_memory_mesh_network_pdu_free(mesh_network_pdu_t *mesh_network_pdu){
#elif defined(HAVE_MALLOC)
typedef struct {
mesh_network_pdu_t data;
btstack_memory_buffer_t tracking;
mesh_network_pdu_t data;
} btstack_memory_mesh_network_pdu_t;
mesh_network_pdu_t * btstack_memory_mesh_network_pdu_get(void){
btstack_memory_mesh_network_pdu_t * buffer = (btstack_memory_mesh_network_pdu_t *) malloc(sizeof(btstack_memory_mesh_network_pdu_t));
if (buffer){
memset(buffer, 0, sizeof(mesh_network_pdu_t));
memset(buffer, 0, sizeof(btstack_memory_mesh_network_pdu_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -1179,8 +1202,9 @@ mesh_network_pdu_t * btstack_memory_mesh_network_pdu_get(void){
}
}
void btstack_memory_mesh_network_pdu_free(mesh_network_pdu_t *mesh_network_pdu){
btstack_memory_mesh_network_pdu_t * buffer = (btstack_memory_mesh_network_pdu_t *) mesh_network_pdu;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) mesh_network_pdu)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -1220,14 +1244,14 @@ void btstack_memory_mesh_segmented_pdu_free(mesh_segmented_pdu_t *mesh_segmented
#elif defined(HAVE_MALLOC)
typedef struct {
mesh_segmented_pdu_t data;
btstack_memory_buffer_t tracking;
mesh_segmented_pdu_t data;
} btstack_memory_mesh_segmented_pdu_t;
mesh_segmented_pdu_t * btstack_memory_mesh_segmented_pdu_get(void){
btstack_memory_mesh_segmented_pdu_t * buffer = (btstack_memory_mesh_segmented_pdu_t *) malloc(sizeof(btstack_memory_mesh_segmented_pdu_t));
if (buffer){
memset(buffer, 0, sizeof(mesh_segmented_pdu_t));
memset(buffer, 0, sizeof(btstack_memory_mesh_segmented_pdu_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -1235,8 +1259,9 @@ mesh_segmented_pdu_t * btstack_memory_mesh_segmented_pdu_get(void){
}
}
void btstack_memory_mesh_segmented_pdu_free(mesh_segmented_pdu_t *mesh_segmented_pdu){
btstack_memory_mesh_segmented_pdu_t * buffer = (btstack_memory_mesh_segmented_pdu_t *) mesh_segmented_pdu;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) mesh_segmented_pdu)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -1276,14 +1301,14 @@ void btstack_memory_mesh_upper_transport_pdu_free(mesh_upper_transport_pdu_t *me
#elif defined(HAVE_MALLOC)
typedef struct {
mesh_upper_transport_pdu_t data;
btstack_memory_buffer_t tracking;
mesh_upper_transport_pdu_t data;
} btstack_memory_mesh_upper_transport_pdu_t;
mesh_upper_transport_pdu_t * btstack_memory_mesh_upper_transport_pdu_get(void){
btstack_memory_mesh_upper_transport_pdu_t * buffer = (btstack_memory_mesh_upper_transport_pdu_t *) malloc(sizeof(btstack_memory_mesh_upper_transport_pdu_t));
if (buffer){
memset(buffer, 0, sizeof(mesh_upper_transport_pdu_t));
memset(buffer, 0, sizeof(btstack_memory_mesh_upper_transport_pdu_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -1291,8 +1316,9 @@ mesh_upper_transport_pdu_t * btstack_memory_mesh_upper_transport_pdu_get(void){
}
}
void btstack_memory_mesh_upper_transport_pdu_free(mesh_upper_transport_pdu_t *mesh_upper_transport_pdu){
btstack_memory_mesh_upper_transport_pdu_t * buffer = (btstack_memory_mesh_upper_transport_pdu_t *) mesh_upper_transport_pdu;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) mesh_upper_transport_pdu)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -1332,14 +1358,14 @@ void btstack_memory_mesh_network_key_free(mesh_network_key_t *mesh_network_key){
#elif defined(HAVE_MALLOC)
typedef struct {
mesh_network_key_t data;
btstack_memory_buffer_t tracking;
mesh_network_key_t data;
} btstack_memory_mesh_network_key_t;
mesh_network_key_t * btstack_memory_mesh_network_key_get(void){
btstack_memory_mesh_network_key_t * buffer = (btstack_memory_mesh_network_key_t *) malloc(sizeof(btstack_memory_mesh_network_key_t));
if (buffer){
memset(buffer, 0, sizeof(mesh_network_key_t));
memset(buffer, 0, sizeof(btstack_memory_mesh_network_key_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -1347,8 +1373,9 @@ mesh_network_key_t * btstack_memory_mesh_network_key_get(void){
}
}
void btstack_memory_mesh_network_key_free(mesh_network_key_t *mesh_network_key){
btstack_memory_mesh_network_key_t * buffer = (btstack_memory_mesh_network_key_t *) mesh_network_key;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) mesh_network_key)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -1388,14 +1415,14 @@ void btstack_memory_mesh_transport_key_free(mesh_transport_key_t *mesh_transport
#elif defined(HAVE_MALLOC)
typedef struct {
mesh_transport_key_t data;
btstack_memory_buffer_t tracking;
mesh_transport_key_t data;
} btstack_memory_mesh_transport_key_t;
mesh_transport_key_t * btstack_memory_mesh_transport_key_get(void){
btstack_memory_mesh_transport_key_t * buffer = (btstack_memory_mesh_transport_key_t *) malloc(sizeof(btstack_memory_mesh_transport_key_t));
if (buffer){
memset(buffer, 0, sizeof(mesh_transport_key_t));
memset(buffer, 0, sizeof(btstack_memory_mesh_transport_key_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -1403,8 +1430,9 @@ mesh_transport_key_t * btstack_memory_mesh_transport_key_get(void){
}
}
void btstack_memory_mesh_transport_key_free(mesh_transport_key_t *mesh_transport_key){
btstack_memory_mesh_transport_key_t * buffer = (btstack_memory_mesh_transport_key_t *) mesh_transport_key;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) mesh_transport_key)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -1444,14 +1472,14 @@ void btstack_memory_mesh_virtual_address_free(mesh_virtual_address_t *mesh_virtu
#elif defined(HAVE_MALLOC)
typedef struct {
mesh_virtual_address_t data;
btstack_memory_buffer_t tracking;
mesh_virtual_address_t data;
} btstack_memory_mesh_virtual_address_t;
mesh_virtual_address_t * btstack_memory_mesh_virtual_address_get(void){
btstack_memory_mesh_virtual_address_t * buffer = (btstack_memory_mesh_virtual_address_t *) malloc(sizeof(btstack_memory_mesh_virtual_address_t));
if (buffer){
memset(buffer, 0, sizeof(mesh_virtual_address_t));
memset(buffer, 0, sizeof(btstack_memory_mesh_virtual_address_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -1459,8 +1487,9 @@ mesh_virtual_address_t * btstack_memory_mesh_virtual_address_get(void){
}
}
void btstack_memory_mesh_virtual_address_free(mesh_virtual_address_t *mesh_virtual_address){
btstack_memory_mesh_virtual_address_t * buffer = (btstack_memory_mesh_virtual_address_t *) mesh_virtual_address;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) mesh_virtual_address)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
@ -1500,14 +1529,14 @@ void btstack_memory_mesh_subnet_free(mesh_subnet_t *mesh_subnet){
#elif defined(HAVE_MALLOC)
typedef struct {
mesh_subnet_t data;
btstack_memory_buffer_t tracking;
mesh_subnet_t data;
} btstack_memory_mesh_subnet_t;
mesh_subnet_t * btstack_memory_mesh_subnet_get(void){
btstack_memory_mesh_subnet_t * buffer = (btstack_memory_mesh_subnet_t *) malloc(sizeof(btstack_memory_mesh_subnet_t));
if (buffer){
memset(buffer, 0, sizeof(mesh_subnet_t));
memset(buffer, 0, sizeof(btstack_memory_mesh_subnet_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -1515,16 +1544,23 @@ mesh_subnet_t * btstack_memory_mesh_subnet_get(void){
}
}
void btstack_memory_mesh_subnet_free(mesh_subnet_t *mesh_subnet){
btstack_memory_mesh_subnet_t * buffer = (btstack_memory_mesh_subnet_t *) mesh_subnet;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) mesh_subnet)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
#endif
// init
void btstack_memory_init(void){
#ifdef HAVE_MALLOC
// assert that there is no unexpected padding for combined buffer
btstack_assert(sizeof(test_buffer_t) == sizeof(btstack_memory_buffer_t) + sizeof(void *));
#endif
#if MAX_NR_HCI_CONNECTIONS > 0
btstack_memory_pool_create(&hci_connection_pool, hci_connection_storage, MAX_NR_HCI_CONNECTIONS, sizeof(hci_connection_t));
#endif

27
tool/btstack_memory_generator.py
View File

@ -138,6 +138,11 @@ typedef struct btstack_memory_buffer {
struct btstack_memory_buffer * prev;
} btstack_memory_buffer_t;
typedef struct {
btstack_memory_buffer_t tracking;
void * pointer;
} test_buffer_t;
static btstack_memory_buffer_t * btstack_memory_malloc_buffers;
static uint32_t btstack_memory_malloc_counter;
@ -220,14 +225,14 @@ void btstack_memory_STRUCT_NAME_free(STRUCT_NAME_t *STRUCT_NAME){
#elif defined(HAVE_MALLOC)
typedef struct {
STRUCT_NAME_t data;
btstack_memory_buffer_t tracking;
STRUCT_NAME_t data;
} btstack_memory_STRUCT_NAME_t;
STRUCT_NAME_t * btstack_memory_STRUCT_NAME_get(void){
btstack_memory_STRUCT_NAME_t * buffer = (btstack_memory_STRUCT_NAME_t *) malloc(sizeof(btstack_memory_STRUCT_NAME_t));
if (buffer){
memset(buffer, 0, sizeof(STRUCT_NAME_t));
memset(buffer, 0, sizeof(btstack_memory_STRUCT_NAME_t));
btstack_memory_tracking_add(&buffer->tracking);
return &buffer->data;
} else {
@ -235,12 +240,22 @@ STRUCT_NAME_t * btstack_memory_STRUCT_NAME_get(void){
}
}
void btstack_memory_STRUCT_NAME_free(STRUCT_NAME_t *STRUCT_NAME){
btstack_memory_STRUCT_NAME_t * buffer = (btstack_memory_STRUCT_NAME_t *) STRUCT_NAME;
btstack_memory_tracking_remove(&buffer->tracking);
// reconstruct buffer start
btstack_memory_buffer_t * buffer = &((btstack_memory_buffer_t *) STRUCT_NAME)[-1];
btstack_memory_tracking_remove(buffer);
free(buffer);
}
#endif
"""
init_header = '''
// init
void btstack_memory_init(void){
#ifdef HAVE_MALLOC
// assert that there is no unexpected padding for combined buffer
btstack_assert(sizeof(test_buffer_t) == sizeof(btstack_memory_buffer_t) + sizeof(void *));
#endif
'''
init_template = """#if POOL_COUNT > 0
btstack_memory_pool_create(&STRUCT_NAME_pool, STRUCT_NAME_storage, POOL_COUNT, sizeof(STRUCT_TYPE));
@ -342,9 +357,7 @@ for struct_names in list_of_mesh_structs:
writeln(f, "")
writeln(f, "#endif")
writeln(f, "// init")
writeln(f, "void btstack_memory_init(void){")
f.write(init_header)
for struct_names in list_of_structs:
for struct_name in struct_names:
writeln(f, replacePlaceholder(init_template, struct_name))