Hello freeswitch-users, there is some doubt about memory leak in freeswitch implemetation. when a channel is created, some mutex are created as below. SWITCH_DECLARE(switch_status_t) switch_channel_alloc(switch_channel_t **channel, switch_call_direction_t direction, switch_memory_pool_t *pool) { switch_assert(pool != NULL); if (((*channel) = switch_core_alloc(pool, sizeof(switch_channel_t))) == 0) { return SWITCH_STATUS_MEMERR; } switch_event_create_plain(&(*channel)->variables, SWITCH_EVENT_CHANNEL_DATA); switch_core_hash_init(&(*channel)->private_hash, pool); switch_queue_create(&(*channel)->dtmf_queue, SWITCH_DTMF_LOG_LEN, pool); switch_queue_create(&(*channel)->dtmf_log_queue, SWITCH_DTMF_LOG_LEN, pool); switch_mutex_init(&(*channel)->dtmf_mutex, SWITCH_MUTEX_NESTED, pool); switch_mutex_init(&(*channel)->flag_mutex, SWITCH_MUTEX_NESTED, pool); switch_mutex_init(&(*channel)->state_mutex, SWITCH_MUTEX_NESTED, pool); switch_mutex_init(&(*channel)->thread_mutex, SWITCH_MUTEX_NESTED, pool); switch_mutex_init(&(*channel)->profile_mutex, SWITCH_MUTEX_NESTED, pool); ... } And, It seems that some memory is newly allocated in switch_mutex_init() by comments in the following code. [ switch_apr.h ] /** * Create and initialize a mutex that can be used to synchronize threads. * @param lock the memory address where the newly created mutex will be * stored. * @param flags Or'ed value of: * <PRE> * SWITCH_THREAD_MUTEX_DEFAULT platform-optimal lock behavior. * SWITCH_THREAD_MUTEX_NESTED enable nested (recursive) locks. * SWITCH_THREAD_MUTEX_UNNESTED disable nested locks (non-recursive). * </PRE> * @param pool the pool from which to allocate the mutex. * @warning Be cautious in using SWITCH_THREAD_MUTEX_DEFAULT. While this is the * most optimial mutex based on a given platform's performance charateristics, * it will behave as either a nested or an unnested lock. * */ SWITCH_DECLARE(switch_status_t) switch_mutex_init(switch_mutex_t ** lock, unsigned int flags, switch_memory_pool_t *pool); /** * Destroy the mutex and free the memory associated with the lock. * @param lock the mutex to destroy. */ SWITCH_DECLARE(switch_status_t) switch_mutex_destroy(switch_mutex_t *lock); but, I can't find any code that is related with destroying mutex. In my opinion, altough a memory size is very tiny for creating mutex, the leaking memory will be more bigger as times go on. It doesn't need to destory the mutex when a channel is destory? could someone explain about this? Thank you in advance. Regards, hkchoi