void
thread_shutdown ()
{
/* Make secondary threads exit wait() */
global_doShutdown = TRUE;
THREAD_BARRIER(global_barrierPtr, 0);
long numThread = global_numThread;
long i;
for (i = 1; i < numThread; i++) {
THREAD_JOIN(global_threads[i]);
}
global_numThread = 1;
THREAD_BARRIER_FREE(global_barrierPtr);
global_barrierPtr = NULL;
free(global_threadIds);
global_threadIds = NULL;
free(global_threads);
global_threads = NULL;
}
int main(int argc, char ** argv) {
shared_queue_t q;
shared_queue_init(&q, N, sizeof(int));
THREAD_T enqueue_thread;
THREAD_T dequeue_thread;
THREAD_INIT(enqueue_thread, enqueue_thread_main, &q);
THREAD_INIT(dequeue_thread, dequeue_thread_main, &q);
THREAD_JOIN(enqueue_thread);
THREAD_JOIN(dequeue_thread);
shared_queue_destroy(&q);
return 0;
}
static void teardown(void) {
running = false;
THREAD_JOIN(server_thread);
UA_Server_run_shutdown(server);
UA_Server_delete(server);
UA_ServerConfig_delete(config);
}
static void teardown_register(void) {
*running_register = false;
THREAD_JOIN(server_thread_register);
UA_Server_run_shutdown(server_register);
UA_Boolean_delete(running_register);
UA_Server_delete(server_register);
}
TSS_RESULT
tcsd_threads_final()
{
int rc;
UINT32 i;
MUTEX_LOCK(tm->lock);
tm->shutdown = 1;
MUTEX_UNLOCK(tm->lock);
/* wait for all currently running threads to exit */
for (i = 0; i < tm->max_threads; i++) {
if (tm->thread_data[i].thread_id != THREAD_NULL) {
if ((rc = THREAD_JOIN(*(tm->thread_data[i].thread_id), NULL))) {
LogError("Thread join failed: error: %d", rc);
}
}
}
free(tm->thread_data);
free(tm);
return TSS_SUCCESS;
}
static void teardown_lds(void) {
*running_lds = false;
THREAD_JOIN(server_thread_lds);
UA_Server_run_shutdown(server_lds);
UA_Boolean_delete(running_lds);
UA_Server_delete(server_lds);
}
/**
* Finalizes processes structures for threads
*/
void process_deinit() {
int iter;
abort_processes = TRUE;
for (iter = 0; iter < MAX_PROCESSES; iter++) {
if (processes[iter].is_active == TRUE) {
SOCKET_SHUTDOWN(&(processes[iter].proc_data->connection));
// Waits for the thread to end and then destroys it
THREAD_JOIN(processes[iter].work, TRUE);
free(processes[iter].work);
processes[iter].is_active = FALSE;
SOCKET_CLOSE(&(processes[iter].proc_data->connection));
free(processes[iter].proc_data);
}
}
}
/*---------------------------------------------------------------------*/
BOOL ArchiveClose(H_ARCHIVE harchive)
{
NODE *node;
STREAM *stream;
if (!ValidateHandle(harchive))
return (FALSE);
_archive[harchive].last_error = ARC_NO_ERROR;
_archive_error = ARC_NO_ERROR;
ArchiveLog(ARC_LOG_VERBOSE, "Close archive: %s", _archive[harchive].path);
/* Close all open event files on archive... */
if ((node = FirstNode(&_archive[harchive].streams))) {
do {
stream = (STREAM *) node->data;
if (_archive[harchive].access == ARC_WRITE)
CloseEventFileAndRename(harchive, stream);
else
CloseEventFile(stream);
} while ((node = NextNode(node)) != NULL);
}
/* If open for write... */
if (_archive[harchive].access == ARC_WRITE) {
MUTEX_LOCK(&_archive[harchive].purge.mutex);
if(_archive[harchive].purge.active ) {
_archive[harchive].purge.stop = TRUE;
MUTEX_UNLOCK(&_archive[harchive].purge.mutex);
ArchiveLog(ARC_LOG_VERBOSE, "Stopping purge thread");
SEM_POST(&_archive[harchive].purge.semaphore);
THREAD_JOIN(&_archive[harchive].purge.thread_id);
}
else
MUTEX_UNLOCK(&_archive[harchive].purge.mutex);
/* Mark as closed and write state to disk */
_archive[harchive].state.write = FALSE;
if (!WriteState(harchive))
return (FALSE);
}
/* Close the state file */
if (!FileClose(_archive[harchive].file)) {
_archive[harchive].last_error = ARC_FILE_IO_ERROR;
return (FALSE);
}
_n_archives--;
/* Clear state */
MUTEX_DESTROY(&_archive[harchive].mutex);
DestroyList(&_archive[harchive].streams);
DestroyPurge(&_archive[harchive].purge);
InitArchive(harchive);
return (TRUE);
}
static void
thread_deferred_cb_skew(void *arg)
{
struct basic_test_data *data = arg;
struct timeval tv_timer = {4, 0};
struct deferred_cb_queue *queue;
time_t elapsed;
int i;
queue = event_base_get_deferred_cb_queue(data->base);
tt_assert(queue);
for (i = 0; i < QUEUE_THREAD_COUNT; ++i)
deferred_data[i].queue = queue;
timer_start = time(NULL);
event_base_once(data->base, -1, EV_TIMEOUT, timer_callback, NULL,
&tv_timer);
event_base_once(data->base, -1, EV_TIMEOUT, start_threads_callback,
NULL, NULL);
event_base_dispatch(data->base);
elapsed = timer_end - timer_start;
TT_BLATHER(("callback count, %u", callback_count));
TT_BLATHER(("elapsed time, %u", (unsigned)elapsed));
/* XXX be more intelligent here. just make sure skew is
* within 2 seconds for now. */
tt_assert(elapsed >= 4 && elapsed <= 6);
end:
for (i = 0; i < QUEUE_THREAD_COUNT; ++i)
THREAD_JOIN(load_threads[i]);
}
~Client()
{
destroy();
#ifdef CB_THREAD
THREAD_JOIN(tid);
#endif
callback.destroy();
}
void TEngine::StopRendering()
{
FRenderer->SetRendering(false);
THREAD_JOIN(FTRenderingThread, FThreadData, NULL);
FRenderer->DestroyRenderWindow();
ENGINE_INFO("Rendering stoped");
FRenderingRunning = false;
}
void TEngine::PauseRendering()
{
FRenderer->SetRendering(false);
THREAD_JOIN(FTRenderingThread, FThreadData,NULL);
FRenderer->HideRenderWindow();
ENGINE_INFO("Rendering paused");
}
// the destructor isn't thread safe wrt to the accessor functions
Trace::~Trace() {
is_running_ = false;
THREAD_JOIN(thread);
// mutex lock isn't required now that the thread stopped
#ifdef _WIN32
CloseHandle(fd_);
#else
munmap((void*)backing_, backing_size_);
close(fd_);
#endif
//printf("dead\n");
}
static void teardown(void) {
removeSubscription();
*running = false;
THREAD_JOIN(server_thread);
UA_Server_run_shutdown(server);
UA_Boolean_delete(running);
UA_Server_delete(server);
UA_ServerConfig_delete(config);
UA_Array_delete(selectClauses, nSelectClauses, &UA_TYPES[UA_TYPES_SIMPLEATTRIBUTEOPERAND]);
UA_Client_disconnect(client);
UA_Client_delete(client);
}
boolean extract_emergency_phr(char *phr_download_to_path, void (*backend_alert_msg_callback_handler_ptr)(char *alert_msg))
{
// Setup a callback handler
backend_alert_msg_callback_handler = backend_alert_msg_callback_handler_ptr;
// Passing variable
ptr_phr_download_to_path = &phr_download_to_path;
init_main();
// Create an emergency PHR extraction thread
if(THREAD_CREATE(emergency_phr_extraction_thread_id, extract_emergency_phr_main, NULL) != 0)
int_error("Creating a thread for \"extract_emergency_phr_main\" failed");
while(1)
{
if(sem_wait(&wake_up_main_thread_mutex) != 0)
int_error("Locking the mutex failed");
// The emergency PHR extraction thread terminated
if(emergency_phr_extraction_thread_terminated_flag)
break;
// Send an error message to frontend
if(strlen(err_msg_to_frontend) > 0)
{
backend_alert_msg_handler_callback(err_msg_to_frontend);
strcpy(err_msg_to_frontend, "");
if(sem_post(&confirm_err_msg_sending_to_frontend_mutex) != 0)
int_error("Unlocking the mutex failed");
}
}
// Join the emergency PHR extraction thread
if(THREAD_JOIN(emergency_phr_extraction_thread_id) != 0)
int_error("Joining a thread \"extract_emergency_phr_main\" failed");
// Send signal to confirm that the emergency PHR extraction thread has been terminated if the action was performed by a cancellation thread
if(emergency_phr_extracting_cancellation_flag)
{
if(sem_post(&send_signal_to_confirm_cancellation_thread_mutex) != 0)
int_error("Unlocking the mutex failed");
if(sem_wait(&cancellation_thread_got_confirmation_mutex) != 0)
int_error("Locking the mutex failed");
}
uninit_main();
return transaction_success_status_flag;
}
static inline void _fast_mtq_stop(fast_mtq f_mtq, int type)
{
int i;
void *ret;
log_debug("Fast mtq. Stop all threads %d", type);
f_mtq->shutdown = type;
COND_BROADCAST(f_mtq->cond);
for (i = 0; i < f_mtq->threads; i++) {
THREAD_JOIN(f_mtq->threads_table[i], ret);
}
}
void* findDongleThread(void* arg)
{
static int args[MAX_COMPORT];
int i;
THREAD_T threads[MAX_COMPORT];
for(i = 0; i < MAX_COMPORT; i++) {
args[i] = i;
}
g_dongleSearchStatus = DONGLE_SEARCHING;
/* Spawn worker threads to find the dongle on a com port */
for(i = 0; i < MAX_COMPORT; i++) {
/* First, make sure there are less than MAX_THREADS running */
MUTEX_LOCK(&g_giant_lock);
while(
(g_numThreads >= MAX_THREADS) &&
(g_dongleSearchStatus == DONGLE_SEARCHING)
)
{
COND_WAIT(&g_giant_cond, &g_giant_lock);
}
if(g_dongleSearchStatus != DONGLE_SEARCHING) {
i++;
MUTEX_UNLOCK(&g_giant_lock);
break;
}
/* Spawn a thread */
THREAD_CREATE(&threads[i], findDongleWorkerThread, &args[i]);
g_numThreads++;
MUTEX_UNLOCK(&g_giant_lock);
}
/* Join all threads */
int j;
for(j = 0; j < i; j++) {
MUTEX_LOCK(&g_giant_lock);
if(g_dongleSearchStatus != DONGLE_SEARCHING) {
MUTEX_UNLOCK(&g_giant_lock);
break;
}
MUTEX_UNLOCK(&g_giant_lock);
THREAD_JOIN(threads[j]);
}
MUTEX_LOCK(&g_giant_lock);
if(g_dongleSearchStatus == DONGLE_SEARCHING) {
g_dongleSearchStatus = DONGLE_NOTFOUND;
}
MUTEX_UNLOCK(&g_giant_lock);
return NULL;
}
void on_button_p1_next_clicked(GtkWidget* widget, gpointer data)
{
/* First, disable the widget so it cannot be clicked again */
gtk_widget_set_sensitive(widget, false);
/* Make sure thread is joined */
THREAD_JOIN(g_mainSearchThread);
/* Reset state vars */
g_dongleSearchStatus = DONGLE_SEARCHING;
/* Start the main search thread */
THREAD_CREATE(&g_mainSearchThread, findDongleThread, NULL);
/* Start the search timeout */
g_timeout_add(200, findDongleTimeout, NULL);
}
static void
thread_deferred_cb_skew(void *arg)
{
struct timeval tv_timer = {1, 0};
struct event_base *base = NULL;
struct event_config *cfg = NULL;
struct timeval elapsed;
int elapsed_usec;
int i;
cfg = event_config_new();
tt_assert(cfg);
event_config_set_max_dispatch_interval(cfg, NULL, 16, 0);
base = event_base_new_with_config(cfg);
tt_assert(base);
for (i = 0; i < QUEUE_THREAD_COUNT; ++i)
deferred_data[i].queue = base;
evutil_gettimeofday(&timer_start, NULL);
event_base_once(base, -1, EV_TIMEOUT, timer_callback, NULL,
&tv_timer);
event_base_once(base, -1, EV_TIMEOUT, start_threads_callback,
NULL, NULL);
event_base_dispatch(base);
evutil_timersub(&timer_end, &timer_start, &elapsed);
TT_BLATHER(("callback count, %u", callback_count));
elapsed_usec =
(unsigned)(elapsed.tv_sec*1000000 + elapsed.tv_usec);
TT_BLATHER(("elapsed time, %u usec", elapsed_usec));
/* XXX be more intelligent here. just make sure skew is
* within .4 seconds for now. */
tt_assert(elapsed_usec >= 600000 && elapsed_usec <= 1400000);
end:
for (i = 0; i < QUEUE_THREAD_COUNT; ++i)
THREAD_JOIN(load_threads[i]);
if (base)
event_base_free(base);
if (cfg)
event_config_free(cfg);
}
void openavbAcmpSMControllerStop()
{
AVB_TRACE_ENTRY(AVB_TRACE_ACMP);
if (bRunning) {
openavbAcmpSMControllerSet_doTerminate(TRUE);
THREAD_JOIN(openavbAcmpSmControllerThread, NULL);
}
SEM_ERR_T(err);
SEM_DESTROY(openavbAcmpSMControllerSemaphore, err);
SEM_LOG_ERR(err);
openavbListDeleteList(openavbAcmpSMControllerVars.inflight);
AVB_TRACE_EXIT(AVB_TRACE_ACMP);
}
static int
k4w2_v4l2_stop(k4w2_t ctx)
{
k4w2_v4l2 * v4l2 = (k4w2_v4l2 *)ctx;
CHANNEL ch;
if (0== v4l2->thread)
return K4W2_ERROR;
v4l2->shutdown = 1;
THREAD_JOIN(v4l2->thread);
v4l2->thread = 0;
for (ch = ctx->begin; ch <= ctx->end; ++ch) {
stop_camera(&v4l2->cam[ch]);
}
return K4W2_SUCCESS;
}
void
httpd_stop(httpd_t *httpd)
{
assert(httpd);
MUTEX_LOCK(httpd->run_mutex);
if (!httpd->running || httpd->joined) {
MUTEX_UNLOCK(httpd->run_mutex);
return;
}
httpd->running = 0;
MUTEX_UNLOCK(httpd->run_mutex);
THREAD_JOIN(httpd->thread);
MUTEX_LOCK(httpd->run_mutex);
httpd->joined = 1;
MUTEX_UNLOCK(httpd->run_mutex);
}
static void teardown(void) {
/* cleanup */
UA_Client_disconnect(client);
UA_Client_delete(client);
running = false;
THREAD_JOIN(server_thread);
UA_NodeId_deleteMembers(&parentNodeId);
UA_NodeId_deleteMembers(&parentReferenceNodeId);
UA_NodeId_deleteMembers(&outNodeId);
UA_Server_run_shutdown(server);
UA_Server_delete(server);
#ifdef UA_ENABLE_HISTORIZING
UA_free(gathering);
#endif
if (!MUTEX_DESTROY(serverMutex)) {
fprintf(stderr, "Server mutex was not destroyed correctly.\n");
exit(1);
}
}
static void
thread_no_events(void *arg)
{
THREAD_T thread;
struct basic_test_data *data = arg;
struct timeval starttime, endtime;
int i;
exit_base = data->base;
memset(times,0,sizeof(times));
for (i=0;i<5;++i) {
event_assign(&time_events[i], data->base,
-1, 0, note_time_cb, ×[i]);
}
evutil_gettimeofday(&starttime, NULL);
THREAD_START(thread, register_events_subthread, data->base);
event_base_loop(data->base, EVLOOP_NO_EXIT_ON_EMPTY);
evutil_gettimeofday(&endtime, NULL);
tt_assert(event_base_got_break(data->base));
THREAD_JOIN(thread);
for (i=0; i<5; ++i) {
struct timeval diff;
double sec;
evutil_timersub(×[i], &starttime, &diff);
sec = diff.tv_sec + diff.tv_usec/1.0e6;
TT_BLATHER(("event %d at %.4f seconds", i, sec));
}
test_timeval_diff_eq(&starttime, ×[0], 100);
test_timeval_diff_eq(&starttime, ×[1], 200);
test_timeval_diff_eq(&starttime, ×[2], 400);
test_timeval_diff_eq(&starttime, ×[3], 450);
test_timeval_diff_eq(&starttime, ×[4], 500);
test_timeval_diff_eq(&starttime, &endtime, 500);
end:
;
}
extern DLL_EXPORT bool openavbTLStop(tl_handle_t handle)
{
AVB_TRACE_ENTRY(AVB_TRACE_TL);
tl_state_t *pTLState = (tl_state_t *)handle;
if (!pTLState) {
AVB_LOG_ERROR("Invalid handle.");
AVB_TRACE_EXIT(AVB_TRACE_TL);
return FALSE;
}
if (pTLState->bRunning) {
// don't set bStreaming to false here, that's needed to track
// that the streaming thread is running, so we can shut it down.
//pTLState->bStreaming = FALSE;
pTLState->bRunning = FALSE;
THREAD_JOIN(pTLState->TLThread, NULL);
}
AVB_TRACE_EXIT(AVB_TRACE_TL);
return TRUE;
}
int main(int argc, char ** argv) {
if (argc != 2) {
printf("usage: %s <number_of_philosopher>\n", argv[0]);
return 0;
}
srand(time(NULL));
int n = (int) strtol(argv[1], (char **)NULL, 10);
MUTEX_T* chopsticks = (MUTEX_T*) malloc(n * sizeof(MUTEX_T));
THREAD_T* philosophers = (THREAD_T*) malloc(n * sizeof(THREAD_T));
for (int i = 0; i < n; i++) {
MUTEX_INIT(chopsticks[i]);
}
for (int i = 0; i < n; i++) {
context_t* ctx = (context_t*) malloc(sizeof(context_t));
ctx->id = i;
ctx->left_chopstick = &chopsticks[i];
ctx->right_chopstick = &chopsticks[(i+1) % n];
THREAD_INIT(philosophers[i], print_hello, ctx);
}
for (int i = 0; i < n; i++) {
THREAD_JOIN(philosophers[i]);
THREAD_DESTROY(philosophers[i]);
}
for (int i = 0; i < n; i++) {
MUTEX_DESTROY(chopsticks[i]);
}
return 0;
}
static void
thread_conditions_simple(void *arg)
{
struct timeval tv_signal, tv_timeout, tv_broadcast;
struct alerted_record alerted[NUM_THREADS];
THREAD_T threads[NUM_THREADS];
struct cond_wait cond;
int i;
struct timeval launched_at;
struct event wake_one;
struct event wake_all;
struct basic_test_data *data = arg;
struct event_base *base = data->base;
int n_timed_out=0, n_signal=0, n_broadcast=0;
tv_signal.tv_sec = tv_timeout.tv_sec = tv_broadcast.tv_sec = 0;
tv_signal.tv_usec = 30*1000;
tv_timeout.tv_usec = 150*1000;
tv_broadcast.tv_usec = 500*1000;
EVTHREAD_ALLOC_LOCK(cond.lock, EVTHREAD_LOCKTYPE_RECURSIVE);
EVTHREAD_ALLOC_COND(cond.cond);
tt_assert(cond.lock);
tt_assert(cond.cond);
for (i = 0; i < NUM_THREADS; ++i) {
memset(&alerted[i], 0, sizeof(struct alerted_record));
alerted[i].cond = &cond;
}
/* Threads 5 and 6 will be allowed to time out */
memcpy(&alerted[5].delay, &tv_timeout, sizeof(tv_timeout));
memcpy(&alerted[6].delay, &tv_timeout, sizeof(tv_timeout));
evtimer_assign(&wake_one, base, wake_one_timeout, &cond);
evtimer_assign(&wake_all, base, wake_all_timeout, &cond);
evutil_gettimeofday(&launched_at, NULL);
/* Launch the threads... */
for (i = 0; i < NUM_THREADS; ++i) {
THREAD_START(threads[i], wait_for_condition, &alerted[i]);
}
/* Start the timers... */
tt_int_op(event_add(&wake_one, &tv_signal), ==, 0);
tt_int_op(event_add(&wake_all, &tv_broadcast), ==, 0);
/* And run for a bit... */
event_base_dispatch(base);
/* And wait till the threads are done. */
for (i = 0; i < NUM_THREADS; ++i)
THREAD_JOIN(threads[i]);
/* Now, let's see what happened. At least one of 5 or 6 should
* have timed out. */
n_timed_out = alerted[5].timed_out + alerted[6].timed_out;
tt_int_op(n_timed_out, >=, 1);
tt_int_op(n_timed_out, <=, 2);
for (i = 0; i < NUM_THREADS; ++i) {
const struct timeval *target_delay;
struct timeval target_time, actual_delay;
if (alerted[i].timed_out) {
TT_BLATHER(("%d looks like a timeout\n", i));
target_delay = &tv_timeout;
tt_assert(i == 5 || i == 6);
} else if (evutil_timerisset(&alerted[i].alerted_at)) {
long diff1,diff2;
evutil_timersub(&alerted[i].alerted_at,
&launched_at, &actual_delay);
diff1 = timeval_msec_diff(&actual_delay,
&tv_signal);
diff2 = timeval_msec_diff(&actual_delay,
&tv_broadcast);
if (abs(diff1) < abs(diff2)) {
TT_BLATHER(("%d looks like a signal\n", i));
target_delay = &tv_signal;
++n_signal;
} else {
TT_BLATHER(("%d looks like a broadcast\n", i));
target_delay = &tv_broadcast;
++n_broadcast;
}
} else {
TT_FAIL(("Thread %d never got woken", i));
continue;
}
evutil_timeradd(target_delay, &launched_at, &target_time);
test_timeval_diff_leq(&target_time, &alerted[i].alerted_at,
0, 50);
}
tt_int_op(n_broadcast + n_signal + n_timed_out, ==, NUM_THREADS);
tt_int_op(n_signal, ==, 1);
end:
;
}
boolean download_emergency_phr(char *target_emergency_server_ip_addr, char *phr_owner_name, char *phr_owner_authority_name, unsigned int phr_id, char *phr_description,
boolean is_restricted_level_phr_flag, void (*backend_alert_msg_callback_handler_ptr)(char *alert_msg), void (*backend_fatal_alert_msg_callback_handler_ptr)(
char *alert_msg), void (*set_emergency_phr_ems_side_processing_success_state_callback_handler_ptr)(),
void (*update_emergency_phr_received_progression_callback_handler_ptr)(unsigned int percent))
{
// Setup allback handlers
backend_alert_msg_callback_handler = backend_alert_msg_callback_handler_ptr;
backend_fatal_alert_msg_callback_handler = backend_fatal_alert_msg_callback_handler_ptr;
set_emergency_phr_ems_side_processing_success_state_callback_handler = set_emergency_phr_ems_side_processing_success_state_callback_handler_ptr;
update_emergency_phr_received_progression_callback_handler = update_emergency_phr_received_progression_callback_handler_ptr;
// Passing variable
ptr_target_emergency_server_ip_addr = &target_emergency_server_ip_addr;
char buffer[BUFFER_LENGTH + 1];
char phr_id_str_tmp[INT_TO_STR_DIGITS_LENGTH + 1];
boolean emergency_phr_downloading_status;
init_main();
set_waiting_server_processing_flag(false);
set_emergency_phr_downloading_flag(false);
// Connect to the emergency server
if(!connect_to_emergency_phr_downloading_service(phr_owner_authority_name, &ssl_conn))
goto ERROR;
// Send request type information
write_token_into_buffer("request_type", (is_restricted_level_phr_flag) ? RESTRICTED_LEVEL_PHR_ACCESSING : SECURE_LEVEL_PHR_ACCESSING, true, buffer);
if(!SSL_send_buffer(ssl_conn, buffer, strlen(buffer)))
{
backend_alert_msg_handler_callback("Sending request type information failed");
goto ERROR;
}
sprintf(phr_id_str_tmp, "%u", phr_id);
// Send the requested emergency PHR information
write_token_into_buffer("desired_phr_owner_name", phr_owner_name, true, buffer);
write_token_into_buffer("phr_id", phr_id_str_tmp, false, buffer);
write_token_into_buffer("phr_description", phr_description, false, buffer);
if(!SSL_send_buffer(ssl_conn, buffer, strlen(buffer)))
{
backend_alert_msg_handler_callback("Sending the requested emergency PHR information failed");
goto ERROR;
}
// Create a waiting server processing thread
if(THREAD_CREATE(waiting_server_processing_thread_id, wait_server_processing_main, NULL) != 0)
int_error("Creating a thread for \"wait_server_processing_main\" failed");
set_waiting_server_processing_flag(true);
while(1)
{
if(sem_wait(&wake_up_main_thread_mutex) != 0)
int_error("Locking the mutex failed");
// The waiting server processing thread terminated
if(waiting_server_processing_thread_terminated_flag)
break;
// Send an error message to frontend
if(strlen(err_msg_to_frontend) > 0)
{
backend_alert_msg_handler_callback(err_msg_to_frontend);
strcpy(err_msg_to_frontend, "");
if(sem_post(&confirm_err_msg_sending_to_frontend_mutex) != 0)
int_error("Unlocking the mutex failed");
}
}
set_waiting_server_processing_flag(false);
// Join the waiting server processing thread
if(THREAD_JOIN(waiting_server_processing_thread_id) != 0)
int_error("Joining a thread \"wait_server_processing_main\" failed");
// Send signal to confirm that the waiting server processing thread has been terminated if the action was performed by a cancellation thread
if(emergency_phr_downloading_cancellation_flag)
{
if(sem_post(&send_signal_to_confirm_cancellation_thread_mutex) != 0)
int_error("Unlocking the mutex failed");
if(sem_wait(&cancellation_thread_got_confirmation_mutex) != 0)
int_error("Locking the mutex failed");
goto OPERATION_HAS_BEEN_CANCELLED;
}
if(!waiting_server_processing_success_status_flag)
{
goto ERROR;
}
set_emergency_phr_ems_side_processing_success_state_handler_callback();
set_emergency_phr_downloading_flag(true);
// Download the emergency PHR
emergency_phr_downloading_status = SSL_recv_phr_file(ssl_conn, UNARCHIVED_EMERGENCY_PHR_TARGET_FILE_PATH);
if(!emergency_phr_downloading_status && !emergency_phr_downloading_cancellation_flag)
{
char err_msg[ERR_MSG_LENGTH + 1];
sprintf(err_msg, "Receiving the %s-level PHR file failed", (is_restricted_level_phr_flag) ? "restricted" : "secure");
backend_alert_msg_callback_handler(err_msg);
goto ERROR;
}
set_emergency_phr_downloading_flag(false);
// Send signal to confirm that the download operation has been cancelled if the action was performed by a cancellation thread
if(emergency_phr_downloading_cancellation_flag)
{
if(sem_post(&send_signal_to_confirm_cancellation_thread_mutex) != 0)
int_error("Unlocking the mutex failed");
if(sem_wait(&cancellation_thread_got_confirmation_mutex) != 0)
int_error("Locking the mutex failed");
goto OPERATION_HAS_BEEN_CANCELLED;
}
SSL_cleanup(ssl_conn);
ssl_conn = NULL;
uninit_main();
return true;
ERROR:
OPERATION_HAS_BEEN_CANCELLED:
set_emergency_phr_downloading_flag(false);
set_waiting_server_processing_flag(false);
unlink(UNARCHIVED_EMERGENCY_PHR_TARGET_FILE_PATH);
if(ssl_conn)
{
SSL_cleanup(ssl_conn);
ssl_conn = NULL;
}
uninit_main();
return false;
}
int main(int argc, char *argv[])
{
int ch;
extern char *optarg;
int i, j, r;
thread_t threads[MAX_TPP];
/* init MP */
MP_INIT(argc,argv);
MP_PROCS(&size);
MP_MYID(&rank);
while ((ch = getopt(argc, argv, "t:s:i:d:h")) != -1) {
switch(ch) {
case 't': /* # of threads */
tpp = atoi(optarg);
if (tpp < 1 || tpp > MAX_TPP) {
PRINTF0("\"%s\" is improper value for -t, should be a "
"number between 1 and %d(MAX_TPP)\n",
optarg, MAX_TPP);
usage();
}
break;
case 'i': /* # of iterations */
iters = atoi(optarg);
if (iters < 1) {
PRINTF0("\"%s\" is improper value for -t, should be a "
"number equal or larger than 1\n", optarg);
usage();
}
break;
case 's': /* # of elements in the array */
asize = atoi(optarg);
if (iters < 1) {
PRINTF0("\"%s\" is improper value for -s, should be a "
"number equal or larger than 1\n", optarg);
usage();
}
break;
case 'd': delay = atoi(optarg); break; /* delay before start */
case 'h': usage(); break; /* print usage info */
}
}
#ifdef NOTHREADS
tpp = 1;
PRINTF0("Warning: NOTHREADS debug symbol is set -- running w/o threads\n");
#endif
th_size = size * tpp;
PRINTF0("\nTest of multi-threaded capabilities:\n"
"%d threads per process (%d threads total),\n"
"%d array elements of size %d,\n"
"%d iteration(s)\n\n", tpp, th_size, asize, sizeof(atype_t), iters);
if (delay) {
printf("%d: %d\n", rank, getpid());
fflush(stdout);
sleep(delay);
MP_BARRIER();
}
TH_INIT(size,tpp);
for (i = 0; i < tpp; i++) th_rank[i] = rank * tpp + i;
#if defined(DEBUG) && defined(LOG2FILE)
for (i = 0; i < tpp; i++) {
fname[10] = '0' + th_rank[i] / 100;
fname[11] = '0' + th_rank[i] % 100 / 10;
fname[12] = '0' + th_rank[i] % 10;
dbg[i] = fopen(fname, "w");
}
#endif
for (i = 0; i < tpp; i++)
prndbg(i, "proc %d, thread %d(%d):\n", rank, i, th_rank[i]);
/* init ARMCI */
ARMCI_Init();
/* set global seed (to ensure same random sequence across procs) */
time_seed = (unsigned)time(NULL);
armci_msg_brdcst(&time_seed, sizeof(time_seed), 0);
srand(time_seed); rand();
prndbg(0, "seed = %u\n", time_seed);
/* random pairs */
pairs = calloc(th_size, sizeof(int));
for (i = 0; i < th_size; i++) pairs[i] = -1;
for (i = 0; i < th_size; i++) {
if (pairs[i] != -1) continue;
r = RND(0, th_size);
while (i == r || pairs[r] != -1 ) r = RND(0, th_size);
pairs[i] = r; pairs[r] = i;
}
for (i = 0, cbufl = 0; i < th_size; i++)
cbufl += sprintf(cbuf + cbufl, " %d->%d|%d->%d",
i, pairs[i], pairs[i], pairs[pairs[i]]);
prndbg(0, "random pairs:%s\n", cbuf);
/* random targets */
rnd_tgts = calloc(th_size, sizeof(int));
for (i = 0, cbufl = 0; i < th_size; i++) {
rnd_tgts[i] = RND(0, th_size);
if (rnd_tgts[i] == i) { i--; continue; }
cbufl += sprintf(cbuf + cbufl, " %d", rnd_tgts[i]);
}
prndbg(0, "random targets:%s\n", cbuf);
/* random one */
rnd_one = RND(0, th_size);
prndbg(0, "random one = %d\n", rnd_one);
assert(ptrs1 = calloc(th_size, sizeof(void *)));
assert(ptrs2 = calloc(th_size, sizeof(void *)));
#ifdef NOTHREADS
thread_main((void *)(long)0);
#else
for (i = 0; i < tpp; i++) THREAD_CREATE(threads + i, thread_main, (void *)(long)i);
for (i = 0; i < tpp; i++) THREAD_JOIN(threads[i], NULL);
#endif
MP_BARRIER();
PRINTF0("Tests Completed\n");
/* clean up */
#if defined(DEBUG) && defined(LOG2FILE)
for (i = 0; i < tpp; i++) fclose(dbg[i]);
#endif
ARMCI_Finalize();
TH_FINALIZE();
MP_FINALIZE();
return 0;
}
int main(int argc, char *argv[])
{
THREAD_TYPE user_authentication_thread_id;
THREAD_TYPE pub_key_serving_thread_id;
THREAD_TYPE user_info_management_thread_id;
THREAD_TYPE server_info_management_thread_id;
THREAD_TYPE user_list_loading_thread_id;
THREAD_TYPE phr_authority_list_loading_thread_id;
THREAD_TYPE user_management_thread_id;
THREAD_TYPE phr_authority_management_thread_id;
THREAD_TYPE user_passwd_resetting_thread_id;
init_server();
// Create threads
if(THREAD_CREATE(user_authentication_thread_id, user_authentication_main, NULL) != 0)
{
uninit_server();
int_error("Creating a thread for \"user_authentication_main\" failed");
return 1;
}
if(THREAD_CREATE(pub_key_serving_thread_id, pub_key_serving_main, NULL) != 0)
{
uninit_server();
int_error("Creating a thread for \"pub_key_serving_main\" failed");
return 1;
}
if(THREAD_CREATE(user_info_management_thread_id, user_info_management_main, NULL) != 0)
{
uninit_server();
int_error("Creating a thread for \"user_info_management_main\" failed");
return 1;
}
if(THREAD_CREATE(server_info_management_thread_id, server_info_management_main, NULL) != 0)
{
uninit_server();
int_error("Creating a thread for \"server_info_management_main\" failed");
return 1;
}
if(THREAD_CREATE(user_list_loading_thread_id, user_list_loading_main, NULL) != 0)
{
uninit_server();
int_error("Creating a thread for \"user_list_loading_main\" failed");
return 1;
}
if(THREAD_CREATE(phr_authority_list_loading_thread_id, phr_authority_list_loading_main, NULL) != 0)
{
uninit_server();
int_error("Creating a thread for \"phr_authority_list_loading_main\" failed");
return 1;
}
if(THREAD_CREATE(user_management_thread_id, user_management_main, NULL) != 0)
{
uninit_server();
int_error("Creating a thread for \"user_management_main\" failed");
return 1;
}
if(THREAD_CREATE(phr_authority_management_thread_id, phr_authority_management_main, NULL) != 0)
{
uninit_server();
int_error("Creating a thread for \"phr_authority_management_main\" failed");
return 1;
}
if(THREAD_CREATE(user_passwd_resetting_thread_id, user_passwd_resetting_main, NULL) != 0)
{
uninit_server();
int_error("Creating a thread for \"user_passwd_resetting_main\" failed");
return 1;
}
printf("Emergency unit: %s.Emergency_Staff_Authority started...\n", GLOBAL_authority_name);
// Join threads
if(THREAD_JOIN(user_authentication_thread_id) != 0)
{
uninit_server();
int_error("Joining a thread \"user_authentication_main\" failed");
return 1;
}
if(THREAD_JOIN(pub_key_serving_thread_id) != 0)
{
uninit_server();
int_error("Joining a thread \"pub_key_serving_main\" failed");
return 1;
}
if(THREAD_JOIN(user_info_management_thread_id) != 0)
{
uninit_server();
int_error("Joining a thread \"user_info_management_main\" failed");
return 1;
}
if(THREAD_JOIN(server_info_management_thread_id) != 0)
{
uninit_server();
int_error("Joining a thread \"server_info_management_main\" failed");
return 1;
}
if(THREAD_JOIN(user_list_loading_thread_id) != 0)
{
uninit_server();
int_error("Joining a thread \"user_list_loading_main\" failed");
return 1;
}
if(THREAD_JOIN(phr_authority_list_loading_thread_id) != 0)
{
uninit_server();
int_error("Joining a thread \"phr_authority_list_loading_main\" failed");
return 1;
}
if(THREAD_JOIN(user_management_thread_id) != 0)
{
uninit_server();
int_error("Joining a thread \"user_management_main\" failed");
return 1;
}
if(THREAD_JOIN(phr_authority_management_thread_id) != 0)
{
uninit_server();
int_error("Joining a thread \"phr_authority_management_main\" failed");
return 1;
}
if(THREAD_JOIN(user_passwd_resetting_thread_id) != 0)
{
uninit_server();
int_error("Joining a thread \"user_passwd_resetting_main\" failed");
return 1;
}
uninit_server();
return 0;
}