From 53801b407ac34554ec27071a2047c5817f7580ab Mon Sep 17 00:00:00 2001 From: Andrea Mazzoleni Date: Tue, 25 May 2021 22:08:12 +0200 Subject: [PATCH] Remove the need of the MingW pthread layer on the Windows port Now everything is implemented usign Windows native calls. --- cmdline/elem.c | 12 +-- cmdline/elem.h | 4 +- cmdline/io.c | 22 ++--- cmdline/io.h | 16 ++-- cmdline/mingw.c | 224 +++++++++++++++++++++++++++++++++------------ cmdline/mingw.h | 23 ++--- cmdline/portable.h | 39 ++++++-- cmdline/snapraid.c | 2 +- cmdline/state.c | 10 +- cmdline/support.c | 56 ++++++------ cmdline/support.h | 28 +++--- cmdline/unix.c | 4 +- 12 files changed, 284 insertions(+), 156 deletions(-) diff --git a/cmdline/elem.c b/cmdline/elem.c index 228a3c81..511c33ec 100644 --- a/cmdline/elem.c +++ b/cmdline/elem.c @@ -748,8 +748,8 @@ struct snapraid_disk* disk_alloc(const char* name, const char* dir, uint64_t dev /* ensure that the dir terminate with "/" if it isn't empty */ pathslash(disk->dir, sizeof(disk->dir)); -#if HAVE_PTHREAD - thread_mutex_init(&disk->fs_mutex, 0); +#if HAVE_THREAD + thread_mutex_init(&disk->fs_mutex); disk->fs_mutex_enabled = 0; /* lock will be enabled at threads start */ #endif @@ -798,7 +798,7 @@ void disk_free(struct snapraid_disk* disk) tommy_list_foreach(&disk->dirlist, (tommy_foreach_func*)dir_free); tommy_hashdyn_done(&disk->dirset); -#if HAVE_PTHREAD +#if HAVE_THREAD thread_mutex_destroy(&disk->fs_mutex); #endif @@ -807,7 +807,7 @@ void disk_free(struct snapraid_disk* disk) void disk_start_thread(struct snapraid_disk* disk) { -#if HAVE_PTHREAD +#if HAVE_THREAD disk->fs_mutex_enabled = 1; #else (void)disk; @@ -816,7 +816,7 @@ void disk_start_thread(struct snapraid_disk* disk) static inline void fs_lock(struct snapraid_disk* disk) { -#if HAVE_PTHREAD +#if HAVE_THREAD if (disk->fs_mutex_enabled) thread_mutex_lock(&disk->fs_mutex); #else @@ -826,7 +826,7 @@ static inline void fs_lock(struct snapraid_disk* disk) static inline void fs_unlock(struct snapraid_disk* disk) { -#if HAVE_PTHREAD +#if HAVE_THREAD if (disk->fs_mutex_enabled) thread_mutex_unlock(&disk->fs_mutex); #else diff --git a/cmdline/elem.h b/cmdline/elem.h index a29a0b0c..a7804320 100644 --- a/cmdline/elem.h +++ b/cmdline/elem.h @@ -357,7 +357,7 @@ struct snapraid_disk { int mapping_idx; /**< Index in the mapping vector. Used only as buffer when writing the content file. */ int skip_access; /**< If the disk is inaccessible and it should be skipped. */ -#if HAVE_PTHREAD +#if HAVE_THREAD /** * Mutex for protecting the filesystem structure. * @@ -367,7 +367,7 @@ struct snapraid_disk { * Files, links and dirs are not protected as they are not expected to * change during multithread processing. */ - pthread_mutex_t fs_mutex; + thread_mutex_t fs_mutex; int fs_mutex_enabled; /*< If the lock has to be used. */ #endif diff --git a/cmdline/io.c b/cmdline/io.c index 53e16c01..784652b9 100644 --- a/cmdline/io.c +++ b/cmdline/io.c @@ -276,7 +276,7 @@ static void io_stop_mono(struct snapraid_io* io) /* multi thread */ /* disable multithread if pthread is not present */ -#if HAVE_PTHREAD +#if HAVE_THREAD /** * Get the next task to work on for a reader. @@ -811,7 +811,7 @@ static void io_start_thread(struct snapraid_io* io, worker->index = 0; - thread_create(&worker->thread, 0, io_reader_thread, worker); + thread_create(&worker->thread, io_reader_thread, worker); } /* start the writer threads */ @@ -820,7 +820,7 @@ static void io_start_thread(struct snapraid_io* io, worker->index = io->io_max - 1; - thread_create(&worker->thread, 0, io_writer_thread, worker); + thread_create(&worker->thread, io_writer_thread, worker); } } @@ -876,7 +876,7 @@ void io_init(struct snapraid_io* io, struct snapraid_state* state, io->state = state; -#if HAVE_PTHREAD +#if HAVE_THREAD if (io_cache == 0) { /* default is 8 MiB of cache */ /* this seems to be a good tradeoff between speed and memory usage */ @@ -967,7 +967,7 @@ void io_init(struct snapraid_io* io, struct snapraid_state* state, worker->buffer_skew = handle_max; } -#if HAVE_PTHREAD +#if HAVE_THREAD if (io->io_max > 1) { io_read_next = io_read_next_thread; io_write_preset = io_write_preset_thread; @@ -979,11 +979,11 @@ void io_init(struct snapraid_io* io, struct snapraid_state* state, io_start = io_start_thread; io_stop = io_stop_thread; - thread_mutex_init(&io->io_mutex, 0); - thread_cond_init(&io->read_done, 0); - thread_cond_init(&io->read_sched, 0); - thread_cond_init(&io->write_done, 0); - thread_cond_init(&io->write_sched, 0); + thread_mutex_init(&io->io_mutex); + thread_cond_init(&io->read_done); + thread_cond_init(&io->read_sched); + thread_cond_init(&io->write_done); + thread_cond_init(&io->write_sched); } else #endif { @@ -1013,7 +1013,7 @@ void io_done(struct snapraid_io* io) free(io->writer_map); free(io->writer_list); -#if HAVE_PTHREAD +#if HAVE_THREAD if (io->io_max > 1) { thread_mutex_destroy(&io->io_mutex); thread_cond_destroy(&io->read_done); diff --git a/cmdline/io.h b/cmdline/io.h index 7df664f5..f0153dcc 100644 --- a/cmdline/io.h +++ b/cmdline/io.h @@ -87,8 +87,8 @@ struct snapraid_task { * from a specific disk. */ struct snapraid_worker { -#if HAVE_PTHREAD - pthread_t thread; /**< Thread context for the worker. */ +#if HAVE_THREAD + thread_id_t thread; /**< Thread context for the worker. */ #endif struct snapraid_io* io; /**< Parent pointer. */ @@ -147,12 +147,12 @@ struct snapraid_io { */ unsigned io_max; -#if HAVE_PTHREAD +#if HAVE_THREAD /** * Mutex used to protect the synchronization * between the io and the workers. */ - pthread_mutex_t io_mutex; + thread_mutex_t io_mutex; /** * Condition for a new read is completed. @@ -161,7 +161,7 @@ struct snapraid_io { * The IO waits on this condition when it's waiting for * a new read to be completed. */ - pthread_cond_t read_done; + thread_cond_t read_done; /** * Condition for a new read scheduled. @@ -170,7 +170,7 @@ struct snapraid_io { * read to process. * The IO signals this condition when new reads are scheduled. */ - pthread_cond_t read_sched; + thread_cond_t read_sched; /** * Condition for a new write is completed. @@ -179,7 +179,7 @@ struct snapraid_io { * The IO waits on this condition when it's waiting for * a new write to be completed. */ - pthread_cond_t write_done; + thread_cond_t write_done; /** * Condition for a new write scheduled. @@ -188,7 +188,7 @@ struct snapraid_io { * write to process. * The IO signals this condition when new writes are scheduled. */ - pthread_cond_t write_sched; + thread_cond_t write_sched; #endif /** diff --git a/cmdline/mingw.c b/cmdline/mingw.c index 5b8c9d49..705278c0 100644 --- a/cmdline/mingw.c +++ b/cmdline/mingw.c @@ -56,12 +56,12 @@ static ULONGLONG (WINAPI* ptr_GetTickCount64)(void); * Description of the last error. * It's stored in the thread local storage. */ -static pthread_key_t last_error; +static windows_key_t last_error; /** * Monotone tick counter */ -static pthread_mutex_t tick_lock; +static windows_mutex_t tick_lock; static uint64_t tick_last; /** @@ -119,14 +119,14 @@ void os_init(int opt) is_scan_winfind = opt != 0; /* initialize the thread local storage for strerror(), using free() as destructor */ - if (pthread_key_create(&last_error, free) != 0) { - log_fatal("Error calling pthread_key_create().\n"); + if (windows_key_create(&last_error, free) != 0) { + log_fatal("Error calling windows_key_create().\n"); exit(EXIT_FAILURE); } tick_last = 0; - if (pthread_mutex_init(&tick_lock, 0) != 0) { - log_fatal("Error calling pthread_mutex_init().\n"); + if (windows_mutex_init(&tick_lock, 0) != 0) { + log_fatal("Error calling windows_mutex_init().\n"); exit(EXIT_FAILURE); } @@ -173,9 +173,9 @@ void os_init(int opt) void os_done(void) { /* delete the thread local storage for strerror() */ - pthread_key_delete(last_error); + windows_key_delete(last_error); - pthread_mutex_destroy(&tick_lock); + windows_mutex_destroy(&tick_lock); /* restore the normal execution level */ SetThreadExecutionState(WIN32_ES_CONTINUOUS); @@ -1811,10 +1811,10 @@ const char* windows_strerror(int err) snprintf(error, len, "%s [%d/%u]", str, err, (unsigned)GetLastError()); /* get previous one, if any */ - previous = pthread_getspecific(last_error); + previous = windows_getspecific(last_error); /* store in the thread local storage */ - if (pthread_setspecific(last_error, error) != 0) { + if (windows_setspecific(last_error, error) != 0) { free(error); return str; } @@ -2024,7 +2024,7 @@ uint64_t tick(void) * We had reports of invalid stats due faulty High Precision Event Timer. * See: https://sourceforge.net/p/snapraid/discussion/1677233/thread/a2122fd6/ */ - pthread_mutex_lock(&tick_lock); + windows_mutex_lock(&tick_lock); /* * MSDN 'QueryPerformanceCounter' @@ -2039,7 +2039,7 @@ uint64_t tick(void) r = tick_last; tick_last = r; - pthread_mutex_unlock(&tick_lock); + windows_mutex_unlock(&tick_lock); return r; } @@ -2600,7 +2600,7 @@ static int device_thread(tommy_list* list, void* (*func)(void* arg)) for (i = tommy_list_head(list); i != 0; i = i->next) { devinfo_t* devinfo = i->data; - thread_create(&devinfo->thread, 0, func, devinfo); + thread_create(&devinfo->thread, func, devinfo); } /* joins all threads */ @@ -2690,109 +2690,221 @@ int devquery(tommy_list* high, tommy_list* low, int operation, int others) } /****************************************************************************/ -/* thread */ +/* pthread like interface */ int windows_mutex_init(windows_mutex_t* mutex, void* attr) { - CRITICAL_SECTION* cs; - (void)attr; - cs = malloc(sizeof(CRITICAL_SECTION)); - if (!cs) - return -1; - - InitializeCriticalSection(cs); - - *mutex = cs; + InitializeCriticalSection(mutex); return 0; } int windows_mutex_destroy(windows_mutex_t* mutex) { - CRITICAL_SECTION* cs = *mutex; - - DeleteCriticalSection(cs); - - free(cs); + DeleteCriticalSection(mutex); return 0; } int windows_mutex_lock(windows_mutex_t* mutex) { - CRITICAL_SECTION* cs = *mutex; - - EnterCriticalSection(cs); + EnterCriticalSection(mutex); return 0; } int windows_mutex_unlock(windows_mutex_t* mutex) { - CRITICAL_SECTION* cs = *mutex; - - LeaveCriticalSection(cs); + LeaveCriticalSection(mutex); return 0; } int windows_cond_init(windows_cond_t* cond, void* attr) { - CONDITION_VARIABLE* cv; - (void)attr; - cv = malloc(sizeof(CONDITION_VARIABLE)); - if (!cv) - return -1; - - InitializeConditionVariable(cv); - - *cond = cv; + InitializeConditionVariable(cond); return 0; } int windows_cond_destroy(windows_cond_t* cond) { - CONDITION_VARIABLE* cv = *cond; - /* note that in Windows there is no DeleteConditionVariable() to call */ - free(cv); + (void)cond; return 0; } int windows_cond_signal(windows_cond_t* cond) { - CONDITION_VARIABLE* cv = *cond; - - WakeConditionVariable(cv); + WakeConditionVariable(cond); return 0; } int windows_cond_broadcast(windows_cond_t* cond) { - CONDITION_VARIABLE* cv = *cond; - - WakeAllConditionVariable(cv); + WakeAllConditionVariable(cond); return 0; } int windows_cond_wait(windows_cond_t* cond, windows_mutex_t* mutex) { - CONDITION_VARIABLE* cv = *cond; - CRITICAL_SECTION* cs = *mutex; - - if (!SleepConditionVariableCS(cv, cs, INFINITE)) + if (!SleepConditionVariableCS(cond, mutex, INFINITE)) return -1; return 0; } +struct windows_key_context { + void (* func)(void *); + DWORD key; + tommy_node node; +}; + +/* list of all keys with destructor */ +static tommy_list windows_key_list = { 0 }; + +int windows_key_create(windows_key_t* key, void(* destructor)(void*)) +{ + struct windows_key_context* context; + + context = malloc(sizeof(struct windows_key_context)); + if (!context) + return -1; + + context->func = destructor; + context->key = TlsAlloc(); + if (context->key == 0xFFFFFFFF) { + windows_errno(GetLastError()); + free(context); + return -1; + } + + /* insert in the list of destructors */ + if (context->func) + tommy_list_insert_tail(&windows_key_list, &context->node, context); + + *key = context; + + return 0; +} + +int windows_key_delete(windows_key_t key) +{ + struct windows_key_context* context = key; + + /* remove from the list of destructors */ + if (context->func) + tommy_list_remove_existing(&windows_key_list, &context->node); + + TlsFree(context->key); + + free(context); + + return 0; +} + +void* windows_getspecific(windows_key_t key) +{ + struct windows_key_context* context = key; + + return TlsGetValue(context->key); +} + +int windows_setspecific(windows_key_t key, void* value) +{ + struct windows_key_context* context = key; + + if (!TlsSetValue(context->key, value)) { + windows_errno(GetLastError()); + return -1; + } + + return 0; +} + +struct windows_thread_context { + HANDLE h; + unsigned id; + void* (* func)(void *); + void* arg; + void* ret; +}; + +/* forwarder to change the function declaration */ +static unsigned __stdcall windows_thread_func(void* arg) +{ + struct windows_thread_context* context = arg; + tommy_node* i; + + context->ret = context->func(context->arg); + + /* call the destructor of all the keys */ + i = tommy_list_head(&windows_key_list); + while (i) { + struct windows_key_context* key = i->data; + if (key->func) { + void* value = windows_getspecific(key); + if (value) + key->func(value); + } + i = i->next; + } + + return 0; +} + +int windows_create(thread_id_t* thread, void* attr, void* (* func)(void *), void* arg) +{ + struct windows_thread_context* context; + + (void)attr; + + context = malloc(sizeof(struct windows_thread_context)); + if (!context) + return -1; + + context->func = func; + context->arg = arg; + context->ret = 0; + context->h = (void*)_beginthreadex(0, 0, windows_thread_func, context, 0, &context->id); + + if (context->h == 0) { + free(context); + return -1; + } + + *thread = context; + + return 0; +} + +int windows_join(thread_id_t thread, void** retval) +{ + struct windows_thread_context* context = thread; + + if (WaitForSingleObject(context->h, INFINITE) != WAIT_OBJECT_0) { + windows_errno(GetLastError()); + return -1; + } + + if (!CloseHandle(context->h)) { + windows_errno(GetLastError()); + return -1; + } + + *retval = context->ret; + + free(context); + + return 0; +} + #endif diff --git a/cmdline/mingw.h b/cmdline/mingw.h index 7ac80e19..8e6b7b1f 100644 --- a/cmdline/mingw.h +++ b/cmdline/mingw.h @@ -385,23 +385,8 @@ size_t windows_direct_size(void); /****************************************************************************/ /* thread */ -#define pthread_mutex_t windows_mutex_t -#define pthread_cond_t windows_cond_t -#define pthread_mutex_init windows_mutex_init -#define pthread_mutex_destroy windows_mutex_destroy -#define pthread_mutex_lock windows_mutex_lock -#define pthread_mutex_unlock windows_mutex_unlock -#define pthread_cond_init windows_cond_init -#define pthread_cond_destroy windows_cond_destroy -#define pthread_cond_signal windows_cond_signal -#define pthread_cond_broadcast windows_cond_broadcast -#define pthread_cond_wait windows_cond_wait - -typedef void* windows_mutex_t; -typedef void* windows_cond_t; - /** - * Like pthread_* equivalent. + * Like the pthread_* equivalent. */ int windows_mutex_init(windows_mutex_t* mutex, void* attr); int windows_mutex_destroy(windows_mutex_t* mutex); @@ -412,6 +397,12 @@ int windows_cond_destroy(windows_cond_t* cond); int windows_cond_signal(windows_cond_t* cond); int windows_cond_broadcast(windows_cond_t* cond); int windows_cond_wait(windows_cond_t* cond, windows_mutex_t* mutex); +int windows_key_create(windows_key_t* key, void(* destructor)(void*)); +int windows_key_delete(windows_key_t key); +void* windows_getspecific(windows_key_t key); +int windows_setspecific(windows_key_t key, void* value); +int windows_create(thread_id_t* thread, void* attr, void* (* func)(void *), void *arg); +int windows_join(thread_id_t thread, void** retval); #endif #endif diff --git a/cmdline/portable.h b/cmdline/portable.h index 5c754281..4d5b89bb 100644 --- a/cmdline/portable.h +++ b/cmdline/portable.h @@ -230,10 +230,6 @@ #include "fnmatch.h" #endif -#if HAVE_PTHREAD_H -#include -#endif - #if HAVE_MATH_H #include #endif @@ -245,8 +241,37 @@ /** * Enable thread use. */ +#ifdef _WIN32 +#define HAVE_THREAD 1 +typedef void* windows_thread_t; +typedef CRITICAL_SECTION windows_mutex_t; +typedef CONDITION_VARIABLE windows_cond_t; +typedef void* windows_key_t; +/* remap to pthread */ +#define thread_id_t windows_thread_t +#define thread_mutex_t windows_mutex_t +#define thread_cond_t windows_cond_t +#define pthread_mutex_init windows_mutex_init +#define pthread_mutex_destroy windows_mutex_destroy +#define pthread_mutex_lock windows_mutex_lock +#define pthread_mutex_unlock windows_mutex_unlock +#define pthread_cond_init windows_cond_init +#define pthread_cond_destroy windows_cond_destroy +#define pthread_cond_signal windows_cond_signal +#define pthread_cond_broadcast windows_cond_broadcast +#define pthread_cond_wait windows_cond_wait +#define pthread_create windows_create +#define pthread_join windows_join +#else +#if HAVE_PTHREAD_H +#include +#endif #if HAVE_PTHREAD_CREATE -#define HAVE_PTHREAD 1 +#define HAVE_THREAD 1 +typedef pthread_t thread_id_t; +typedef pthread_mutex_t thread_mutex_t; +typedef pthread_cond_t thread_cond_t; +#endif #endif /** @@ -470,8 +495,8 @@ struct devinfo_struct { char smart_serial[SMART_MAX]; /**< SMART serial number. */ char smart_vendor[SMART_MAX]; /**< SMART vendor. */ char smart_model[SMART_MAX]; /**< SMART model. */ -#if HAVE_PTHREAD - pthread_t thread; +#if HAVE_THREAD + thread_id_t thread; #endif tommy_node node; }; diff --git a/cmdline/snapraid.c b/cmdline/snapraid.c index ec4f839b..9e5e97b3 100644 --- a/cmdline/snapraid.c +++ b/cmdline/snapraid.c @@ -862,7 +862,7 @@ int main(int argc, char* argv[]) opt.force_stats = 1; break; case OPT_TEST_COND_SIGNAL_OUTSIDE : -#if HAVE_PTHREAD +#if HAVE_THREAD thread_cond_signal_outside = 1; #endif break; diff --git a/cmdline/state.c b/cmdline/state.c index b639055a..336a70c5 100644 --- a/cmdline/state.c +++ b/cmdline/state.c @@ -44,7 +44,7 @@ * Multi thread for verify is instead always generally faster, * so we enable it if possible. */ -#if HAVE_PTHREAD +#if HAVE_THREAD /* #define HAVE_MT_WRITE 1 */ #define HAVE_MT_VERIFY 1 #endif @@ -2881,7 +2881,7 @@ static void state_read_content(struct snapraid_state* state, const char* path, S struct state_write_thread_context { struct snapraid_state* state; #if HAVE_MT_WRITE - pthread_t thread; + thread_id_t thread; #endif /* input */ block_off_t blockmax; @@ -3498,7 +3498,7 @@ static void state_write_content(struct snapraid_state* state, uint32_t* out_crc) context->info_has_rehash = info_has_rehash; context->f = f; - thread_create(&context->thread, 0, state_write_thread, context); + thread_create(&context->thread, state_write_thread, context); i = i->next; } @@ -3843,7 +3843,7 @@ struct state_verify_thread_context { struct snapraid_state* state; struct snapraid_content* content; #if HAVE_MT_VERIFY - pthread_t thread; + thread_id_t thread; #else void* retval; #endif @@ -3934,7 +3934,7 @@ static void state_verify_content(struct snapraid_state* state, uint32_t crc) context->f = f; #if HAVE_MT_VERIFY - thread_create(&context->thread, 0, state_verify_thread, context); + thread_create(&context->thread, state_verify_thread, context); #else context->retval = state_verify_thread(context); #endif diff --git a/cmdline/support.c b/cmdline/support.c index 16d02297..5343df26 100644 --- a/cmdline/support.c +++ b/cmdline/support.c @@ -25,51 +25,51 @@ /** * Locks used externally. */ -#if HAVE_PTHREAD -static pthread_mutex_t msg_lock; -static pthread_mutex_t memory_lock; +#if HAVE_THREAD +static thread_mutex_t msg_lock; +static thread_mutex_t memory_lock; #endif void lock_msg(void) { -#if HAVE_PTHREAD +#if HAVE_THREAD thread_mutex_lock(&msg_lock); #endif } void unlock_msg(void) { -#if HAVE_PTHREAD +#if HAVE_THREAD thread_mutex_unlock(&msg_lock); #endif } void lock_memory(void) { -#if HAVE_PTHREAD +#if HAVE_THREAD thread_mutex_lock(&memory_lock); #endif } void unlock_memory(void) { -#if HAVE_PTHREAD +#if HAVE_THREAD thread_mutex_unlock(&memory_lock); #endif } void lock_init(void) { -#if HAVE_PTHREAD +#if HAVE_THREAD /* initialize the locks as first operation as log_fatal depends on them */ - thread_mutex_init(&msg_lock, 0); - thread_mutex_init(&memory_lock, 0); + thread_mutex_init(&msg_lock); + thread_mutex_init(&memory_lock); #endif } void lock_done(void) { -#if HAVE_PTHREAD +#if HAVE_THREAD thread_mutex_destroy(&msg_lock); thread_mutex_destroy(&memory_lock); #endif @@ -1539,10 +1539,10 @@ int smartctl_flush(FILE* f, const char* file, const char* name) /****************************************************************************/ /* thread */ -#if HAVE_PTHREAD -void thread_mutex_init(pthread_mutex_t* mutex, pthread_mutexattr_t* attr) +#if HAVE_THREAD +void thread_mutex_init(thread_mutex_t* mutex) { - if (pthread_mutex_init(mutex, attr) != 0) { + if (pthread_mutex_init(mutex, 0) != 0) { /* LCOV_EXCL_START */ log_fatal("Failed call to pthread_mutex_init().\n"); os_abort(); @@ -1550,7 +1550,7 @@ void thread_mutex_init(pthread_mutex_t* mutex, pthread_mutexattr_t* attr) } } -void thread_mutex_destroy(pthread_mutex_t* mutex) +void thread_mutex_destroy(thread_mutex_t* mutex) { if (pthread_mutex_destroy(mutex) != 0) { /* LCOV_EXCL_START */ @@ -1560,7 +1560,7 @@ void thread_mutex_destroy(pthread_mutex_t* mutex) } } -void thread_mutex_lock(pthread_mutex_t* mutex) +void thread_mutex_lock(thread_mutex_t* mutex) { if (pthread_mutex_lock(mutex) != 0) { /* LCOV_EXCL_START */ @@ -1570,7 +1570,7 @@ void thread_mutex_lock(pthread_mutex_t* mutex) } } -void thread_mutex_unlock(pthread_mutex_t* mutex) +void thread_mutex_unlock(thread_mutex_t* mutex) { if (pthread_mutex_unlock(mutex) != 0) { /* LCOV_EXCL_START */ @@ -1580,9 +1580,9 @@ void thread_mutex_unlock(pthread_mutex_t* mutex) } } -void thread_cond_init(pthread_cond_t* cond, pthread_condattr_t* attr) +void thread_cond_init(thread_cond_t* cond) { - if (pthread_cond_init(cond, attr) != 0) { + if (pthread_cond_init(cond, 0) != 0) { /* LCOV_EXCL_START */ log_fatal("Failed call to pthread_cond_init().\n"); os_abort(); @@ -1590,7 +1590,7 @@ void thread_cond_init(pthread_cond_t* cond, pthread_condattr_t* attr) } } -void thread_cond_destroy(pthread_cond_t* cond) +void thread_cond_destroy(thread_cond_t* cond) { if (pthread_cond_destroy(cond) != 0) { /* LCOV_EXCL_START */ @@ -1600,7 +1600,7 @@ void thread_cond_destroy(pthread_cond_t* cond) } } -void thread_cond_signal(pthread_cond_t* cond) +void thread_cond_signal(thread_cond_t* cond) { if (pthread_cond_signal(cond) != 0) { /* LCOV_EXCL_START */ @@ -1610,7 +1610,7 @@ void thread_cond_signal(pthread_cond_t* cond) } } -void thread_cond_broadcast(pthread_cond_t* cond) +void thread_cond_broadcast(thread_cond_t* cond) { if (pthread_cond_broadcast(cond) != 0) { /* LCOV_EXCL_START */ @@ -1620,7 +1620,7 @@ void thread_cond_broadcast(pthread_cond_t* cond) } } -void thread_cond_wait(pthread_cond_t* cond, pthread_mutex_t* mutex) +void thread_cond_wait(thread_cond_t* cond, thread_mutex_t* mutex) { if (pthread_cond_wait(cond, mutex) != 0) { /* LCOV_EXCL_START */ @@ -1659,7 +1659,7 @@ void thread_cond_wait(pthread_cond_t* cond, pthread_mutex_t* mutex) */ int thread_cond_signal_outside = 0; -void thread_cond_signal_and_unlock(pthread_cond_t* cond, pthread_mutex_t* mutex) +void thread_cond_signal_and_unlock(thread_cond_t* cond, thread_mutex_t* mutex) { if (thread_cond_signal_outside) { /* without the thread checker unlock before signaling, */ @@ -1676,7 +1676,7 @@ void thread_cond_signal_and_unlock(pthread_cond_t* cond, pthread_mutex_t* mutex) } } -void thread_cond_broadcast_and_unlock(pthread_cond_t* cond, pthread_mutex_t* mutex) +void thread_cond_broadcast_and_unlock(thread_cond_t* cond, thread_mutex_t* mutex) { if (thread_cond_signal_outside) { /* without the thread checker unlock before signaling, */ @@ -1693,9 +1693,9 @@ void thread_cond_broadcast_and_unlock(pthread_cond_t* cond, pthread_mutex_t* mut } } -void thread_create(pthread_t* thread, pthread_attr_t* attr, void *(* func)(void *), void *arg) +void thread_create(thread_id_t* thread, void* (* func)(void *), void *arg) { - if (pthread_create(thread, attr, func, arg) != 0) { + if (pthread_create(thread, 0, func, arg) != 0) { /* LCOV_EXCL_START */ log_fatal("Failed call to pthread_create().\n"); os_abort(); @@ -1703,7 +1703,7 @@ void thread_create(pthread_t* thread, pthread_attr_t* attr, void *(* func)(void } } -void thread_join(pthread_t thread, void** retval) +void thread_join(thread_id_t thread, void** retval) { if (pthread_join(thread, retval) != 0) { /* LCOV_EXCL_START */ diff --git a/cmdline/support.h b/cmdline/support.h index e7e76b5f..090f45d4 100644 --- a/cmdline/support.h +++ b/cmdline/support.h @@ -407,7 +407,7 @@ int smartctl_flush(FILE* f, const char* file, const char* name); /****************************************************************************/ /* thread */ -#if HAVE_PTHREAD +#if HAVE_THREAD /** * Control when to signal the condition variables. * @@ -420,19 +420,19 @@ extern int thread_cond_signal_outside; /** * Thread wrappers to handle error conditions. */ -void thread_mutex_init(pthread_mutex_t* mutex, pthread_mutexattr_t* attr); -void thread_mutex_destroy(pthread_mutex_t* mutex); -void thread_mutex_lock(pthread_mutex_t* mutex); -void thread_mutex_unlock(pthread_mutex_t* mutex); -void thread_cond_init(pthread_cond_t* cond, pthread_condattr_t* attr); -void thread_cond_destroy(pthread_cond_t* cond); -void thread_cond_signal(pthread_cond_t* cond); -void thread_cond_broadcast(pthread_cond_t* cond); -void thread_cond_wait(pthread_cond_t* cond, pthread_mutex_t* mutex); -void thread_cond_signal_and_unlock(pthread_cond_t* cond, pthread_mutex_t* mutex); -void thread_cond_broadcast_and_unlock(pthread_cond_t* cond, pthread_mutex_t* mutex); -void thread_create(pthread_t* thread, pthread_attr_t* attr, void *(* func)(void *), void *arg); -void thread_join(pthread_t thread, void** retval); +void thread_mutex_init(thread_mutex_t* mutex); +void thread_mutex_destroy(thread_mutex_t* mutex); +void thread_mutex_lock(thread_mutex_t* mutex); +void thread_mutex_unlock(thread_mutex_t* mutex); +void thread_cond_init(thread_cond_t* cond); +void thread_cond_destroy(thread_cond_t* cond); +void thread_cond_signal(thread_cond_t* cond); +void thread_cond_broadcast(thread_cond_t* cond); +void thread_cond_wait(thread_cond_t* cond, thread_mutex_t* mutex); +void thread_cond_signal_and_unlock(thread_cond_t* cond, thread_mutex_t* mutex); +void thread_cond_broadcast_and_unlock(thread_cond_t* cond, thread_mutex_t* mutex); +void thread_create(thread_id_t* thread, void* (* func)(void *), void *arg); +void thread_join(thread_id_t thread, void** retval); #endif #endif diff --git a/cmdline/unix.c b/cmdline/unix.c index 2b897fe1..15948989 100644 --- a/cmdline/unix.c +++ b/cmdline/unix.c @@ -1325,12 +1325,12 @@ static int device_thread(tommy_list* list, void* (*func)(void* arg)) int fail = 0; tommy_node* i; -#if HAVE_PTHREAD +#if HAVE_THREAD /* start all threads */ for (i = tommy_list_head(list); i != 0; i = i->next) { devinfo_t* devinfo = i->data; - thread_create(&devinfo->thread, 0, func, devinfo); + thread_create(&devinfo->thread, func, devinfo); } /* join all threads */