kenmirrors/asterisk
1
0
Fork 0
mirror of https://github.com/asterisk/asterisk.git synced 2025-09-04 20:04:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove the test_for_thread_safety() function completely.

Browse Source 
The test is not valid.  Besides, if we actually suspected that recursive
mutexes were not working, we would get a ton of LOG_ERROR messages when
DEBUG_THREADS is turned on.

(inspired by a discussion on the asterisk-dev list)


git-svn-id: https://origsvn.digium.com/svn/asterisk/branches/1.4@162413 65c4cc65-6c06-0410-ace0-fbb531ad65f3
This commit is contained in:
Russell Bryant
2008-12-09 22:17:39 +00:00
parent 5134bb74a9
commit c2446000d9
3 changed files with 0 additions and 68 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
include/asterisk/utils.h
View File

@@ -219,8 +219,6 @@ static force_inline void ast_slinear_saturated_divide(short *input, short *value
*input /= *value;
}
int test_for_thread_safety(void);
/*!
* \brief thread-safe replacement for inet_ntoa().
*

4
main/asterisk.c
View File

@@ -2981,10 +2981,6 @@ int main(int argc, char *argv[])
}
#endif
/* Test recursive mutex locking. */
if (test_for_thread_safety())
ast_verbose("Warning! Asterisk is not thread safe.\n");
ast_makesocket();
sigemptyset(&sigs);
sigaddset(&sigs, SIGHUP);

62
main/utils.c
View File

@@ -228,68 +228,6 @@ struct hostent *ast_gethostbyname(const char *host, struct ast_hostent *hp)
return &hp->hp;
}
AST_MUTEX_DEFINE_STATIC(test_lock);
AST_MUTEX_DEFINE_STATIC(test_lock2);
static pthread_t test_thread;
static int lock_count = 0;
static int test_errors = 0;
/*! \brief This is a regression test for recursive mutexes.
test_for_thread_safety() will return 0 if recursive mutex locks are
working properly, and non-zero if they are not working properly. */
static void *test_thread_body(void *data)
{
ast_mutex_lock(&test_lock);
lock_count += 10;
if (lock_count != 10)
test_errors++;
ast_mutex_lock(&test_lock);
lock_count += 10;
if (lock_count != 20)
test_errors++;
ast_mutex_lock(&test_lock2);
ast_mutex_unlock(&test_lock);
lock_count -= 10;
if (lock_count != 10)
test_errors++;
ast_mutex_unlock(&test_lock);
lock_count -= 10;
ast_mutex_unlock(&test_lock2);
if (lock_count != 0)
test_errors++;
return NULL;
}
int test_for_thread_safety(void)
{
ast_mutex_lock(&test_lock2);
ast_mutex_lock(&test_lock);
lock_count += 1;
ast_mutex_lock(&test_lock);
lock_count += 1;
ast_pthread_create(&test_thread, NULL, test_thread_body, NULL);
usleep(100);
if (lock_count != 2)
test_errors++;
ast_mutex_unlock(&test_lock);
lock_count -= 1;
usleep(100);
if (lock_count != 1)
test_errors++;
ast_mutex_unlock(&test_lock);
lock_count -= 1;
if (lock_count != 0)
test_errors++;
ast_mutex_unlock(&test_lock2);
usleep(100);
if (lock_count != 0)
test_errors++;
pthread_join(test_thread, NULL);
return(test_errors); /* return 0 on success. */
}
/*! \brief Produce 32 char MD5 hash of value. */
void ast_md5_hash(char *output, char *input)
{