mirror of
https://github.com/amadvance/snapraid.git
synced 2026-11-19 22:46:36 -05:00
Remove the need of the MingW pthread layer on the Windows port
Now everything is implemented usign Windows native calls.
This commit is contained in:
parent
7ce88e5f18
commit
53801b407a
12 changed files with 284 additions and 156 deletions
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
22
cmdline/io.c
22
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);
|
||||
|
|
|
|||
16
cmdline/io.h
16
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
|
||||
|
||||
/**
|
||||
|
|
|
|||
224
cmdline/mingw.c
224
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
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -230,10 +230,6 @@
|
|||
#include "fnmatch.h"
|
||||
#endif
|
||||
|
||||
#if HAVE_PTHREAD_H
|
||||
#include <pthread.h>
|
||||
#endif
|
||||
|
||||
#if HAVE_MATH_H
|
||||
#include <math.h>
|
||||
#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 <pthread.h>
|
||||
#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;
|
||||
};
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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 */
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue