shaba/lvm2
1
0
Fork 0
mirror of git://sourceware.org/git/lvm2.git synced 2025-01-18 10:04:20 +03:00
Code Releases Activity

static naming

Browse Source
This commit is contained in:
Alasdair Kergon 2007-01-15 18:58:40 +00:00
parent 02059c81e7
commit c7a5306039
1 changed files with 179 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

338
daemons/dmeventd/dmeventd.c
View File

@ -168,22 +168,25 @@ static LIST_INIT(_thread_registry);
static LIST_INIT(_thread_registry_unused); static LIST_INIT(_thread_registry_unused);
static int _timeout_running; static int _timeout_running;
static LIST_INIT(timeout_registry); static LIST_INIT(_timeout_registry);
static pthread_mutex_t _timeout_mutex = PTHREAD_MUTEX_INITIALIZER; static pthread_mutex_t _timeout_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t _timeout_cond = PTHREAD_COND_INITIALIZER; static pthread_cond_t _timeout_cond = PTHREAD_COND_INITIALIZER;
/* Allocate/free the status structure for a monitoring thread. */ /* Allocate/free the status structure for a monitoring thread. */
static struct thread_status *alloc_thread_status(struct message_data *data, static struct thread_status *_alloc_thread_status(struct message_data *data,
struct dso_data *dso_data) struct dso_data *dso_data)
{ {
struct thread_status *ret = (typeof(ret)) dm_malloc(sizeof(*ret)); struct thread_status *ret = (typeof(ret)) dm_malloc(sizeof(*ret));
if (ret) { if (!ret)
return NULL;
if (!memset(ret, 0, sizeof(*ret)) || if (!memset(ret, 0, sizeof(*ret)) ||
!(ret->device.uuid = dm_strdup(data->device_uuid))) { !(ret->device.uuid = dm_strdup(data->device_uuid))) {
dm_free(ret); dm_free(ret);
ret = NULL; return NULL;
} else { }
ret->current_task = NULL; ret->current_task = NULL;
ret->device.name = NULL; ret->device.name = NULL;
ret->device.major = ret->device.minor = 0; ret->device.major = ret->device.minor = 0;
@ -191,13 +194,11 @@ static struct thread_status *alloc_thread_status(struct message_data *data,
ret->events = data->events.field; ret->events = data->events.field;
ret->timeout = data->timeout.secs; ret->timeout = data->timeout.secs;
list_init(&ret->timeout_list); list_init(&ret->timeout_list);
}
}
return ret; return ret;
} }
static void free_thread_status(struct thread_status *thread) static void _free_thread_status(struct thread_status *thread)
{ {
dm_free(thread->device.uuid); dm_free(thread->device.uuid);
dm_free(thread->device.name); dm_free(thread->device.name);
@ -205,7 +206,7 @@ static void free_thread_status(struct thread_status *thread)
} }
/* Allocate/free DSO data. */ /* Allocate/free DSO data. */
static struct dso_data *alloc_dso_data(struct message_data *data) static struct dso_data *_alloc_dso_data(struct message_data *data)
{ {
struct dso_data *ret = (typeof(ret)) dm_malloc(sizeof(*ret)); struct dso_data *ret = (typeof(ret)) dm_malloc(sizeof(*ret));
@ -221,7 +222,7 @@ static struct dso_data *alloc_dso_data(struct message_data *data)
return ret; return ret;
} }
static void free_dso_data(struct dso_data *data) static void _free_dso_data(struct dso_data *data)
{ {
dm_free(data->dso_name); dm_free(data->dso_name);
dm_free(data); dm_free(data);
@ -233,8 +234,7 @@ static void free_dso_data(struct dso_data *data)
*/ */
/* FIXME? move to libdevmapper to share with the client lib (need to /* FIXME? move to libdevmapper to share with the client lib (need to
make delimiter a parameter then) */ make delimiter a parameter then) */
static const char delimiter = ' '; static int _fetch_string(char **ptr, char **src, const char delimiter)
static int fetch_string(char **ptr, char **src)
{ {
int ret = 0; int ret = 0;
char *p; char *p;
@ -262,7 +262,7 @@ static int fetch_string(char **ptr, char **src)
} }
/* Free message memory. */ /* Free message memory. */
static void free_message(struct message_data *message_data) static void _free_message(struct message_data *message_data)
{ {
if (message_data->dso_name) if (message_data->dso_name)
dm_free(message_data->dso_name); dm_free(message_data->dso_name);
@ -273,7 +273,7 @@ static void free_message(struct message_data *message_data)
} }
/* Parse a register message from the client. */ /* Parse a register message from the client. */
static int parse_message(struct message_data *message_data) static int _parse_message(struct message_data *message_data)
{ {
int ret = 0; int ret = 0;
char *p = message_data->msg->data; char *p = message_data->msg->data;
@ -286,10 +286,10 @@ static int parse_message(struct message_data *message_data)
* Retrieve application identifier, mapped device * Retrieve application identifier, mapped device
* path and events # string from message. * path and events # string from message.
*/ */
if (fetch_string(&message_data->dso_name, &p) && if (_fetch_string(&message_data->dso_name, &p, ' ') &&
fetch_string(&message_data->device_uuid, &p) && _fetch_string(&message_data->device_uuid, &p, ' ') &&
fetch_string(&message_data->events.str, &p) && _fetch_string(&message_data->events.str, &p, ' ') &&
fetch_string(&message_data->timeout.str, &p)) { _fetch_string(&message_data->timeout.str, &p, ' ')) {
if (message_data->events.str) { if (message_data->events.str) {
enum dm_event_mask i = atoi(message_data->events.str); enum dm_event_mask i = atoi(message_data->events.str);
@ -317,18 +317,18 @@ static int parse_message(struct message_data *message_data)
}; };
/* Global mutex to lock access to lists et al. */ /* Global mutex to lock access to lists et al. */
static int lock_mutex(void) static int _lock_mutex(void)
{ {
return pthread_mutex_lock(&_global_mutex); return pthread_mutex_lock(&_global_mutex);
} }
static int unlock_mutex(void) static int _unlock_mutex(void)
{ {
return pthread_mutex_unlock(&_global_mutex); return pthread_mutex_unlock(&_global_mutex);
} }
/* Store pid in pidfile. */ /* Store pid in pidfile. */
static int storepid(int lf) static int _storepid(int lf)
{ {
int len; int len;
char pid[8]; char pid[8];
@ -348,7 +348,7 @@ static int storepid(int lf)
} }
/* Check, if a device exists. */ /* Check, if a device exists. */
static int fill_device_data(struct thread_status *ts) static int _fill_device_data(struct thread_status *ts)
{ {
struct dm_task *dmt; struct dm_task *dmt;
struct dm_info dmi; struct dm_info dmi;
@ -391,7 +391,7 @@ static int fill_device_data(struct thread_status *ts)
* *
* Mutex must be held when calling this. * Mutex must be held when calling this.
*/ */
static struct thread_status *lookup_thread_status(struct message_data *data) static struct thread_status *_lookup_thread_status(struct message_data *data)
{ {
struct thread_status *thread; struct thread_status *thread;
@ -403,35 +403,35 @@ static struct thread_status *lookup_thread_status(struct message_data *data)
} }
/* Cleanup at exit. */ /* Cleanup at exit. */
static void exit_dm_lib(void) static void _exit_dm_lib(void)
{ {
dm_lib_release(); dm_lib_release();
dm_lib_exit(); dm_lib_exit();
} }
static void exit_timeout(void *unused) static void _exit_timeout(void *unused)
{ {
_timeout_running = 0; _timeout_running = 0;
pthread_mutex_unlock(&_timeout_mutex); pthread_mutex_unlock(&_timeout_mutex);
} }
/* Wake up monitor threads every so often. */ /* Wake up monitor threads every so often. */
static void *timeout_thread(void *unused) static void *_timeout_thread(void *unused)
{ {
struct timespec timeout; struct timespec timeout;
time_t curr_time; time_t curr_time;
timeout.tv_nsec = 0; timeout.tv_nsec = 0;
pthread_cleanup_push(exit_timeout, NULL); pthread_cleanup_push(_exit_timeout, NULL);
pthread_mutex_lock(&_timeout_mutex); pthread_mutex_lock(&_timeout_mutex);
while (!list_empty(&timeout_registry)) { while (!list_empty(&_timeout_registry)) {
struct thread_status *thread; struct thread_status *thread;
timeout.tv_sec = (time_t) -1; timeout.tv_sec = (time_t) -1;
curr_time = time(NULL); curr_time = time(NULL);
list_iterate_items_gen(thread, &timeout_registry, timeout_list) { list_iterate_items_gen(thread, &_timeout_registry, timeout_list) {
if (thread->next_time < curr_time) { if (thread->next_time < curr_time) {
thread->next_time = curr_time + thread->timeout; thread->next_time = curr_time + thread->timeout;
pthread_kill(thread->thread, SIGALRM); pthread_kill(thread->thread, SIGALRM);
@ -450,7 +450,7 @@ static void *timeout_thread(void *unused)
return NULL; return NULL;
} }
static int register_for_timeout(struct thread_status *thread) static int _register_for_timeout(struct thread_status *thread)
{ {
int ret = 0; int ret = 0;
@ -459,7 +459,7 @@ static int register_for_timeout(struct thread_status *thread)
thread->next_time = time(NULL) + thread->timeout; thread->next_time = time(NULL) + thread->timeout;
if (list_empty(&thread->timeout_list)) { if (list_empty(&thread->timeout_list)) {
list_add(&timeout_registry, &thread->timeout_list); list_add(&_timeout_registry, &thread->timeout_list);
if (_timeout_running) if (_timeout_running)
pthread_cond_signal(&_timeout_cond); pthread_cond_signal(&_timeout_cond);
} }
@ -468,7 +468,7 @@ static int register_for_timeout(struct thread_status *thread)
pthread_t timeout_id; pthread_t timeout_id;
if (!(ret = -pthread_create(&timeout_id, NULL, if (!(ret = -pthread_create(&timeout_id, NULL,
timeout_thread, NULL))) _timeout_thread, NULL)))
_timeout_running = 1; _timeout_running = 1;
} }
@ -477,7 +477,7 @@ static int register_for_timeout(struct thread_status *thread)
return ret; return ret;
} }
static void unregister_for_timeout(struct thread_status *thread) static void _unregister_for_timeout(struct thread_status *thread)
{ {
pthread_mutex_lock(&_timeout_mutex); pthread_mutex_lock(&_timeout_mutex);
if (!list_empty(&thread->timeout_list)) { if (!list_empty(&thread->timeout_list)) {
@ -487,7 +487,7 @@ static void unregister_for_timeout(struct thread_status *thread)
pthread_mutex_unlock(&_timeout_mutex); pthread_mutex_unlock(&_timeout_mutex);
} }
static void no_intr_log(int level, const char *file, int line, static void _no_intr_log(int level, const char *file, int line,
const char *f, ...) const char *f, ...)
{ {
va_list ap; va_list ap;
@ -512,7 +512,7 @@ static void no_intr_log(int level, const char *file, int line,
fprintf(stdout, "\n"); fprintf(stdout, "\n");
} }
static sigset_t unblock_sigalrm(void) static sigset_t _unblock_sigalrm(void)
{ {
sigset_t set, old; sigset_t set, old;
@ -527,7 +527,7 @@ static sigset_t unblock_sigalrm(void)
#define DM_WAIT_FATAL 2 #define DM_WAIT_FATAL 2
/* Wait on a device until an event occurs. */ /* Wait on a device until an event occurs. */
static int event_wait(struct thread_status *thread, struct dm_task **task) static int _event_wait(struct thread_status *thread, struct dm_task **task)
{ {
sigset_t set; sigset_t set;
int ret = DM_WAIT_RETRY; int ret = DM_WAIT_RETRY;
@ -549,8 +549,8 @@ static int event_wait(struct thread_status *thread, struct dm_task **task)
* This is so that you can break out of waiting on an event, * This is so that you can break out of waiting on an event,
* either for a timeout event, or to cancel the thread. * either for a timeout event, or to cancel the thread.
*/ */
set = unblock_sigalrm(); set = _unblock_sigalrm();
dm_log_init(no_intr_log); dm_log_init(_no_intr_log);
errno = 0; errno = 0;
if (dm_task_run(dmt)) { if (dm_task_run(dmt)) {
thread->current_events |= DM_EVENT_DEVICE_ERROR; thread->current_events |= DM_EVENT_DEVICE_ERROR;
@ -585,7 +585,7 @@ static int event_wait(struct thread_status *thread, struct dm_task **task)
} }
/* Register a device with the DSO. */ /* Register a device with the DSO. */
static int do_register_device(struct thread_status *thread) static int _do_register_device(struct thread_status *thread)
{ {
return thread->dso_data->register_device(thread->device.name, return thread->dso_data->register_device(thread->device.name,
thread->device.uuid, thread->device.uuid,
@ -594,7 +594,7 @@ static int do_register_device(struct thread_status *thread)
} }
/* Unregister a device with the DSO. */ /* Unregister a device with the DSO. */
static int do_unregister_device(struct thread_status *thread) static int _do_unregister_device(struct thread_status *thread)
{ {
return thread->dso_data->unregister_device(thread->device.name, return thread->dso_data->unregister_device(thread->device.name,
thread->device.uuid, thread->device.uuid,
@ -603,17 +603,17 @@ static int do_unregister_device(struct thread_status *thread)
} }
/* Process an event in the DSO. */ /* Process an event in the DSO. */
static void do_process_event(struct thread_status *thread, struct dm_task *task) static void _do_process_event(struct thread_status *thread, struct dm_task *task)
{ {
thread->dso_data->process_event(task, thread->current_events); thread->dso_data->process_event(task, thread->current_events);
} }
/* Thread cleanup handler to unregister device. */ /* Thread cleanup handler to unregister device. */
static void monitor_unregister(void *arg) static void _monitor_unregister(void *arg)
{ {
struct thread_status *thread = arg; struct thread_status *thread = arg;
if (!do_unregister_device(thread)) if (!_do_unregister_device(thread))
syslog(LOG_ERR, "%s: %s unregister failed\n", __func__, syslog(LOG_ERR, "%s: %s unregister failed\n", __func__,
thread->device.name); thread->device.name);
if (thread->current_task) if (thread->current_task)
@ -622,25 +622,25 @@ static void monitor_unregister(void *arg)
} }
/* Device monitoring thread. */ /* Device monitoring thread. */
static void *monitor_thread(void *arg) static void *_monitor_thread(void *arg)
{ {
struct thread_status *thread = arg; struct thread_status *thread = arg;
int wait_error = 0; int wait_error = 0;
struct dm_task *task; struct dm_task *task;
pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL); pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL);
pthread_cleanup_push(monitor_unregister, thread); pthread_cleanup_push(_monitor_unregister, thread);
/* Wait for do_process_request() to finish its task. */ /* Wait for do_process_request() to finish its task. */
lock_mutex(); _lock_mutex();
thread->status = DM_THREAD_RUNNING; thread->status = DM_THREAD_RUNNING;
unlock_mutex(); _unlock_mutex();
/* Loop forever awaiting/analyzing device events. */ /* Loop forever awaiting/analyzing device events. */
while (1) { while (1) {
thread->current_events = 0; thread->current_events = 0;
wait_error = event_wait(thread, &task); wait_error = _event_wait(thread, &task);
if (wait_error == DM_WAIT_RETRY) if (wait_error == DM_WAIT_RETRY)
continue; continue;
@ -655,39 +655,39 @@ static void *monitor_thread(void *arg)
/* /*
* Check against filter. * Check against filter.
* *
* If there's current events delivered from event_wait() AND * If there's current events delivered from _event_wait() AND
* the device got registered for those events AND * the device got registered for those events AND
* those events haven't been processed yet, call * those events haven't been processed yet, call
* the DSO's process_event() handler. * the DSO's process_event() handler.
*/ */
lock_mutex(); _lock_mutex();
if (thread->status == DM_THREAD_SHUTDOWN) { if (thread->status == DM_THREAD_SHUTDOWN) {
unlock_mutex(); _unlock_mutex();
break; break;
} }
unlock_mutex(); _unlock_mutex();
if (thread->events & thread->current_events) { if (thread->events & thread->current_events) {
lock_mutex(); _lock_mutex();
thread->processing = 1; thread->processing = 1;
unlock_mutex(); _unlock_mutex();
do_process_event(thread, task); _do_process_event(thread, task);
dm_task_destroy(task); dm_task_destroy(task);
thread->current_task = NULL; thread->current_task = NULL;
lock_mutex(); _lock_mutex();
thread->processing = 0; thread->processing = 0;
unlock_mutex(); _unlock_mutex();
} else { } else {
dm_task_destroy(task); dm_task_destroy(task);
thread->current_task = NULL; thread->current_task = NULL;
} }
} }
lock_mutex(); _lock_mutex();
thread->status = DM_THREAD_DONE; thread->status = DM_THREAD_DONE;
unlock_mutex(); _unlock_mutex();
pthread_cleanup_pop(1); pthread_cleanup_pop(1);
@ -695,12 +695,12 @@ static void *monitor_thread(void *arg)
} }
/* Create a device monitoring thread. */ /* Create a device monitoring thread. */
static int create_thread(struct thread_status *thread) static int _create_thread(struct thread_status *thread)
{ {
return pthread_create(&thread->thread, NULL, monitor_thread, thread); return pthread_create(&thread->thread, NULL, _monitor_thread, thread);
} }
static int terminate_thread(struct thread_status *thread) static int _terminate_thread(struct thread_status *thread)
{ {
int ret; int ret;
@ -711,41 +711,41 @@ static int terminate_thread(struct thread_status *thread)
} }
/* DSO reference counting. */ /* DSO reference counting. */
static void lib_get(struct dso_data *data) static void _lib_get(struct dso_data *data)
{ {
data->ref_count++; data->ref_count++;
} }
static void lib_put(struct dso_data *data) static void _lib_put(struct dso_data *data)
{ {
if (!--data->ref_count) { if (!--data->ref_count) {
dlclose(data->dso_handle); dlclose(data->dso_handle);
UNLINK_DSO(data); UNLINK_DSO(data);
free_dso_data(data); _free_dso_data(data);
} }
} }
/* Find DSO data. */ /* Find DSO data. */
static struct dso_data *lookup_dso(struct message_data *data) static struct dso_data *_lookup_dso(struct message_data *data)
{ {
struct dso_data *dso_data, *ret = NULL; struct dso_data *dso_data, *ret = NULL;
lock_mutex(); _lock_mutex();
list_iterate_items(dso_data, &_dso_registry) list_iterate_items(dso_data, &_dso_registry)
if (!strcmp(data->dso_name, dso_data->dso_name)) { if (!strcmp(data->dso_name, dso_data->dso_name)) {
lib_get(dso_data); _lib_get(dso_data);
ret = dso_data; ret = dso_data;
break; break;
} }
unlock_mutex(); _unlock_mutex();
return ret; return ret;
} }
/* Lookup DSO symbols we need. */ /* Lookup DSO symbols we need. */
static int lookup_symbol(void *dl, struct dso_data *data, static int _lookup_symbol(void *dl, struct dso_data *data,
void **symbol, const char *name) void **symbol, const char *name)
{ {
if ((*symbol = dlsym(dl, name))) if ((*symbol = dlsym(dl, name)))
@ -756,16 +756,16 @@ static int lookup_symbol(void *dl, struct dso_data *data,
static int lookup_symbols(void *dl, struct dso_data *data) static int lookup_symbols(void *dl, struct dso_data *data)
{ {
return lookup_symbol(dl, data, (void *) &data->process_event, return _lookup_symbol(dl, data, (void *) &data->process_event,
"process_event") && "process_event") &&
lookup_symbol(dl, data, (void *) &data->register_device, _lookup_symbol(dl, data, (void *) &data->register_device,
"register_device") && "register_device") &&
lookup_symbol(dl, data, (void *) &data->unregister_device, _lookup_symbol(dl, data, (void *) &data->unregister_device,
"unregister_device"); "unregister_device");
} }
/* Load an application specific DSO. */ /* Load an application specific DSO. */
static struct dso_data *load_dso(struct message_data *data) static struct dso_data *_load_dso(struct message_data *data)
{ {
void *dl; void *dl;
struct dso_data *ret = NULL; struct dso_data *ret = NULL;
@ -780,13 +780,13 @@ static struct dso_data *load_dso(struct message_data *data)
return NULL; return NULL;
} }
if (!(ret = alloc_dso_data(data))) { if (!(ret = _alloc_dso_data(data))) {
dlclose(dl); dlclose(dl);
return NULL; return NULL;
} }
if (!(lookup_symbols(dl, ret))) { if (!(lookup_symbols(dl, ret))) {
free_dso_data(ret); _free_dso_data(ret);
dlclose(dl); dlclose(dl);
return NULL; return NULL;
} }
@ -796,17 +796,17 @@ static struct dso_data *load_dso(struct message_data *data)
* we've got no references to it any more. * we've got no references to it any more.
*/ */
ret->dso_handle = dl; ret->dso_handle = dl;
lib_get(ret); _lib_get(ret);
lock_mutex(); _lock_mutex();
LINK_DSO(ret); LINK_DSO(ret);
unlock_mutex(); _unlock_mutex();
return ret; return ret;
} }
/* Return success on daemon active check. */ /* Return success on daemon active check. */
static int active(struct message_data *message_data) static int _active(struct message_data *message_data)
{ {
return 0; return 0;
} }
@ -817,14 +817,14 @@ static int active(struct message_data *message_data)
* Only one caller at a time here, because we use * Only one caller at a time here, because we use
* a FIFO and lock it against multiple accesses. * a FIFO and lock it against multiple accesses.
*/ */
static int register_for_event(struct message_data *message_data) static int _register_for_event(struct message_data *message_data)
{ {
int ret = 0; int ret = 0;
struct thread_status *thread, *thread_new = NULL; struct thread_status *thread, *thread_new = NULL;
struct dso_data *dso_data; struct dso_data *dso_data;
if (!(dso_data = lookup_dso(message_data)) && if (!(dso_data = _lookup_dso(message_data)) &&
!(dso_data = load_dso(message_data))) { !(dso_data = _load_dso(message_data))) {
stack; stack;
#ifdef ELIBACC #ifdef ELIBACC
ret = -ELIBACC; ret = -ELIBACC;
@ -835,35 +835,35 @@ static int register_for_event(struct message_data *message_data)
} }
/* Preallocate thread status struct to avoid deadlock. */ /* Preallocate thread status struct to avoid deadlock. */
if (!(thread_new = alloc_thread_status(message_data, dso_data))) { if (!(thread_new = _alloc_thread_status(message_data, dso_data))) {
stack; stack;
ret = -ENOMEM; ret = -ENOMEM;
goto out; goto out;
} }
if (!fill_device_data(thread_new)) { if (!_fill_device_data(thread_new)) {
stack; stack;
ret = -ENODEV; ret = -ENODEV;
goto out; goto out;
} }
lock_mutex(); _lock_mutex();
if (!(thread = lookup_thread_status(message_data))) { if (!(thread = _lookup_thread_status(message_data))) {
unlock_mutex(); _unlock_mutex();
if (!(ret = do_register_device(thread_new))) if (!(ret = _do_register_device(thread_new)))
goto out; goto out;
thread = thread_new; thread = thread_new;
thread_new = NULL; thread_new = NULL;
/* Try to create the monitoring thread for this device. */ /* Try to create the monitoring thread for this device. */
lock_mutex(); _lock_mutex();
if ((ret = -create_thread(thread))) { if ((ret = -_create_thread(thread))) {
unlock_mutex(); _unlock_mutex();
do_unregister_device(thread); _do_unregister_device(thread);
free_thread_status(thread); _free_thread_status(thread);
goto out; goto out;
} else } else
LINK_THREAD(thread); LINK_THREAD(thread);
@ -872,7 +872,7 @@ static int register_for_event(struct message_data *message_data)
/* Or event # into events bitfield. */ /* Or event # into events bitfield. */
thread->events |= message_data->events.field; thread->events |= message_data->events.field;
unlock_mutex(); _unlock_mutex();
/* FIXME - If you fail to register for timeout events, you /* FIXME - If you fail to register for timeout events, you
still monitor all the other events. Is this the right still monitor all the other events. Is this the right
@ -881,7 +881,7 @@ static int register_for_event(struct message_data *message_data)
successfully started up later, you will start receiving successfully started up later, you will start receiving
DM_EVENT_TIMEOUT events */ DM_EVENT_TIMEOUT events */
if (thread->events & DM_EVENT_TIMEOUT) if (thread->events & DM_EVENT_TIMEOUT)
ret = -register_for_timeout(thread); ret = -_register_for_timeout(thread);
out: out:
/* /*
@ -889,7 +889,7 @@ static int register_for_event(struct message_data *message_data)
* the lock in case we haven't used it. * the lock in case we haven't used it.
*/ */
if (thread_new) if (thread_new)
free_thread_status(thread_new); _free_thread_status(thread_new);
return ret; return ret;
} }
@ -899,7 +899,7 @@ static int register_for_event(struct message_data *message_data)
* *
* Only one caller at a time here as with register_for_event(). * Only one caller at a time here as with register_for_event().
*/ */
static int unregister_for_event(struct message_data *message_data) static int _unregister_for_event(struct message_data *message_data)
{ {
int ret = 0; int ret = 0;
struct thread_status *thread; struct thread_status *thread;
@ -908,10 +908,10 @@ static int unregister_for_event(struct message_data *message_data)
* Clear event in bitfield and deactivate * Clear event in bitfield and deactivate
* monitoring thread in case bitfield is 0. * monitoring thread in case bitfield is 0.
*/ */
lock_mutex(); _lock_mutex();
if (!(thread = lookup_thread_status(message_data))) { if (!(thread = _lookup_thread_status(message_data))) {
unlock_mutex(); _unlock_mutex();
ret = -ENODEV; ret = -ENODEV;
goto out; goto out;
} }
@ -919,7 +919,7 @@ static int unregister_for_event(struct message_data *message_data)
thread->events &= ~message_data->events.field; thread->events &= ~message_data->events.field;
if (!(thread->events & DM_EVENT_TIMEOUT)) if (!(thread->events & DM_EVENT_TIMEOUT))
unregister_for_timeout(thread); _unregister_for_timeout(thread);
/* /*
* In case there's no events to monitor on this device -> * In case there's no events to monitor on this device ->
* unlink and terminate its monitoring thread. * unlink and terminate its monitoring thread.
@ -928,7 +928,7 @@ static int unregister_for_event(struct message_data *message_data)
UNLINK_THREAD(thread); UNLINK_THREAD(thread);
LINK(thread, &_thread_registry_unused); LINK(thread, &_thread_registry_unused);
} }
unlock_mutex(); _unlock_mutex();
out: out:
return ret; return ret;
@ -939,7 +939,7 @@ static int unregister_for_event(struct message_data *message_data)
* *
* Only one caller at a time here as with register_for_event(). * Only one caller at a time here as with register_for_event().
*/ */
static int registered_device(struct message_data *message_data, static int _registered_device(struct message_data *message_data,
struct thread_status *thread) struct thread_status *thread)
{ {
struct dm_event_daemon_message *msg = message_data->msg; struct dm_event_daemon_message *msg = message_data->msg;
@ -956,12 +956,12 @@ static int registered_device(struct message_data *message_data,
msg->size = dm_asprintf(&(msg->data), fmt, dso, dev, events); msg->size = dm_asprintf(&(msg->data), fmt, dso, dev, events);
unlock_mutex(); _unlock_mutex();
return 0; return 0;
} }
static int want_registered_device(char *dso_name, char *device_uuid, static int _want_registered_device(char *dso_name, char *device_uuid,
struct thread_status *thread) struct thread_status *thread)
{ {
/* If DSO names and device paths are equal. */ /* If DSO names and device paths are equal. */
@ -980,16 +980,16 @@ static int want_registered_device(char *dso_name, char *device_uuid,
return 1; return 1;
} }
static int _get_registered_device(struct message_data *message_data, int next) static int _get_registered_dev(struct message_data *message_data, int next)
{ {
int hit = 0; int hit = 0;
struct thread_status *thread; struct thread_status *thread;
lock_mutex(); _lock_mutex();
/* Iterate list of threads checking if we want a particular one. */ /* Iterate list of threads checking if we want a particular one. */
list_iterate_items(thread, &_thread_registry) list_iterate_items(thread, &_thread_registry)
if ((hit = want_registered_device(message_data->dso_name, if ((hit = _want_registered_device(message_data->dso_name,
message_data->device_uuid, message_data->device_uuid,
thread))) thread)))
break; break;
@ -1006,39 +1006,39 @@ static int _get_registered_device(struct message_data *message_data, int next)
goto out; goto out;
thread = list_item(thread->list.n, struct thread_status); thread = list_item(thread->list.n, struct thread_status);
} while (!want_registered_device(message_data->dso_name, NULL, thread)); } while (!_want_registered_device(message_data->dso_name, NULL, thread));
return registered_device(message_data, thread); return _registered_device(message_data, thread);
out: out:
unlock_mutex(); _unlock_mutex();
return -ENOENT; return -ENOENT;
} }
static int get_registered_device(struct message_data *message_data) static int _get_registered_device(struct message_data *message_data)
{ {
return _get_registered_device(message_data, 0); return _get_registered_dev(message_data, 0);
} }
static int get_next_registered_device(struct message_data *message_data) static int _get_next_registered_device(struct message_data *message_data)
{ {
return _get_registered_device(message_data, 1); return _get_registered_dev(message_data, 1);
} }
static int set_timeout(struct message_data *message_data) static int _set_timeout(struct message_data *message_data)
{ {
struct thread_status *thread; struct thread_status *thread;
lock_mutex(); _lock_mutex();
if ((thread = lookup_thread_status(message_data))) if ((thread = _lookup_thread_status(message_data)))
thread->timeout = message_data->timeout.secs; thread->timeout = message_data->timeout.secs;
unlock_mutex(); _unlock_mutex();
return thread ? 0 : -ENODEV; return thread ? 0 : -ENODEV;
} }
static int get_timeout(struct message_data *message_data) static int _get_timeout(struct message_data *message_data)
{ {
struct thread_status *thread; struct thread_status *thread;
struct dm_event_daemon_message *msg = message_data->msg; struct dm_event_daemon_message *msg = message_data->msg;
@ -1046,21 +1046,21 @@ static int get_timeout(struct message_data *message_data)
if (msg->data) if (msg->data)
dm_free(msg->data); dm_free(msg->data);
lock_mutex(); _lock_mutex();
if ((thread = lookup_thread_status(message_data))) { if ((thread = _lookup_thread_status(message_data))) {
msg->size = msg->size =
dm_asprintf(&(msg->data), "%" PRIu32, thread->timeout); dm_asprintf(&(msg->data), "%" PRIu32, thread->timeout);
} else { } else {
msg->data = NULL; msg->data = NULL;
msg->size = 0; msg->size = 0;
} }
unlock_mutex(); _unlock_mutex();
return thread ? 0 : -ENODEV; return thread ? 0 : -ENODEV;
} }
/* Initialize a fifos structure with path names. */ /* Initialize a fifos structure with path names. */
static void init_fifos(struct dm_event_fifos *fifos) static void _init_fifos(struct dm_event_fifos *fifos)
{ {
memset(fifos, 0, sizeof(*fifos)); memset(fifos, 0, sizeof(*fifos));
@ -1069,7 +1069,7 @@ static void init_fifos(struct dm_event_fifos *fifos)
} }
/* Open fifos used for client communication. */ /* Open fifos used for client communication. */
static int open_fifos(struct dm_event_fifos *fifos) static int _open_fifos(struct dm_event_fifos *fifos)
{ {
/* Create fifos */ /* Create fifos */
if (((mkfifo(fifos->client_path, 0600) == -1) && errno != EEXIST) || if (((mkfifo(fifos->client_path, 0600) == -1) && errno != EEXIST) ||
@ -1123,7 +1123,7 @@ static int open_fifos(struct dm_event_fifos *fifos)
* Read message from client making sure that data is available * Read message from client making sure that data is available
* and a complete message is read. Must not block indefinitely. * and a complete message is read. Must not block indefinitely.
*/ */
static int client_read(struct dm_event_fifos *fifos, static int _client_read(struct dm_event_fifos *fifos,
struct dm_event_daemon_message *msg) struct dm_event_daemon_message *msg)
{ {
struct timeval t; struct timeval t;
@ -1179,7 +1179,7 @@ static int client_read(struct dm_event_fifos *fifos,
/* /*
* Write a message to the client making sure that it is ready to write. * Write a message to the client making sure that it is ready to write.
*/ */
static int client_write(struct dm_event_fifos *fifos, static int _client_write(struct dm_event_fifos *fifos,
struct dm_event_daemon_message *msg) struct dm_event_daemon_message *msg)
{ {
unsigned bytes = 0; unsigned bytes = 0;
@ -1216,21 +1216,21 @@ static int client_write(struct dm_event_fifos *fifos,
* We put the request handling functions into * We put the request handling functions into
* a list because of the growing number. * a list because of the growing number.
*/ */
static int handle_request(struct dm_event_daemon_message *msg, static int _handle_request(struct dm_event_daemon_message *msg,
struct message_data *message_data) struct message_data *message_data)
{ {
static struct { static struct {
unsigned int cmd; unsigned int cmd;
int (*f)(struct message_data *); int (*f)(struct message_data *);
} requests[] = { } requests[] = {
{ DM_EVENT_CMD_REGISTER_FOR_EVENT, register_for_event}, { DM_EVENT_CMD_REGISTER_FOR_EVENT, _register_for_event},
{ DM_EVENT_CMD_UNREGISTER_FOR_EVENT, unregister_for_event}, { DM_EVENT_CMD_UNREGISTER_FOR_EVENT, _unregister_for_event},
{ DM_EVENT_CMD_GET_REGISTERED_DEVICE, get_registered_device}, { DM_EVENT_CMD_GET_REGISTERED_DEVICE, _get_registered_device},
{ DM_EVENT_CMD_GET_NEXT_REGISTERED_DEVICE, { DM_EVENT_CMD_GET_NEXT_REGISTERED_DEVICE,
get_next_registered_device}, _get_next_registered_device},
{ DM_EVENT_CMD_SET_TIMEOUT, set_timeout}, { DM_EVENT_CMD_SET_TIMEOUT, _set_timeout},
{ DM_EVENT_CMD_GET_TIMEOUT, get_timeout}, { DM_EVENT_CMD_GET_TIMEOUT, _get_timeout},
{ DM_EVENT_CMD_ACTIVE, active}, { DM_EVENT_CMD_ACTIVE, _active},
}, *req; }, *req;
for (req = requests; req < requests + sizeof(requests); req++) for (req = requests; req < requests + sizeof(requests); req++)
@ -1241,7 +1241,7 @@ static int handle_request(struct dm_event_daemon_message *msg,
} }
/* Process a request passed from the communication thread. */ /* Process a request passed from the communication thread. */
static int do_process_request(struct dm_event_daemon_message *msg) static int _do_process_request(struct dm_event_daemon_message *msg)
{ {
int ret; int ret;
static struct message_data message_data; static struct message_data message_data;
@ -1249,19 +1249,19 @@ static int do_process_request(struct dm_event_daemon_message *msg)
/* Parse the message. */ /* Parse the message. */
memset(&message_data, 0, sizeof(message_data)); memset(&message_data, 0, sizeof(message_data));
message_data.msg = msg; message_data.msg = msg;
if (msg->cmd != DM_EVENT_CMD_ACTIVE && !parse_message(&message_data)) { if (msg->cmd != DM_EVENT_CMD_ACTIVE && !_parse_message(&message_data)) {
stack; stack;
ret = -EINVAL; ret = -EINVAL;
} else } else
ret = handle_request(msg, &message_data); ret = _handle_request(msg, &message_data);
free_message(&message_data); _free_message(&message_data);
return ret; return ret;
} }
/* Only one caller at a time. */ /* Only one caller at a time. */
static void process_request(struct dm_event_fifos *fifos) static void _process_request(struct dm_event_fifos *fifos)
{ {
struct dm_event_daemon_message msg; struct dm_event_daemon_message msg;
@ -1271,10 +1271,10 @@ static void process_request(struct dm_event_fifos *fifos)
* Read the request from the client (client_read, client_write * Read the request from the client (client_read, client_write
* give true on success and false on failure). * give true on success and false on failure).
*/ */
if (!client_read(fifos, &msg)) if (!_client_read(fifos, &msg))
return; return;
msg.cmd = do_process_request(&msg); msg.cmd = _do_process_request(&msg);
if (!msg.data) { if (!msg.data) {
msg.data = dm_strdup(strerror(-msg.cmd)); msg.data = dm_strdup(strerror(-msg.cmd));
if (msg.data) if (msg.data)
@ -1285,20 +1285,20 @@ static void process_request(struct dm_event_fifos *fifos)
} }
} }
if (!client_write(fifos, &msg)) if (!_client_write(fifos, &msg))
stack; stack;
if (msg.data) if (msg.data)
dm_free(msg.data); dm_free(msg.data);
} }
static void cleanup_unused_threads(void) static void _cleanup_unused_threads(void)
{ {
int ret; int ret;
struct list *l; struct list *l;
struct thread_status *thread; struct thread_status *thread;
lock_mutex(); _lock_mutex();
while ((l = list_first(&_thread_registry_unused))) { while ((l = list_first(&_thread_registry_unused))) {
thread = list_item(l, struct thread_status); thread = list_item(l, struct thread_status);
if (thread->processing) { if (thread->processing) {
@ -1311,7 +1311,7 @@ static void cleanup_unused_threads(void)
} else if (thread->status == DM_THREAD_SHUTDOWN) { } else if (thread->status == DM_THREAD_SHUTDOWN) {
if (!thread->events) { if (!thread->events) {
/* turn codes negative -- should we be returning this? */ /* turn codes negative -- should we be returning this? */
ret = terminate_thread(thread); ret = _terminate_thread(thread);
if (ret == ESRCH) { if (ret == ESRCH) {
thread->status = DM_THREAD_DONE; thread->status = DM_THREAD_DONE;
@ -1332,27 +1332,27 @@ static void cleanup_unused_threads(void)
} else if (thread->status == DM_THREAD_DONE) { } else if (thread->status == DM_THREAD_DONE) {
list_del(l); list_del(l);
pthread_join(thread->thread, NULL); pthread_join(thread->thread, NULL);
lib_put(thread->dso_data); _lib_put(thread->dso_data);
free_thread_status(thread); _free_thread_status(thread);
} }
} }
out: out:
unlock_mutex(); _unlock_mutex();
} }
static void sig_alarm(int signum) static void _sig_alarm(int signum)
{ {
pthread_testcancel(); pthread_testcancel();
} }
/* Init thread signal handling. */ /* Init thread signal handling. */
static void init_thread_signals(void) static void _init_thread_signals(void)
{ {
sigset_t my_sigset; sigset_t my_sigset;
struct sigaction act; struct sigaction act;
memset(&act, 0, sizeof(act)); memset(&act, 0, sizeof(act));
act.sa_handler = sig_alarm; act.sa_handler = _sig_alarm;
sigaction(SIGALRM, &act, NULL); sigaction(SIGALRM, &act, NULL);
sigfillset(&my_sigset); sigfillset(&my_sigset);
@ -1372,7 +1372,7 @@ static void init_thread_signals(void)
* Set the global variable which the process should * Set the global variable which the process should
* be watching to determine when to exit. * be watching to determine when to exit.
*/ */
static void exit_handler(int sig) static void _exit_handler(int sig)
{ {
/* /*
* We exit when '_exit_now' is set. * We exit when '_exit_now' is set.
@ -1389,7 +1389,7 @@ static void exit_handler(int sig)
} }
static int lock_pidfile(void) static int _lock_pidfile(void)
{ {
int lf; int lf;
char pidfile[] = DMEVENTD_PIDFILE; char pidfile[] = DMEVENTD_PIDFILE;
@ -1400,13 +1400,13 @@ static int lock_pidfile(void)
if (flock(lf, LOCK_EX | LOCK_NB) < 0) if (flock(lf, LOCK_EX | LOCK_NB) < 0)
exit(EXIT_LOCKFILE_INUSE); exit(EXIT_LOCKFILE_INUSE);
if (!storepid(lf)) if (!_storepid(lf))
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
return 0; return 0;
} }
static void daemonize(void) static void _daemonize(void)
{ {
int status; int status;
int pid; int pid;
@ -1420,7 +1420,7 @@ static void daemonize(void)
fprintf(stderr, "Unable to restore signals."); fprintf(stderr, "Unable to restore signals.");
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
} }
signal(SIGTERM, &exit_handler); signal(SIGTERM, &_exit_handler);
pid = fork(); pid = fork();
@ -1478,12 +1478,12 @@ static void daemonize(void)
openlog("dmeventd", LOG_PID, LOG_DAEMON); openlog("dmeventd", LOG_PID, LOG_DAEMON);
lock_pidfile(); /* exits if failure */ _lock_pidfile(); /* exits if failure */
/* Set the rest of the signals to cause '_exit_now' to be set */ /* Set the rest of the signals to cause '_exit_now' to be set */
signal(SIGINT, &exit_handler); signal(SIGINT, &_exit_handler);
signal(SIGHUP, &exit_handler); signal(SIGHUP, &_exit_handler);
signal(SIGQUIT, &exit_handler); signal(SIGQUIT, &_exit_handler);
} }
int main(int argc, char *argv[]) int main(int argc, char *argv[])
@ -1492,16 +1492,16 @@ int main(int argc, char *argv[])
struct dm_event_fifos fifos; struct dm_event_fifos fifos;
//struct sys_log logdata = {DAEMON_NAME, LOG_DAEMON}; //struct sys_log logdata = {DAEMON_NAME, LOG_DAEMON};
daemonize(); _daemonize();
init_thread_signals(); _init_thread_signals();
//multilog_clear_logging(); //multilog_clear_logging();
//multilog_add_type(std_syslog, &logdata); //multilog_add_type(std_syslog, &logdata);
//multilog_init_verbose(std_syslog, _LOG_DEBUG); //multilog_init_verbose(std_syslog, _LOG_DEBUG);
//multilog_async(1); //multilog_async(1);
init_fifos(&fifos); _init_fifos(&fifos);
pthread_mutex_init(&_global_mutex, NULL); pthread_mutex_init(&_global_mutex, NULL);
@ -1510,7 +1510,7 @@ int main(int argc, char *argv[])
exit(EXIT_FAILURE); exit(EXIT_FAILURE);
#endif #endif
if ((ret = open_fifos(&fifos))) if ((ret = _open_fifos(&fifos)))
exit(EXIT_FIFO_FAILURE); exit(EXIT_FIFO_FAILURE);
/* Signal parent, letting them know we are ready to go. */ /* Signal parent, letting them know we are ready to go. */
@ -1518,8 +1518,8 @@ int main(int argc, char *argv[])
syslog(LOG_INFO, "dmeventd ready for processing."); syslog(LOG_INFO, "dmeventd ready for processing.");
while (!_exit_now) { while (!_exit_now) {
process_request(&fifos); _process_request(&fifos);
cleanup_unused_threads(); _cleanup_unused_threads();
if (!list_empty(&_thread_registry) if (!list_empty(&_thread_registry)
|| !list_empty(&_thread_registry_unused)) || !list_empty(&_thread_registry_unused))
_thread_registries_empty = 0; _thread_registries_empty = 0;
@ -1527,7 +1527,7 @@ int main(int argc, char *argv[])
_thread_registries_empty = 1; _thread_registries_empty = 1;
} }
exit_dm_lib(); _exit_dm_lib();
#ifdef MCL_CURRENT #ifdef MCL_CURRENT
munlockall(); munlockall();