From: Kevin Day Date: Tue, 2 Sep 2025 01:36:56 +0000 (-0500) Subject: Progress: Begin revamping the thread locking design. X-Git-Tag: 0.7.3~26 X-Git-Url: https://www.git.kevux.org/?a=commitdiff_plain;h=36899ba8fed4b0bfbefa962106007f9b93103b7d;p=controller Progress: Begin revamping the thread locking design. This enables the full mutex types. Nothing else is done yet. --- diff --git a/sources/c/program/controller/main/common/type/instance.c b/sources/c/program/controller/main/common/type/instance.c index 5a7ca99..40d4e0a 100644 --- a/sources/c/program/controller/main/common/type/instance.c +++ b/sources/c/program/controller/main/common/type/instance.c @@ -19,7 +19,7 @@ extern "C" { f_thread_condition_delete(&instance->wait_condition); f_thread_lock_delete(&instance->lock); f_thread_lock_delete(&instance->active); - f_thread_mutex_delete(&instance->wait); + f_thread_mutex_full_delete(&instance->wait); controller_cache_delete(&instance->cache); controller_rule_delete(&instance->rule); @@ -71,7 +71,7 @@ extern "C" { } if (F_status_is_error_not(status)) { - status = f_thread_mutex_create(0, &(*instance)->wait); + status = controller_lock_create_mutex_full(&(*instance)->wait); } if (F_status_is_error_not(status)) { diff --git a/sources/c/program/controller/main/common/type/instance.h b/sources/c/program/controller/main/common/type/instance.h index 0b44a6e..94fbe29 100644 --- a/sources/c/program/controller/main/common/type/instance.h +++ b/sources/c/program/controller/main/common/type/instance.h @@ -63,7 +63,7 @@ extern "C" { f_thread_lock_t active; f_thread_lock_t lock; - f_thread_mutex_t wait; + f_thread_mutex_full_t wait; f_thread_condition_t wait_condition; f_pids_t childs; @@ -86,7 +86,7 @@ extern "C" { 0, \ f_thread_lock_t_initialize, \ f_thread_lock_t_initialize, \ - f_thread_mutex_t_initialize, \ + f_thread_mutex_full_t_initialize, \ f_thread_condition_t_initialize, \ f_pids_t_initialize, \ f_string_dynamics_t_initialize, \ diff --git a/sources/c/program/controller/main/common/type/lock.c b/sources/c/program/controller/main/common/type/lock.c index 73e83aa..c11cf0c 100644 --- a/sources/c/program/controller/main/common/type/lock.c +++ b/sources/c/program/controller/main/common/type/lock.c @@ -9,15 +9,16 @@ extern "C" { if (!lock || (lock->flag & controller_lock_flag_setup_not_d)) return; - f_thread_mutex_delete(&lock->alert); - f_thread_mutex_delete(&lock->cancel); - f_thread_mutex_delete(&lock->entry); - f_thread_mutex_delete(&lock->print); - f_thread_mutex_delete(&lock->reap); + f_thread_mutex_full_delete(&lock->alert); + f_thread_mutex_full_delete(&lock->cancel); + f_thread_mutex_full_delete(&lock->entry); + f_thread_mutex_full_delete(&lock->print); + f_thread_mutex_full_delete(&lock->reap); f_thread_lock_delete(&lock->enable); f_thread_lock_delete(&lock->instance); f_thread_lock_delete(&lock->rule); + f_thread_lock_delete(&lock->signal); f_thread_condition_delete(&lock->alert_condition); f_thread_condition_delete(&lock->reap_condition); diff --git a/sources/c/program/controller/main/common/type/lock.h b/sources/c/program/controller/main/common/type/lock.h index d54ea3f..5e55fbc 100644 --- a/sources/c/program/controller/main/common/type/lock.h +++ b/sources/c/program/controller/main/common/type/lock.h @@ -45,11 +45,11 @@ extern "C" { typedef struct { uint8_t flag; - f_thread_mutex_t alert; - f_thread_mutex_t cancel; - f_thread_mutex_t entry; - f_thread_mutex_t print; - f_thread_mutex_t reap; + f_thread_mutex_full_t alert; + f_thread_mutex_full_t cancel; + f_thread_mutex_full_t entry; + f_thread_mutex_full_t print; + f_thread_mutex_full_t reap; f_thread_lock_t enable; f_thread_lock_t instance; @@ -62,11 +62,11 @@ extern "C" { #define controller_lock_t_initialize { \ 0, \ - f_thread_mutex_t_initialize, \ - f_thread_mutex_t_initialize, \ - f_thread_mutex_t_initialize, \ - f_thread_mutex_t_initialize, \ - f_thread_mutex_t_initialize, \ + f_thread_mutex_full_t_initialize, \ + f_thread_mutex_full_t_initialize, \ + f_thread_mutex_full_t_initialize, \ + f_thread_mutex_full_t_initialize, \ + f_thread_mutex_full_t_initialize, \ f_thread_lock_t_initialize, \ f_thread_lock_t_initialize, \ f_thread_lock_t_initialize, \ @@ -82,8 +82,9 @@ extern "C" { * @param lock * The lock to de-allocate. * + * @see f_thread_condition_delete() * @see f_thread_lock_delete() - * @see f_thread_mutex_delete() + * @see f_thread_mutex_full_delete() */ #ifndef _di_controller_lock_delete_ extern void controller_lock_delete(controller_lock_t * const lock); diff --git a/sources/c/program/controller/main/entry.c b/sources/c/program/controller/main/entry.c index eb2a589..f783e5c 100644 --- a/sources/c/program/controller/main/entry.c +++ b/sources/c/program/controller/main/entry.c @@ -14,7 +14,7 @@ extern "C" { status = controller_entry_read_do(main, is_entry); - f_thread_mutex_unlock(&main->thread.lock.entry); + f_thread_mutex_unlock(&main->thread.lock.entry.mutex); return status; } diff --git a/sources/c/program/controller/main/instance/wait.c b/sources/c/program/controller/main/instance/wait.c index 6a7e5a2..3b9987d 100644 --- a/sources/c/program/controller/main/instance/wait.c +++ b/sources/c/program/controller/main/instance/wait.c @@ -35,9 +35,9 @@ extern "C" { controller_time_now(controller_thread_timeout_wait_4_seconds_d, controller_thread_timeout_wait_4_nanoseconds_d, &time); } - status = f_thread_condition_wait_timed(&time, &instance->wait_condition, &instance->wait); + status = f_thread_condition_wait_timed(&time, &instance->wait_condition, &instance->wait.mutex); - f_thread_mutex_unlock(&instance->wait); + f_thread_mutex_unlock(&instance->wait.mutex); if (!controller_thread_is_enabled_instance(instance)) return F_status_set_error(F_interrupt); if (F_status_is_error(status)) break; diff --git a/sources/c/program/controller/main/lock.c b/sources/c/program/controller/main/lock.c index 7b50c77..5444cc0 100644 --- a/sources/c/program/controller/main/lock.c +++ b/sources/c/program/controller/main/lock.c @@ -9,19 +9,19 @@ extern "C" { if (!lock) return F_status_set_error(F_parameter); - f_status_t status = f_thread_mutex_create(0, &lock->alert); + f_status_t status = controller_lock_create_mutex_full(&lock->alert); if (F_status_is_error(status)) return status; - status = f_thread_mutex_create(0, &lock->cancel); + status = controller_lock_create_mutex_full(&lock->cancel); if (F_status_is_error_not(status)) { - status = f_thread_mutex_create(0, &lock->entry); + status = controller_lock_create_mutex_full(&lock->entry); if (F_status_is_error_not(status)) { - status = f_thread_mutex_create(0, &lock->print); + status = controller_lock_create_mutex_full(&lock->print); if (F_status_is_error_not(status)) { - status = f_thread_mutex_create(0, &lock->reap); + status = controller_lock_create_mutex_full(&lock->reap); if (F_status_is_error_not(status)) { status = f_thread_lock_create(0, &lock->enable); @@ -33,18 +33,26 @@ extern "C" { status = f_thread_lock_create(0, &lock->rule); if (F_status_is_error_not(status)) { - status = f_thread_condition_create(0, &lock->alert_condition); + status = f_thread_lock_create(0, &lock->signal); if (F_status_is_error_not(status)) { - status = f_thread_condition_create(0, &lock->reap_condition); + status = f_thread_condition_create(0, &lock->alert_condition); + + if (F_status_is_error_not(status)) { + status = f_thread_condition_create(0, &lock->reap_condition); + + if (F_status_is_error(status)) { + f_thread_condition_delete(&lock->alert_condition); + } + } if (F_status_is_error(status)) { - f_thread_condition_delete(&lock->alert_condition); + f_thread_lock_delete(&lock->rule); } } if (F_status_is_error(status)) { - f_thread_lock_delete(&lock->rule); + f_thread_lock_delete(&lock->signal); } } @@ -59,27 +67,27 @@ extern "C" { } if (F_status_is_error(status)) { - f_thread_mutex_delete(&lock->reap); + f_thread_mutex_full_delete(&lock->reap); } } if (F_status_is_error(status)) { - f_thread_mutex_delete(&lock->print); + f_thread_mutex_full_delete(&lock->print); } } if (F_status_is_error(status)) { - f_thread_mutex_delete(&lock->entry); + f_thread_mutex_full_delete(&lock->entry); } } if (F_status_is_error(status)) { - f_thread_mutex_delete(&lock->cancel); + f_thread_mutex_full_delete(&lock->cancel); } } if (F_status_is_error(status)) { - f_thread_mutex_delete(&lock->alert); + f_thread_mutex_full_delete(&lock->alert); return status; } @@ -90,10 +98,35 @@ extern "C" { } #endif // _di_controller_lock_create_ +#ifndef _di_controller_lock_create_mutex_full_ + f_status_t controller_lock_create_mutex_full(f_thread_mutex_full_t * const full) { + + if (!full) return F_status_set_error(F_parameter); + + f_status_t status = f_thread_mutex_attribute_create(&full->attribute); + if (F_status_is_error(status)) return status; + + status = f_thread_mutex_attribute_type_set(f_thread_mutex_type_error_check_d, &full->attribute); + + if (F_status_is_error_not(status)) { + status = f_thread_mutex_create(0, &full->mutex); + } + + // De-allocate the attribute set on failure. + if (F_status_is_error(status)) { + f_thread_mutex_attribute_delete(&full->attribute); + + return status; + } + + return F_okay; + } +#endif // _di_controller_lock_create_mutex_full_ + #ifndef _di_controller_lock_mutex_ - f_status_t controller_lock_mutex(const uint8_t is_normal, const uint8_t check, const time_t seconds, const long nanoseconds, controller_thread_t * const thread, f_thread_mutex_t * const mutex) { + f_status_t controller_lock_mutex(const uint8_t is_normal, const uint8_t check, const time_t seconds, const long nanoseconds, controller_thread_t * const thread, f_thread_mutex_full_t * const full) { - if (!thread || !mutex) return F_status_set_error(F_parameter); + if (!thread || !full) return F_status_set_error(F_parameter); f_status_t status = F_okay; @@ -103,7 +136,7 @@ extern "C" { controller_time_now(controller_thread_timeout_lock_read_seconds_d, controller_thread_timeout_lock_read_nanoseconds_d, &time); - status = f_thread_mutex_lock_timed(&time, mutex); + status = f_thread_mutex_lock_timed(&time, &full->mutex); if (status == F_time) { if (check) { @@ -123,18 +156,18 @@ extern "C" { #endif // _di_controller_lock_mutex_ #ifndef _di_controller_lock_mutex_standard_ - f_status_t controller_lock_mutex_standard(const uint8_t is_normal, const uint8_t check, controller_thread_t * const thread, f_thread_mutex_t * const mutex) { + f_status_t controller_lock_mutex_standard(const uint8_t is_normal, const uint8_t check, controller_thread_t * const thread, f_thread_mutex_full_t * const full) { - return controller_lock_mutex(is_normal, check, controller_thread_timeout_lock_read_seconds_d, controller_thread_timeout_lock_read_nanoseconds_d, thread, mutex); + return controller_lock_mutex(is_normal, check, controller_thread_timeout_lock_read_seconds_d, controller_thread_timeout_lock_read_nanoseconds_d, thread, full); } #endif // _di_controller_lock_mutex_standard_ #ifndef _di_controller_lock_mutex_instance_ - f_status_t controller_lock_mutex_instance(controller_instance_t * const instance, f_thread_mutex_t * const mutex) { + f_status_t controller_lock_mutex_instance(controller_instance_t * const instance, f_thread_mutex_full_t * const full) { if (!instance) return F_status_set_error(F_parameter); - return controller_lock_mutex_standard(instance->type != controller_instance_type_exit_e, controller_lock_check_flag_yes_d, &instance->main->thread, mutex); + return controller_lock_mutex_standard(instance->type != controller_instance_type_exit_e, controller_lock_check_flag_yes_d, &instance->main->thread, full); } #endif // _di_controller_lock_mutex_instance_ diff --git a/sources/c/program/controller/main/lock.h b/sources/c/program/controller/main/lock.h index c15481e..bf21743 100644 --- a/sources/c/program/controller/main/lock.h +++ b/sources/c/program/controller/main/lock.h @@ -30,16 +30,47 @@ extern "C" { * F_parameter (with error bit) if a parameter is invalid. * * Errors (with error bit) from: f_thread_lock_delete(). - * Errors (with error bit) from: f_thread_mutex_delete(). + * Errors (with error bit) from: f_thread_mutex_full_delete(). + * Errors (with error bit) from: controller_lock_create_mutex_full(). * * @see f_thread_lock_delete() - * @see f_thread_mutex_delete() + * @see f_thread_mutex_full_delete() + * @see controller_lock_create_mutex_full() */ #ifndef _di_controller_lock_create_ extern f_status_t controller_lock_create(controller_lock_t * const lock); #endif // _di_controller_lock_create_ /** + * Perform the initial, required, allocation for a single full mutex lock. + * + * The mutex attribute will be deallocated on any errors following its allocation before returning. + * + * @param full + * The full mutex lock to allocate. + * + * Must not be NULL. + * + * @return + * F_okay on success. + * + * F_parameter (with error bit) if a parameter is invalid. + * + * Errors (with error bit) from: f_thread_mutex_attribute_create(). + * Errors (with error bit) from: f_thread_mutex_attribute_delete(). + * Errors (with error bit) from: f_thread_mutex_attribute_type_set(). + * Errors (with error bit) from: f_thread_mutex_create(). + * + * @see f_thread_mutex_attribute_create() + * @see f_thread_mutex_attribute_delete() + * @see f_thread_mutex_attribute_type_set() + * @see f_thread_mutex_create() + */ +#ifndef _di_controller_lock_create_mutex_full_ + extern f_status_t controller_lock_create_mutex_full(f_thread_mutex_full_t * const full); +#endif // _di_controller_lock_create_mutex_full_ + +/** * Wait to get a mutex lock. * * Given a mutex lock, periodically check to see if main thread is disabled while waiting. @@ -59,8 +90,8 @@ extern "C" { * The thread data used to determine if the main thread is disabled or not. * * Must not be NULL. - * @param mutex - * The mutex to lock. + * @param full + * The full mutex to lock. * * Must not be NULL. * @@ -77,7 +108,7 @@ extern "C" { * @see f_thread_mutex_lock_timed() */ #ifndef _di_controller_lock_mutex_ - extern f_status_t controller_lock_mutex(const uint8_t is_normal, const uint8_t check, const time_t seconds, const long nanoseconds, controller_thread_t * const thread, f_thread_mutex_t * const mutex); + extern f_status_t controller_lock_mutex(const uint8_t is_normal, const uint8_t check, const time_t seconds, const long nanoseconds, controller_thread_t * const thread, f_thread_mutex_full_t * const full); #endif // _di_controller_lock_mutex_ /** @@ -96,8 +127,8 @@ extern "C" { * The thread data used to determine if the main thread is disabled or not. * * Must not be NULL. - * @param mutex - * The mutex to lock. + * @param full + * The full mutex to lock. * * Must not be NULL. * @@ -109,7 +140,7 @@ extern "C" { * @see controller_lock_mutex() */ #ifndef _di_controller_lock_mutex_standard_ - extern f_status_t controller_lock_mutex_standard(const uint8_t is_normal, const uint8_t check, controller_thread_t * const thread, f_thread_mutex_t * const mutex); + extern f_status_t controller_lock_mutex_standard(const uint8_t is_normal, const uint8_t check, controller_thread_t * const thread, f_thread_mutex_full_t * const full); #endif // _di_controller_lock_mutex_standard_ /** @@ -121,8 +152,8 @@ extern "C" { * The instance to use when checking if thread is enabled. * * Must not be NULL. - * @param mutex - * The mutex to lock. + * @param full + * The full mutex to lock. * * Must not be NULL. * @@ -136,7 +167,7 @@ extern "C" { * @see controller_lock_mutex() */ #ifndef _di_controller_lock_mutex_instance_ - extern f_status_t controller_lock_mutex_instance(controller_instance_t * const instance, f_thread_mutex_t * const mutex); + extern f_status_t controller_lock_mutex_instance(controller_instance_t * const instance, f_thread_mutex_full_t * const full); #endif // _di_controller_lock_mutex_instance_ /** diff --git a/sources/c/program/controller/main/print/error.c b/sources/c/program/controller/main/print/error.c index 588d6e8..1a2a28c 100644 --- a/sources/c/program/controller/main/print/error.c +++ b/sources/c/program/controller/main/print/error.c @@ -12,11 +12,11 @@ extern "C" { controller_t * const main = (controller_t *) print->custom; - f_thread_mutex_lock(&main->thread.lock.print); + f_thread_mutex_lock(&main->thread.lock.print.mutex); fll_error_print(print, F_status_set_fine(main->setting.state.status), function, fll_error_file_flag_fallback_e); - f_thread_mutex_unlock(&main->thread.lock.print); + f_thread_mutex_unlock(&main->thread.lock.print.mutex); return F_okay; } @@ -48,11 +48,11 @@ extern "C" { controller_t * const main = (controller_t *) print->custom; - f_thread_mutex_lock(&main->thread.lock.print); + f_thread_mutex_lock(&main->thread.lock.print.mutex); fll_error_file_print(print, F_status_set_fine(main->setting.state.status), function, fll_error_file_flag_fallback_e, name, operation, type); - f_thread_mutex_unlock(&main->thread.lock.print); + f_thread_mutex_unlock(&main->thread.lock.print.mutex); return F_okay; } @@ -66,11 +66,11 @@ extern "C" { controller_t * const main = (controller_t *) print->custom; - f_thread_mutex_lock(&main->thread.lock.print); + f_thread_mutex_lock(&main->thread.lock.print.mutex); fll_error_file_print(print, status, function, fll_error_file_flag_fallback_e, name, operation, type); - f_thread_mutex_unlock(&main->thread.lock.print); + f_thread_mutex_unlock(&main->thread.lock.print.mutex); return F_okay; } @@ -104,11 +104,11 @@ extern "C" { controller_t * const main = (controller_t *) print->custom; - f_thread_mutex_lock(&main->thread.lock.print); + f_thread_mutex_lock(&main->thread.lock.print.mutex); fll_error_print(print, status, function, fll_error_file_flag_fallback_e); - f_thread_mutex_unlock(&main->thread.lock.print); + f_thread_mutex_unlock(&main->thread.lock.print.mutex); return F_okay; } diff --git a/sources/c/program/controller/main/print/error/entry.c b/sources/c/program/controller/main/print/error/entry.c index 723fd90..a4470c5 100644 --- a/sources/c/program/controller/main/print/error/entry.c +++ b/sources/c/program/controller/main/print/error/entry.c @@ -14,7 +14,7 @@ extern "C" { controller_t * const main = (controller_t *) print->custom; // fll_error_print() automatically locks, so manually handle only the mutex locking and flushing rather than calling controller_lock_print(). - f_thread_mutex_lock(&main->thread.lock.print); + f_thread_mutex_lock(&main->thread.lock.print.mutex); fll_error_print(print, status, function, fallback); @@ -72,7 +72,7 @@ extern "C" { controller_t * const main = (controller_t *) print->custom; // fll_error_file_print() automatically locks, so manually handle only the mutex locking and flushing rather than calling controller_lock_print(). - f_thread_mutex_lock(&main->thread.lock.print); + f_thread_mutex_lock(&main->thread.lock.print.mutex); fll_error_file_print(print, status, function, fallback, name, operation, type); diff --git a/sources/c/program/controller/main/print/error/rule.c b/sources/c/program/controller/main/print/error/rule.c index 4ae7d1e..f0a44ea 100644 --- a/sources/c/program/controller/main/print/error/rule.c +++ b/sources/c/program/controller/main/print/error/rule.c @@ -14,7 +14,7 @@ extern "C" { controller_t * const main = (controller_t *) print->custom; // fll_error_print() automatically locks, so manually handle only the mutex locking and flushing rather than calling controller_lock_print(). - f_thread_mutex_lock(&main->thread.lock.print); + f_thread_mutex_lock(&main->thread.lock.print.mutex); fll_error_print(print, status, function, fallback); diff --git a/sources/c/program/controller/main/print/lock.c b/sources/c/program/controller/main/print/lock.c index 740f64b..02f940e 100644 --- a/sources/c/program/controller/main/print/lock.c +++ b/sources/c/program/controller/main/print/lock.c @@ -8,7 +8,7 @@ extern "C" { void controller_lock_print(const f_file_t to, controller_thread_t * const thread) { if (thread) { - f_thread_mutex_lock(&thread->lock.print); + f_thread_mutex_lock(&thread->lock.print.mutex); } f_file_stream_lock(to); @@ -22,7 +22,7 @@ extern "C" { f_file_stream_unlock(to); if (thread) { - f_thread_mutex_unlock(&thread->lock.print); + f_thread_mutex_unlock(&thread->lock.print.mutex); } } #endif // _di_controller_unlock_print_flush_ diff --git a/sources/c/program/controller/main/thread/cleanup.c b/sources/c/program/controller/main/thread/cleanup.c index 8952112..9838dff 100644 --- a/sources/c/program/controller/main/thread/cleanup.c +++ b/sources/c/program/controller/main/thread/cleanup.c @@ -34,11 +34,11 @@ extern "C" { ); // Use mutex lock and conditional wait, but if that fails fall back to a regular timed wait. - if (f_thread_mutex_lock(&main->thread.lock.reap) == F_okay) { - status = f_thread_condition_wait_timed(&delay, &main->thread.lock.reap_condition, &main->thread.lock.reap); + if (f_thread_mutex_lock(&main->thread.lock.reap.mutex) == F_okay) { + status = f_thread_condition_wait_timed(&delay, &main->thread.lock.reap_condition, &main->thread.lock.reap.mutex); if (F_status_is_error_not(status)) { - f_thread_mutex_unlock(&main->thread.lock.reap); + f_thread_mutex_unlock(&main->thread.lock.reap.mutex); } } else { @@ -99,7 +99,7 @@ extern "C" { controller_time_now(controller_thread_timeout_cancel_seconds_d, controller_thread_timeout_cancel_nanoseconds_d, &time); - status = f_thread_mutex_lock_timed(&time, &main->thread.lock.cancel); + status = f_thread_mutex_lock_timed(&time, &main->thread.lock.cancel.mutex); if (F_status_is_error(status)) break; } while (status != F_okay); @@ -110,7 +110,7 @@ extern "C" { // If "active" has a read or write lock, then do not attempt to clean it. if (f_thread_lock_write_try(&instance->active) != F_okay) { - f_thread_mutex_unlock(&main->thread.lock.cancel); + f_thread_mutex_unlock(&main->thread.lock.cancel.mutex); continue; } @@ -118,7 +118,7 @@ extern "C" { // If "lock" has a read or write lock, then do not attempt to clean it. if (f_thread_lock_write_try(&instance->lock) != F_okay) { f_thread_unlock(&instance->active); - f_thread_mutex_unlock(&main->thread.lock.cancel); + f_thread_mutex_unlock(&main->thread.lock.cancel.mutex); continue; } @@ -127,7 +127,7 @@ extern "C" { if (instance->state == controller_instance_state_active_e || instance->state == controller_instance_state_busy_e || controller_thread_enable_get(&main->thread) != controller_thread_enable_e) { f_thread_unlock(&instance->lock); f_thread_unlock(&instance->active); - f_thread_mutex_unlock(&main->thread.lock.cancel); + f_thread_mutex_unlock(&main->thread.lock.cancel.mutex); if (controller_thread_enable_get(&main->thread) == controller_thread_enable_e) continue; @@ -148,7 +148,7 @@ extern "C" { if (j < instance->path_pids.used || controller_thread_enable_get(&main->thread) != controller_thread_enable_e) { f_thread_unlock(&instance->lock); f_thread_unlock(&instance->active); - f_thread_mutex_unlock(&main->thread.lock.cancel); + f_thread_mutex_unlock(&main->thread.lock.cancel.mutex); if (controller_thread_enable_get(&main->thread) == controller_thread_enable_e) continue; @@ -169,7 +169,7 @@ extern "C" { else { f_thread_unlock(&instance->lock); f_thread_unlock(&instance->active); - f_thread_mutex_unlock(&main->thread.lock.cancel); + f_thread_mutex_unlock(&main->thread.lock.cancel.mutex); continue; } @@ -211,7 +211,7 @@ extern "C" { f_thread_unlock(&instance->lock); f_thread_unlock(&instance->active); - f_thread_mutex_unlock(&main->thread.lock.cancel); + f_thread_mutex_unlock(&main->thread.lock.cancel.mutex); } // for f_thread_unlock(&main->thread.lock.instance); diff --git a/sources/c/program/controller/main/thread/instance.c b/sources/c/program/controller/main/thread/instance.c index 1753686..959a671 100644 --- a/sources/c/program/controller/main/thread/instance.c +++ b/sources/c/program/controller/main/thread/instance.c @@ -33,7 +33,7 @@ extern "C" { // Only cancel when enabled. if (!controller_thread_enable_is(&main->thread, is_normal)) { - f_thread_mutex_unlock(&main->thread.lock.cancel); + f_thread_mutex_unlock(&main->thread.lock.cancel.mutex); return; } @@ -111,7 +111,7 @@ extern "C" { } if (main->process.mode == controller_process_mode_helper_e && !(main->setting.flag & controller_main_flag_validate_d)) { - f_thread_mutex_unlock(&main->thread.lock.cancel); + f_thread_mutex_unlock(&main->thread.lock.cancel.mutex); return; } @@ -119,7 +119,7 @@ extern "C" { status = controller_lock_read(is_normal, controller_lock_check_flag_error_d, controller_thread_timeout_cancel_seconds_d, controller_thread_timeout_cancel_nanoseconds_d, &main->thread, &main->thread.lock.instance); if (F_status_is_error(status)) { - f_thread_mutex_unlock(&main->thread.lock.cancel); + f_thread_mutex_unlock(&main->thread.lock.cancel.mutex); return; } @@ -231,7 +231,7 @@ extern "C" { status = controller_lock_read(is_normal, controller_lock_check_flag_error_d, controller_thread_timeout_cancel_seconds_d, controller_thread_timeout_cancel_nanoseconds_d, &main->thread, &main->thread.lock.instance); if (F_status_is_error(status)) { - f_thread_mutex_unlock(&main->thread.lock.cancel); + f_thread_mutex_unlock(&main->thread.lock.cancel.mutex); return; } @@ -350,7 +350,7 @@ extern "C" { } // for f_thread_unlock(&main->thread.lock.instance); - f_thread_mutex_unlock(&main->thread.lock.cancel); + f_thread_mutex_unlock(&main->thread.lock.cancel.mutex); } #endif // _di_controller_thread_instance_cancel_ @@ -392,14 +392,14 @@ extern "C" { f_time_spec_t time = f_time_spec_t_initialize; do { - status = f_thread_mutex_lock(&main->thread.lock.alert); + status = f_thread_mutex_lock(&main->thread.lock.alert.mutex); if (F_status_is_error(status)) break; controller_time_now(controller_thread_timeout_exit_ready_seconds_d, controller_thread_timeout_exit_ready_nanoseconds_d, &time); - status = f_thread_condition_wait_timed(&time, &main->thread.lock.alert_condition, &main->thread.lock.alert); + status = f_thread_condition_wait_timed(&time, &main->thread.lock.alert_condition, &main->thread.lock.alert.mutex); - f_thread_mutex_unlock(&main->thread.lock.alert); + f_thread_mutex_unlock(&main->thread.lock.alert.mutex); } while (F_status_is_error_not(status) && controller_thread_enable_get(&main->thread) == controller_thread_enable_exit_e);