static naming

daemons/dmeventd/dmeventd.c

@@ -168,36 +168,37 @@ static LIST_INIT(_thread_registry);
 static LIST_INIT(_thread_registry_unused);
 
 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_cond_t _timeout_cond = PTHREAD_COND_INITIALIZER;
 
 /* Allocate/free the status structure for a monitoring thread. */
-static struct thread_status *alloc_thread_status(struct message_data *data,
-						 struct dso_data *dso_data)
+static struct thread_status *_alloc_thread_status(struct message_data *data,
+						  struct dso_data *dso_data)
 {
 	struct thread_status *ret = (typeof(ret)) dm_malloc(sizeof(*ret));
 
-	if (ret) {
-		if (!memset(ret, 0, sizeof(*ret)) ||
-		    !(ret->device.uuid = dm_strdup(data->device_uuid))) {
-			dm_free(ret);
-			ret = NULL;
-		} else {
-			ret->current_task = NULL;
-			ret->device.name = NULL;
-			ret->device.major = ret->device.minor = 0;
-			ret->dso_data = dso_data;
-			ret->events = data->events.field;
-			ret->timeout = data->timeout.secs;
-			list_init(&ret->timeout_list);
-		}
+	if (!ret)
+		return NULL;
+
+	if (!memset(ret, 0, sizeof(*ret)) ||
+	    !(ret->device.uuid = dm_strdup(data->device_uuid))) {
+		dm_free(ret);
+		return NULL;
 	}
 
+	ret->current_task = NULL;
+	ret->device.name = NULL;
+	ret->device.major = ret->device.minor = 0;
+	ret->dso_data = dso_data;
+	ret->events = data->events.field;
+	ret->timeout = data->timeout.secs;
+	list_init(&ret->timeout_list);
+
 	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.name);
@@ -205,7 +206,7 @@ static void free_thread_status(struct thread_status *thread)
 }
 
 /* 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));
 
@@ -221,7 +222,7 @@ static struct dso_data *alloc_dso_data(struct message_data *data)
 	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);
@@ -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
    make delimiter a parameter then) */
-static const char delimiter = ' ';
-static int fetch_string(char **ptr, char **src)
+static int _fetch_string(char **ptr, char **src, const char delimiter)
 {
 	int ret = 0;
 	char *p;
@@ -262,7 +262,7 @@ static int fetch_string(char **ptr, char **src)
 }
 
 /* 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)
 		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. */
-static int parse_message(struct message_data *message_data)
+static int _parse_message(struct message_data *message_data)
 {
 	int ret = 0;
 	char *p = message_data->msg->data;
@@ -286,10 +286,10 @@ static int parse_message(struct message_data *message_data)
 	 * Retrieve application identifier, mapped device
 	 * path and events # string from message.
 	 */
-	if (fetch_string(&message_data->dso_name, &p) &&
-	    fetch_string(&message_data->device_uuid, &p) &&
-	    fetch_string(&message_data->events.str, &p) &&
-	    fetch_string(&message_data->timeout.str, &p)) {
+	if (_fetch_string(&message_data->dso_name, &p, ' ') &&
+	    _fetch_string(&message_data->device_uuid, &p, ' ') &&
+	    _fetch_string(&message_data->events.str, &p, ' ') &&
+	    _fetch_string(&message_data->timeout.str, &p, ' ')) {
 		if (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. */
-static int lock_mutex(void)
+static int _lock_mutex(void)
 {
 	return pthread_mutex_lock(&_global_mutex);
 }
 
-static int unlock_mutex(void)
+static int _unlock_mutex(void)
 {
 	return pthread_mutex_unlock(&_global_mutex);
 }
 
 /* Store pid in pidfile. */
-static int storepid(int lf)
+static int _storepid(int lf)
 {
 	int len;
 	char pid[8];
@@ -348,7 +348,7 @@ static int storepid(int lf)
 }
 
 /* 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_info dmi;
@@ -391,7 +391,7 @@ static int fill_device_data(struct thread_status *ts)
  *
  * 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;
 
@@ -403,35 +403,35 @@ static struct thread_status *lookup_thread_status(struct message_data *data)
 }
 
 /* Cleanup at exit. */
-static void exit_dm_lib(void)
+static void _exit_dm_lib(void)
 {
 	dm_lib_release();
 	dm_lib_exit();
 }
 
-static void exit_timeout(void *unused)
+static void _exit_timeout(void *unused)
 {
 	_timeout_running = 0;
 	pthread_mutex_unlock(&_timeout_mutex);
 }
 
 /* Wake up monitor threads every so often. */
-static void *timeout_thread(void *unused)
+static void *_timeout_thread(void *unused)
 {
 	struct timespec timeout;
 	time_t curr_time;
 
 	timeout.tv_nsec = 0;
-	pthread_cleanup_push(exit_timeout, NULL);
+	pthread_cleanup_push(_exit_timeout, NULL);
 	pthread_mutex_lock(&_timeout_mutex);
 
-	while (!list_empty(&timeout_registry)) {
+	while (!list_empty(&_timeout_registry)) {
 		struct thread_status *thread;
 
 		timeout.tv_sec = (time_t) -1;
 		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) {
 				thread->next_time = curr_time + thread->timeout;
 				pthread_kill(thread->thread, SIGALRM);
@@ -450,7 +450,7 @@ static void *timeout_thread(void *unused)
 	return NULL;
 }
 
-static int register_for_timeout(struct thread_status *thread)
+static int _register_for_timeout(struct thread_status *thread)
 {
 	int ret = 0;
 
@@ -459,7 +459,7 @@ static int register_for_timeout(struct thread_status *thread)
 	thread->next_time = time(NULL) + thread->timeout;
 
 	if (list_empty(&thread->timeout_list)) {
-		list_add(&timeout_registry, &thread->timeout_list);
+		list_add(&_timeout_registry, &thread->timeout_list);
 		if (_timeout_running)
 			pthread_cond_signal(&_timeout_cond);
 	}
@@ -468,7 +468,7 @@ static int register_for_timeout(struct thread_status *thread)
 		pthread_t timeout_id;
 
 		if (!(ret = -pthread_create(&timeout_id, NULL,
-					    timeout_thread, NULL)))
+					    _timeout_thread, NULL)))
 			_timeout_running = 1;
 	}
 
@@ -477,7 +477,7 @@ static int register_for_timeout(struct thread_status *thread)
 	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);
 	if (!list_empty(&thread->timeout_list)) {
@@ -487,7 +487,7 @@ static void unregister_for_timeout(struct thread_status *thread)
 	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, ...)
 {
 	va_list ap;
@@ -512,7 +512,7 @@ static void no_intr_log(int level, const char *file, int line,
 		fprintf(stdout, "\n");
 }
 
-static sigset_t unblock_sigalrm(void)
+static sigset_t _unblock_sigalrm(void)
 {
 	sigset_t set, old;
 
@@ -527,7 +527,7 @@ static sigset_t unblock_sigalrm(void)
 #define DM_WAIT_FATAL 2
 
 /* 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;
 	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,
 	 * either for a timeout event, or to cancel the thread.
 	 */
-	set = unblock_sigalrm();
-	dm_log_init(no_intr_log);
+	set = _unblock_sigalrm();
+	dm_log_init(_no_intr_log);
 	errno = 0;
 	if (dm_task_run(dmt)) {
 		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. */
-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,
 						 thread->device.uuid,
@@ -594,7 +594,7 @@ static int do_register_device(struct thread_status *thread)
 }
 
 /* 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,
 						   thread->device.uuid,
@@ -603,17 +603,17 @@ static int do_unregister_device(struct thread_status *thread)
 }
 
 /* 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 cleanup handler to unregister device. */
-static void monitor_unregister(void *arg)
+static void _monitor_unregister(void *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__,
 		       thread->device.name);
 	if (thread->current_task)
@@ -622,25 +622,25 @@ static void monitor_unregister(void *arg)
 }
 
 /* Device monitoring thread. */
-static void *monitor_thread(void *arg)
+static void *_monitor_thread(void *arg)
 {
 	struct thread_status *thread = arg;
 	int wait_error = 0;
 	struct dm_task *task;
 
 	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. */
-	lock_mutex();
+	_lock_mutex();
 	thread->status = DM_THREAD_RUNNING;
-	unlock_mutex();
+	_unlock_mutex();
 
 	/* Loop forever awaiting/analyzing device events. */
 	while (1) {
 		thread->current_events = 0;
 
-		wait_error = event_wait(thread, &task);
+		wait_error = _event_wait(thread, &task);
 		if (wait_error == DM_WAIT_RETRY)
 			continue;
 
@@ -655,39 +655,39 @@ static void *monitor_thread(void *arg)
 		/*
 		 * 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
 		 * those events haven't been processed yet, call
 		 * the DSO's process_event() handler.
 		 */
-		lock_mutex();
+		_lock_mutex();
 		if (thread->status == DM_THREAD_SHUTDOWN) {
-			unlock_mutex();
+			_unlock_mutex();
 			break;
 		}
-		unlock_mutex();
+		_unlock_mutex();
 
 		if (thread->events & thread->current_events) {
-			lock_mutex();
+			_lock_mutex();
 			thread->processing = 1;
-			unlock_mutex();
+			_unlock_mutex();
 
-			do_process_event(thread, task);
+			_do_process_event(thread, task);
 			dm_task_destroy(task);
 			thread->current_task = NULL;
 
-			lock_mutex();
+			_lock_mutex();
 			thread->processing = 0;
-			unlock_mutex();
+			_unlock_mutex();
 		} else {
 			dm_task_destroy(task);
 			thread->current_task = NULL;
 		}
 	}
 
-	lock_mutex();
+	_lock_mutex();
 	thread->status = DM_THREAD_DONE;
-	unlock_mutex();
+	_unlock_mutex();
 
 	pthread_cleanup_pop(1);
 
@@ -695,12 +695,12 @@ static void *monitor_thread(void *arg)
 }
 
 /* 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;
 
@@ -711,41 +711,41 @@ static int terminate_thread(struct thread_status *thread)
 }
 
 /* DSO reference counting. */
-static void lib_get(struct dso_data *data)
+static void _lib_get(struct dso_data *data)
 {
 	data->ref_count++;
 }
 
-static void lib_put(struct dso_data *data)
+static void _lib_put(struct dso_data *data)
 {
 	if (!--data->ref_count) {
 		dlclose(data->dso_handle);
 		UNLINK_DSO(data);
-		free_dso_data(data);
+		_free_dso_data(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;
 
-	lock_mutex();
+	_lock_mutex();
 
 	list_iterate_items(dso_data, &_dso_registry)
 	    if (!strcmp(data->dso_name, dso_data->dso_name)) {
-		lib_get(dso_data);
+		_lib_get(dso_data);
 		ret = dso_data;
 		break;
 	}
 
-	unlock_mutex();
+	_unlock_mutex();
 
 	return ret;
 }
 
 /* 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)
 {
 	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)
 {
-	return lookup_symbol(dl, data, (void *) &data->process_event,
+	return _lookup_symbol(dl, data, (void *) &data->process_event,
 			     "process_event") &&
-	    lookup_symbol(dl, data, (void *) &data->register_device,
+	    _lookup_symbol(dl, data, (void *) &data->register_device,
 			  "register_device") &&
-	    lookup_symbol(dl, data, (void *) &data->unregister_device,
+	    _lookup_symbol(dl, data, (void *) &data->unregister_device,
 			  "unregister_device");
 }
 
 /* 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;
 	struct dso_data *ret = NULL;
@@ -780,13 +780,13 @@ static struct dso_data *load_dso(struct message_data *data)
 		return NULL;
 	}
 
-	if (!(ret = alloc_dso_data(data))) {
+	if (!(ret = _alloc_dso_data(data))) {
 		dlclose(dl);
 		return NULL;
 	}
 
 	if (!(lookup_symbols(dl, ret))) {
-		free_dso_data(ret);
+		_free_dso_data(ret);
 		dlclose(dl);
 		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.
 	 */
 	ret->dso_handle = dl;
-	lib_get(ret);
+	_lib_get(ret);
 
-	lock_mutex();
+	_lock_mutex();
 	LINK_DSO(ret);
-	unlock_mutex();
+	_unlock_mutex();
 
 	return ret;
 }
 
 /* Return success on daemon active check. */
-static int active(struct message_data *message_data)
+static int _active(struct message_data *message_data)
 {
 	return 0;
 }
@@ -817,14 +817,14 @@ static int active(struct message_data *message_data)
  * Only one caller at a time here, because we use
  * 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;
 	struct thread_status *thread, *thread_new = NULL;
 	struct dso_data *dso_data;
 
-	if (!(dso_data = lookup_dso(message_data)) &&
-	    !(dso_data = load_dso(message_data))) {
+	if (!(dso_data = _lookup_dso(message_data)) &&
+	    !(dso_data = _load_dso(message_data))) {
 		stack;
 #ifdef ELIBACC
 		ret = -ELIBACC;
@@ -835,35 +835,35 @@ static int register_for_event(struct message_data *message_data)
 	}
 
 	/* 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;
 		ret = -ENOMEM;
 		goto out;
 	}
 
-	if (!fill_device_data(thread_new)) {
+	if (!_fill_device_data(thread_new)) {
 		stack;
 		ret = -ENODEV;
 		goto out;
 	}
 
-	lock_mutex();
+	_lock_mutex();
 
-	if (!(thread = lookup_thread_status(message_data))) {
-		unlock_mutex();
+	if (!(thread = _lookup_thread_status(message_data))) {
+		_unlock_mutex();
 
-		if (!(ret = do_register_device(thread_new)))
+		if (!(ret = _do_register_device(thread_new)))
 			goto out;
 
 		thread = thread_new;
 		thread_new = NULL;
 
 		/* Try to create the monitoring thread for this device. */
-		lock_mutex();
-		if ((ret = -create_thread(thread))) {
-			unlock_mutex();
-			do_unregister_device(thread);
-			free_thread_status(thread);
+		_lock_mutex();
+		if ((ret = -_create_thread(thread))) {
+			_unlock_mutex();
+			_do_unregister_device(thread);
+			_free_thread_status(thread);
 			goto out;
 		} else
 			LINK_THREAD(thread);
@@ -872,7 +872,7 @@ static int register_for_event(struct message_data *message_data)
 	/* Or event # into events bitfield. */
 	thread->events |= message_data->events.field;
 
-	unlock_mutex();
+	_unlock_mutex();
 
 	/* FIXME - If you fail to register for timeout events, you
 	   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
 	   DM_EVENT_TIMEOUT events */
 	if (thread->events & DM_EVENT_TIMEOUT)
-		ret = -register_for_timeout(thread);
+		ret = -_register_for_timeout(thread);
 
       out:
 	/*
@@ -889,7 +889,7 @@ static int register_for_event(struct message_data *message_data)
 	 * the lock in case we haven't used it.
 	 */
 	if (thread_new)
-		free_thread_status(thread_new);
+		_free_thread_status(thread_new);
 
 	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().
  */
-static int unregister_for_event(struct message_data *message_data)
+static int _unregister_for_event(struct message_data *message_data)
 {
 	int ret = 0;
 	struct thread_status *thread;
@@ -908,10 +908,10 @@ static int unregister_for_event(struct message_data *message_data)
 	 * Clear event in bitfield and deactivate
 	 * monitoring thread in case bitfield is 0.
 	 */
-	lock_mutex();
+	_lock_mutex();
 
-	if (!(thread = lookup_thread_status(message_data))) {
-		unlock_mutex();
+	if (!(thread = _lookup_thread_status(message_data))) {
+		_unlock_mutex();
 		ret = -ENODEV;
 		goto out;
 	}
@@ -919,7 +919,7 @@ static int unregister_for_event(struct message_data *message_data)
 	thread->events &= ~message_data->events.field;
 
 	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 ->
 	 * unlink and terminate its monitoring thread.
@@ -928,7 +928,7 @@ static int unregister_for_event(struct message_data *message_data)
 		UNLINK_THREAD(thread);
 		LINK(thread, &_thread_registry_unused);
 	}
-	unlock_mutex();
+	_unlock_mutex();
 
       out:
 	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().
  */
-static int registered_device(struct message_data *message_data,
+static int _registered_device(struct message_data *message_data,
 			     struct thread_status *thread)
 {
 	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);
 
-	unlock_mutex();
+	_unlock_mutex();
 
 	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)
 {
 	/* 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;
 }
 
-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;
 	struct thread_status *thread;
 
-	lock_mutex();
+	_lock_mutex();
 
 	/* Iterate list of threads checking if we want a particular one. */
 	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,
 					      thread)))
 		break;
@@ -1006,39 +1006,39 @@ static int _get_registered_device(struct message_data *message_data, int next)
 			goto out;
 
 		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:
-	unlock_mutex();
+	_unlock_mutex();
 
 	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;
 
-	lock_mutex();
-	if ((thread = lookup_thread_status(message_data)))
+	_lock_mutex();
+	if ((thread = _lookup_thread_status(message_data)))
 		thread->timeout = message_data->timeout.secs;
-	unlock_mutex();
+	_unlock_mutex();
 
 	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 dm_event_daemon_message *msg = message_data->msg;
@@ -1046,21 +1046,21 @@ static int get_timeout(struct message_data *message_data)
 	if (msg->data)
 		dm_free(msg->data);
 
-	lock_mutex();
-	if ((thread = lookup_thread_status(message_data))) {
+	_lock_mutex();
+	if ((thread = _lookup_thread_status(message_data))) {
 		msg->size =
 		    dm_asprintf(&(msg->data), "%" PRIu32, thread->timeout);
 	} else {
 		msg->data = NULL;
 		msg->size = 0;
 	}
-	unlock_mutex();
+	_unlock_mutex();
 
 	return thread ? 0 : -ENODEV;
 }
 
 /* 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));
 
@@ -1069,7 +1069,7 @@ static void init_fifos(struct dm_event_fifos *fifos)
 }
 
 /* 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 */
 	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
  * 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 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.
  */
-static int client_write(struct dm_event_fifos *fifos,
+static int _client_write(struct dm_event_fifos *fifos,
 			struct dm_event_daemon_message *msg)
 {
 	unsigned bytes = 0;
@@ -1216,21 +1216,21 @@ static int client_write(struct dm_event_fifos *fifos,
  * We put the request handling functions into
  * 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)
 {
 	static struct {
 		unsigned int cmd;
 		int (*f)(struct message_data *);
 	} requests[] = {
-		{ DM_EVENT_CMD_REGISTER_FOR_EVENT, register_for_event},
-		{ DM_EVENT_CMD_UNREGISTER_FOR_EVENT, unregister_for_event},
-		{ DM_EVENT_CMD_GET_REGISTERED_DEVICE, get_registered_device},
+		{ DM_EVENT_CMD_REGISTER_FOR_EVENT, _register_for_event},
+		{ DM_EVENT_CMD_UNREGISTER_FOR_EVENT, _unregister_for_event},
+		{ DM_EVENT_CMD_GET_REGISTERED_DEVICE, _get_registered_device},
 		{ DM_EVENT_CMD_GET_NEXT_REGISTERED_DEVICE,
-			get_next_registered_device},
-		{ DM_EVENT_CMD_SET_TIMEOUT, set_timeout},
-		{ DM_EVENT_CMD_GET_TIMEOUT, get_timeout},
-		{ DM_EVENT_CMD_ACTIVE, active},
+			_get_next_registered_device},
+		{ DM_EVENT_CMD_SET_TIMEOUT, _set_timeout},
+		{ DM_EVENT_CMD_GET_TIMEOUT, _get_timeout},
+		{ DM_EVENT_CMD_ACTIVE, _active},
 	}, *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. */
-static int do_process_request(struct dm_event_daemon_message *msg)
+static int _do_process_request(struct dm_event_daemon_message *msg)
 {
 	int ret;
 	static struct message_data message_data;
@@ -1249,19 +1249,19 @@ static int do_process_request(struct dm_event_daemon_message *msg)
 	/* Parse the message. */
 	memset(&message_data, 0, sizeof(message_data));
 	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;
 		ret = -EINVAL;
 	} else
-		ret = handle_request(msg, &message_data);
+		ret = _handle_request(msg, &message_data);
 
-	free_message(&message_data);
+	_free_message(&message_data);
 
 	return ret;
 }
 
 /* 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;
 
@@ -1271,10 +1271,10 @@ static void process_request(struct dm_event_fifos *fifos)
 	 * Read the request from the client (client_read, client_write
 	 * give true on success and false on failure).
 	 */
-	if (!client_read(fifos, &msg))
+	if (!_client_read(fifos, &msg))
 		return;
 
-	msg.cmd = do_process_request(&msg);
+	msg.cmd = _do_process_request(&msg);
 	if (!msg.data) {
 		msg.data = dm_strdup(strerror(-msg.cmd));
 		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;
 
 	if (msg.data)
 		dm_free(msg.data);
 }
 
-static void cleanup_unused_threads(void)
+static void _cleanup_unused_threads(void)
 {
 	int ret;
 	struct list *l;
 	struct thread_status *thread;
 
-	lock_mutex();
+	_lock_mutex();
 	while ((l = list_first(&_thread_registry_unused))) {
 		thread = list_item(l, struct thread_status);
 		if (thread->processing) {
@@ -1311,7 +1311,7 @@ static void cleanup_unused_threads(void)
 		} else if (thread->status == DM_THREAD_SHUTDOWN) {
 			if (!thread->events) {
 				/* turn codes negative -- should we be returning this? */
-				ret = terminate_thread(thread);
+				ret = _terminate_thread(thread);
 
 				if (ret == ESRCH) {
 					thread->status = DM_THREAD_DONE;
@@ -1332,27 +1332,27 @@ static void cleanup_unused_threads(void)
 		} else if (thread->status == DM_THREAD_DONE) {
 			list_del(l);
 			pthread_join(thread->thread, NULL);
-			lib_put(thread->dso_data);
-			free_thread_status(thread);
+			_lib_put(thread->dso_data);
+			_free_thread_status(thread);
 		}
 	}
       out:
-	unlock_mutex();
+	_unlock_mutex();
 }
 
-static void sig_alarm(int signum)
+static void _sig_alarm(int signum)
 {
 	pthread_testcancel();
 }
 
 /* Init thread signal handling. */
-static void init_thread_signals(void)
+static void _init_thread_signals(void)
 {
 	sigset_t my_sigset;
 	struct sigaction act;
 
 	memset(&act, 0, sizeof(act));
-	act.sa_handler = sig_alarm;
+	act.sa_handler = _sig_alarm;
 	sigaction(SIGALRM, &act, NULL);
 	sigfillset(&my_sigset);
 
@@ -1372,7 +1372,7 @@ static void init_thread_signals(void)
  * Set the global variable which the process should
  * 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.
@@ -1389,7 +1389,7 @@ static void exit_handler(int sig)
 
 }
 
-static int lock_pidfile(void)
+static int _lock_pidfile(void)
 {
 	int lf;
 	char pidfile[] = DMEVENTD_PIDFILE;
@@ -1400,13 +1400,13 @@ static int lock_pidfile(void)
 	if (flock(lf, LOCK_EX | LOCK_NB) < 0)
 		exit(EXIT_LOCKFILE_INUSE);
 
-	if (!storepid(lf))
+	if (!_storepid(lf))
 		exit(EXIT_FAILURE);
 
 	return 0;
 }
 
-static void daemonize(void)
+static void _daemonize(void)
 {
 	int status;
 	int pid;
@@ -1420,7 +1420,7 @@ static void daemonize(void)
 		fprintf(stderr, "Unable to restore signals.");
 		exit(EXIT_FAILURE);
 	}
-	signal(SIGTERM, &exit_handler);
+	signal(SIGTERM, &_exit_handler);
 
 	pid = fork();
 
@@ -1478,12 +1478,12 @@ static void daemonize(void)
 
 	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 */
-	signal(SIGINT, &exit_handler);
-	signal(SIGHUP, &exit_handler);
-	signal(SIGQUIT, &exit_handler);
+	signal(SIGINT, &_exit_handler);
+	signal(SIGHUP, &_exit_handler);
+	signal(SIGQUIT, &_exit_handler);
 }
 
 int main(int argc, char *argv[])
@@ -1492,16 +1492,16 @@ int main(int argc, char *argv[])
 	struct dm_event_fifos fifos;
 	//struct sys_log logdata = {DAEMON_NAME, LOG_DAEMON};
 
-	daemonize();
+	_daemonize();
 
-	init_thread_signals();
+	_init_thread_signals();
 
 	//multilog_clear_logging();
 	//multilog_add_type(std_syslog, &logdata);
 	//multilog_init_verbose(std_syslog, _LOG_DEBUG);
 	//multilog_async(1);
 
-	init_fifos(&fifos);
+	_init_fifos(&fifos);
 
 	pthread_mutex_init(&_global_mutex, NULL);
 
@@ -1510,7 +1510,7 @@ int main(int argc, char *argv[])
 		exit(EXIT_FAILURE);
 #endif
 
-	if ((ret = open_fifos(&fifos)))
+	if ((ret = _open_fifos(&fifos)))
 		exit(EXIT_FIFO_FAILURE);
 
 	/* 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.");
 
 	while (!_exit_now) {
-		process_request(&fifos);
-		cleanup_unused_threads();
+		_process_request(&fifos);
+		_cleanup_unused_threads();
 		if (!list_empty(&_thread_registry)
 		    || !list_empty(&_thread_registry_unused))
 			_thread_registries_empty = 0;
@@ -1527,7 +1527,7 @@ int main(int argc, char *argv[])
 			_thread_registries_empty = 1;
 	}
 
-	exit_dm_lib();
+	_exit_dm_lib();
 
 #ifdef MCL_CURRENT
 	munlockall();