This enables the full mutex types.
Nothing else is done yet.
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);
}
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)) {
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;
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, \
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);
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;
#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, \
* @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);
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;
}
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;
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);
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);
}
}
}
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;
}
}
#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;
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) {
#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_
* 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.
* 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.
*
* @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_
/**
* 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.
*
* @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_
/**
* 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.
*
* @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_
/**
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;
}
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;
}
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;
}
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;
}
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);
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);
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);
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);
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_
);
// 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 {
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);
// 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;
}
// 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;
}
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;
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;
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;
}
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);
// 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;
}
}
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;
}
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;
}
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;
}
} // 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_
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);
projects / controller / commitdiff