[PATCH 1/3] ipc: convert int -> int32_t; unsigned int -> uint32_t

[Angus Salkeld]

Signed-off-by: Angus Salkeld <asalkeld(a)redhat.com&gt;
---
 include/qb/qbipcc.h |   16 ++--
 include/qb/qbipcs.h |   56 +++++++-------
 lib/ipcc.c          |   92 ++++++++++++-----------
 lib/ipcs.c          |  205 +++++++++++++++++++++++++--------------------------
 4 files changed, 184 insertions(+), 185 deletions(-)

diff --git a/include/qb/qbipcc.h b/include/qb/qbipcc.h
index 517a23b..4ccc626 100644
--- a/include/qb/qbipcc.h
+++ b/include/qb/qbipcc.h
@@ -36,37 +36,37 @@ extern "C" {
 
 int32_t
 qb_ipcc_service_connect(const char *socket_name,
-			unsigned int service,
+			uint32_t service,
 			size_t request_size,
 			size_t respnse__size,
 			size_t dispatch_size, qb_hdb_handle_t * handle);
 
 int32_t qb_ipcc_service_disconnect(qb_hdb_handle_t handle);
 
-int32_t qb_ipcc_fd_get(qb_hdb_handle_t handle, int *fd);
+int32_t qb_ipcc_fd_get(qb_hdb_handle_t handle, int32_t * fd);
 
-int32_t qb_ipcc_dispatch_get(qb_hdb_handle_t handle, void **buf, int timeout);
+int32_t qb_ipcc_dispatch_get(qb_hdb_handle_t handle, void **buf,
+			     int32_t timeout);
 
 int32_t qb_ipcc_dispatch_put(qb_hdb_handle_t handle);
 
 int32_t
 qb_ipcc_dispatch_flow_control_get(qb_hdb_handle_t handle,
-				  unsigned int *flow_control_state);
+				  uint32_t * flow_control_state);
 
 int32_t
 qb_ipcc_msg_send(qb_hdb_handle_t handle,
-		 const struct iovec *iov, unsigned int iov_len);
+		 const struct iovec *iov, uint32_t iov_len);
 
 int32_t
 qb_ipcc_msg_send_reply_receive(qb_hdb_handle_t handle,
 			       const struct iovec *iov,
-			       unsigned int iov_len,
-			       void *res_msg, size_t res_len);
+			       uint32_t iov_len, void *res_msg, size_t res_len);
 
 int32_t
 qb_ipcc_msg_send_reply_receive_in_buf_get(qb_hdb_handle_t handle,
 					  const struct iovec *iov,
-					  unsigned int iov_len, void **res_msg);
+					  uint32_t iov_len, void **res_msg);
 
 int32_t qb_ipcc_msg_send_reply_receive_in_buf_put(qb_hdb_handle_t handle);
 
diff --git a/include/qb/qbipcs.h b/include/qb/qbipcs.h
index 8292076..ed6f5c0 100644
--- a/include/qb/qbipcs.h
+++ b/include/qb/qbipcs.h
@@ -33,36 +33,36 @@ extern "C" {
 
 struct iovec;
 
-typedef int (*qb_ipcs_init_fn_lvalue) (void *conn);
-typedef int (*qb_ipcs_exit_fn_lvalue) (void *conn);
+typedef int32_t(*qb_ipcs_init_fn_lvalue) (void *conn);
+typedef int32_t(*qb_ipcs_exit_fn_lvalue) (void *conn);
 typedef void (*qb_ipcs_handler_fn_lvalue) (void *conn, const void *msg);
 
 struct qb_ipcs_init_state {
 	const char *socket_name;
-	int sched_policy;
+	int32_t sched_policy;
 	const struct sched_param *sched_param;
 	void *(*malloc) (size_t size);
 	void (*free) (void *ptr);
-	int (*service_available) (unsigned int service);
-	int (*private_data_size_get) (unsigned int service);
-	int (*security_valid) (int uid, int gid);
+	int32_t(*service_available) (uint32_t service);
+	int32_t(*private_data_size_get) (uint32_t service);
+	int32_t(*security_valid) (int32_t uid, int32_t gid);
 	void (*serialize_lock) (void);
 	void (*serialize_unlock) (void);
-	int (*sending_allowed) (unsigned int service, unsigned int id,
-				const void *msg,
-				void *sending_allowed_private_data);
+	int32_t(*sending_allowed) (uint32_t service, uint32_t id,
+				   const void *msg,
+				   void *sending_allowed_private_data);
 	void (*sending_allowed_release) (void *sending_allowed_private_data);
-	void (*poll_accept_add) (int fd);
-	void (*poll_dispatch_add) (int fd, void *context);
-	void (*poll_dispatch_modify) (int fd, int events);
-	void (*poll_dispatch_destroy) (int fd, void *context);
+	void (*poll_accept_add) (int32_t fd);
+	void (*poll_dispatch_add) (int32_t fd, void *context);
+	void (*poll_dispatch_modify) (int32_t fd, int32_t events);
+	void (*poll_dispatch_destroy) (int32_t fd, void *context);
 	void (*fatal_error) (const char *error_msg);
-	 qb_ipcs_init_fn_lvalue(*init_fn_get) (unsigned int service);
-	 qb_ipcs_exit_fn_lvalue(*exit_fn_get) (unsigned int service);
-	 qb_ipcs_handler_fn_lvalue(*handler_fn_get) (unsigned int service,
-						     unsigned int id);
-	 qb_hdb_handle_t(*stats_create_connection) (const char *name, pid_t pid,
-						    int fd);
+	qb_ipcs_init_fn_lvalue(*init_fn_get) (uint32_t service);
+	qb_ipcs_exit_fn_lvalue(*exit_fn_get) (uint32_t service);
+	qb_ipcs_handler_fn_lvalue(*handler_fn_get) (uint32_t service,
+						    uint32_t id);
+	qb_hdb_handle_t(*stats_create_connection) (const char *name, pid_t pid,
+						   int32_t fd);
 	void (*stats_destroy_connection) (qb_hdb_handle_t handle);
 	void (*stats_update_value) (qb_hdb_handle_t handle,
 				    const char *name, const void *value,
@@ -77,15 +77,15 @@ void qb_ipcs_ipc_init(struct qb_ipcs_init_state *init_state);
 
 void *qb_ipcs_private_data_get(void *conn);
 
-int qb_ipcs_response_send(void *conn, const void *msg, size_t mlen);
+int32_t qb_ipcs_response_send(void *conn, const void *msg, size_t mlen);
 
-int qb_ipcs_response_iov_send(void *conn,
-			      const struct iovec *iov, unsigned int iov_len);
+int32_t qb_ipcs_response_iov_send(void *conn,
+				  const struct iovec *iov, uint32_t iov_len);
 
-int qb_ipcs_dispatch_send(void *conn, const void *msg, size_t mlen);
+int32_t qb_ipcs_dispatch_send(void *conn, const void *msg, size_t mlen);
 
-int qb_ipcs_dispatch_iov_send(void *conn,
-			      const struct iovec *iov, unsigned int iov_len);
+int32_t qb_ipcs_dispatch_iov_send(void *conn,
+				  const struct iovec *iov, uint32_t iov_len);
 
 void qb_ipcs_refcount_inc(void *conn);
 
@@ -93,11 +93,11 @@ void qb_ipcs_refcount_dec(void *conn);
 
 void qb_ipcs_ipc_exit(void);
 
-int qb_ipcs_ipc_service_exit(unsigned int service);
+int32_t qb_ipcs_ipc_service_exit(uint32_t service);
 
-int qb_ipcs_handler_accept(int fd, int revent, void *context);
+int32_t qb_ipcs_handler_accept(int32_t fd, int32_t revent, void *context);
 
-int qb_ipcs_handler_dispatch(int fd, int revent, void *context);
+int32_t qb_ipcs_handler_dispatch(int32_t fd, int32_t revent, void *context);
 
 /* *INDENT-OFF* */
 #ifdef __cplusplus
diff --git a/lib/ipcc.c b/lib/ipcc.c
index 259f4be..e35f570 100644
--- a/lib/ipcc.c
+++ b/lib/ipcc.c
@@ -43,13 +43,13 @@
 #define IPC_SEMWAIT_TIMEOUT 2
 
 struct ipc_instance {
-	int fd;
+	int32_t fd;
 #if _POSIX_THREAD_PROCESS_SHARED < 1
-	int semid;
+	int32_t semid;
 #endif
-	int flow_control_state;
+	int32_t flow_control_state;
 	struct control_buffer *control_buffer;
-	qb_ringbuffer_t * request_rb;
+	qb_ringbuffer_t *request_rb;
 	char *response_buffer;
 	char *dispatch_buffer;
 	size_t control_size;
@@ -71,9 +71,9 @@ DECLARE_HDB_DATABASE(ipc_hdb, ipc_hdb_destructor);
 #endif
 
 #ifdef SO_NOSIGPIPE
-static void socket_nosigpipe(int s)
+static void socket_nosigpipe(int32_t s)
 {
-	int on = 1;
+	int32_t on = 1;
 	setsockopt(s, SOL_SOCKET, SO_NOSIGPIPE, (void *)&on, sizeof(on));
 }
 #endif
@@ -82,14 +82,14 @@ static void socket_nosigpipe(int s)
 #define MSG_NOSIGNAL 0
 #endif
 
-static int32_t socket_send(int s, void *msg, size_t len)
+static int32_t socket_send(int32_t s, void *msg, size_t len)
 {
 	int32_t res = 0;
-	int result;
+	int32_t result;
 	struct msghdr msg_send;
 	struct iovec iov_send;
 	char *rbuf = msg;
-	int processed = 0;
+	int32_t processed = 0;
 
 	msg_send.msg_iov = &iov_send;
 	msg_send.msg_iovlen = 1;
@@ -135,14 +135,14 @@ res_exit:
 	return (res);
 }
 
-static int32_t socket_recv(int s, void *msg, size_t len)
+static int32_t socket_recv(int32_t s, void *msg, size_t len)
 {
 	int32_t res = 0;
-	int result;
+	int32_t result;
 	struct msghdr msg_recv;
 	struct iovec iov_recv;
 	char *rbuf = msg;
-	int processed = 0;
+	int32_t processed = 0;
 
 	msg_recv.msg_iov = &iov_recv;
 	msg_recv.msg_iovlen = 1;
@@ -195,11 +195,11 @@ res_exit:
 }
 
 #if _POSIX_THREAD_PROCESS_SHARED < 1
-static int priv_change_send(struct ipc_instance *ipc_instance)
+static int32_t priv_change_send(struct ipc_instance *ipc_instance)
 {
 	char buf_req;
 	mar_req_priv_change req_priv_change;
-	unsigned int res;
+	int32_t res;
 
 	req_priv_change.euid = geteuid();
 	/*
@@ -228,21 +228,21 @@ static int priv_change_send(struct ipc_instance *ipc_instance)
 
 #if defined(_SEM_SEMUN_UNDEFINED)
 union semun {
-	int val;
+	int32_t val;
 	struct semid_ds *buf;
-	unsigned short int *array;
+	unsigned short int32_t *array;
 	struct seminfo *__buf;
 };
 #endif
 #endif
 
-static int
+static int32_t
 circular_memory_map(char *path, const char *file, void **buf, size_t bytes)
 {
-	int fd;
+	int32_t fd;
 	void *addr_orig;
 	void *addr;
-	int res;
+	int32_t res;
 
 	sprintf(path, "/dev/shm/%s", file);
 
@@ -301,7 +301,7 @@ circular_memory_map(char *path, const char *file, void **buf, size_t
bytes)
 
 static void memory_unmap(void *addr, size_t bytes)
 {
-	int res;
+	int32_t res;
 
 	res = munmap(addr, bytes);
 }
@@ -321,12 +321,13 @@ void ipc_hdb_destructor(void *context)
 		     (ipc_instance->dispatch_size) << 1);
 }
 
-static int memory_map(char *path, const char *file, void **buf, size_t bytes)
+static int32_t memory_map(char *path, const char *file, void **buf,
+			  size_t bytes)
 {
-	int fd;
+	int32_t fd;
 	void *addr_orig;
 	void *addr;
-	int res;
+	int32_t res;
 
 	sprintf(path, "/dev/shm/%s", file);
 
@@ -374,7 +375,7 @@ static int memory_map(char *path, const char *file, void **buf, size_t
bytes)
 
 static int32_t
 msg_send(struct ipc_instance *ipc_instance,
-	 const struct iovec *iov, unsigned int iov_len)
+	 const struct iovec *iov, uint32_t iov_len)
 {
 	int32_t i;
 	size_t size = 0;
@@ -399,7 +400,7 @@ msg_send(struct ipc_instance *ipc_instance,
 	return qb_rb_chunk_commit(ipc_instance->request_rb, size);
 }
 
-static int32_t ipc_sem_wait(struct ipc_instance *ipc_instance, int sem_num)
+static int32_t ipc_sem_wait(struct ipc_instance *ipc_instance, int32_t sem_num)
 {
 #if _POSIX_THREAD_PROCESS_SHARED < 1
 	struct sembuf sop;
@@ -408,7 +409,7 @@ static int32_t ipc_sem_wait(struct ipc_instance *ipc_instance, int
sem_num)
 	struct pollfd pfd;
 	sem_t *sem = NULL;
 #endif
-	int res;
+	int32_t res;
 
 #if _POSIX_THREAD_PROCESS_SHARED > 0
 	switch (sem_num) {
@@ -511,12 +512,12 @@ reply_receive_in_buf(struct ipc_instance *ipc_instance, void
**res_msg)
  */
 int32_t
 qb_ipcc_service_connect(const char *socket_name,
-			unsigned int service,
+			uint32_t service,
 			size_t request_size,
 			size_t response_size,
 			size_t dispatch_size, qb_hdb_handle_t * handle)
 {
-	int request_fd;
+	int32_t request_fd;
 	struct sockaddr_un address;
 	int32_t res;
 	struct ipc_instance *ipc_instance;
@@ -524,7 +525,7 @@ qb_ipcc_service_connect(const char *socket_name,
 	key_t semkey = 0;
 	union semun semun;
 #endif
-	int sys_res;
+	int32_t sys_res;
 	mar_req_setup_t req_setup;
 	mar_res_setup_t res_setup;
 	char control_map_path[128];
@@ -585,8 +586,9 @@ qb_ipcc_service_connect(const char *socket_name,
 
 	/* RB request */
 	ipc_instance->request_rb = qb_rb_open("request_ringbuffer-XXXXXX",
-			request_size,
-			QB_RB_FLAG_CREATE|QB_RB_FLAG_SHARED_PROCESS);
+					      request_size,
+					      QB_RB_FLAG_CREATE |
+					      QB_RB_FLAG_SHARED_PROCESS);
 	if (ipc_instance->request_rb == NULL) {
 		res = EBADE;
 		goto error_request_buffer;
@@ -735,7 +737,7 @@ int32_t qb_ipcc_service_disconnect(qb_hdb_handle_t handle)
 
 int32_t
 qb_ipcc_dispatch_flow_control_get(qb_hdb_handle_t handle,
-				  unsigned int *flow_control_state)
+				  uint32_t * flow_control_state)
 {
 	struct ipc_instance *ipc_instance;
 	int32_t res;
@@ -751,7 +753,7 @@ qb_ipcc_dispatch_flow_control_get(qb_hdb_handle_t handle,
 	return (res);
 }
 
-int32_t qb_ipcc_fd_get(qb_hdb_handle_t handle, int *fd)
+int32_t qb_ipcc_fd_get(qb_hdb_handle_t handle, int32_t * fd)
 {
 	struct ipc_instance *ipc_instance;
 	int32_t res;
@@ -767,13 +769,14 @@ int32_t qb_ipcc_fd_get(qb_hdb_handle_t handle, int *fd)
 	return (res);
 }
 
-int32_t qb_ipcc_dispatch_get(qb_hdb_handle_t handle, void **data, int timeout)
+int32_t qb_ipcc_dispatch_get(qb_hdb_handle_t handle, void **data,
+			     int32_t timeout)
 {
 	struct pollfd ufds;
-	int poll_events;
+	int32_t poll_events;
 	char buf;
 	struct ipc_instance *ipc_instance;
-	int res;
+	int32_t res;
 	char buf_two = 1;
 	char *data_addr;
 	int32_t error = 0;
@@ -864,7 +867,7 @@ int32_t qb_ipcc_dispatch_put(qb_hdb_handle_t handle)
 	struct ipc_instance *ipc_instance;
 	int32_t res;
 	char *addr;
-	unsigned int read_idx;
+	uint32_t read_idx;
 
 	res =
 	    qb_hdb_handle_get_always(&ipc_hdb, handle, (void **)&ipc_instance);
@@ -896,7 +899,7 @@ error_exit:
 
 int32_t
 qb_ipcc_msg_send(qb_hdb_handle_t handle,
-		 const struct iovec * iov, unsigned int iov_len)
+		 const struct iovec * iov, uint32_t iov_len)
 {
 	int32_t res;
 	struct ipc_instance *ipc_instance;
@@ -919,8 +922,7 @@ qb_ipcc_msg_send(qb_hdb_handle_t handle,
 int32_t
 qb_ipcc_msg_send_reply_receive(qb_hdb_handle_t handle,
 			       const struct iovec * iov,
-			       unsigned int iov_len,
-			       void *res_msg, size_t res_len)
+			       uint32_t iov_len, void *res_msg, size_t res_len)
 {
 	int32_t res;
 	struct ipc_instance *ipc_instance;
@@ -949,9 +951,9 @@ error_exit:
 int32_t
 qb_ipcc_msg_send_reply_receive_in_buf_get(qb_hdb_handle_t handle,
 					  const struct iovec * iov,
-					  unsigned int iov_len, void **res_msg)
+					  uint32_t iov_len, void **res_msg)
 {
-	unsigned int res;
+	int32_t res;
 	struct ipc_instance *ipc_instance;
 
 	res = qb_hdb_handle_get(&ipc_hdb, handle, (void **)&ipc_instance);
@@ -976,7 +978,7 @@ error_exit:
 
 int32_t qb_ipcc_msg_send_reply_receive_in_buf_put(qb_hdb_handle_t handle)
 {
-	unsigned int res;
+	int32_t res;
 	struct ipc_instance *ipc_instance;
 
 	res = qb_hdb_handle_get(&ipc_hdb, handle, (void **)&ipc_instance);
@@ -996,7 +998,7 @@ qb_ipcc_zcb_alloc(qb_hdb_handle_t handle,
 	struct ipc_instance *ipc_instance;
 	void *buf = NULL;
 	char path[128];
-	unsigned int res;
+	int32_t res;
 	mar_req_qb_ipcc_zc_alloc_t req_qb_ipcc_zc_alloc;
 	qb_ipc_response_header_t res_qb_ipcs_zc_alloc;
 	size_t map_size;
@@ -1039,7 +1041,7 @@ int32_t qb_ipcc_zcb_free(qb_hdb_handle_t handle, void *buffer)
 	mar_req_qb_ipcc_zc_free_t req_qb_ipcc_zc_free;
 	qb_ipc_response_header_t res_qb_ipcs_zc_free;
 	struct iovec iovec;
-	unsigned int res;
+	int32_t res;
 	struct qb_ipcs_zc_header *header =
 	    (struct qb_ipcs_zc_header *)((char *)buffer -
 					 sizeof(struct qb_ipcs_zc_header));
diff --git a/lib/ipcs.c b/lib/ipcs.c
index 8f9cf8f..296d668 100644
--- a/lib/ipcs.c
+++ b/lib/ipcs.c
@@ -76,9 +76,9 @@ struct zcb_mapped {
 #if _POSIX_THREAD_PROCESS_SHARED < 1
 #if defined(_SEM_SEMUN_UNDEFINED)
 union semun {
-	int val;
+	int32_t val;
 	struct semid_ds *buf;
-	unsigned short int *array;
+	unsigned short int32_t *array;
 	struct seminfo *__buf;
 };
 #endif
@@ -94,21 +94,21 @@ enum conn_state {
 };
 
 struct conn_info {
-	int fd;
+	int32_t fd;
 	pthread_t thread;
 	pid_t client_pid;
 	pthread_attr_t thread_attr;
-	unsigned int service;
+	uint32_t service;
 	enum conn_state state;
-	int notify_flow_control_enabled;
-	int flow_control_state;
-	int refcount;
+	int32_t notify_flow_control_enabled;
+	int32_t flow_control_state;
+	int32_t refcount;
 	qb_hdb_handle_t stats_handle;
 #if _POSIX_THREAD_PROCESS_SHARED < 1
 	key_t semkey;
-	int semid;
+	int32_t semid;
 #endif
-	unsigned int pending_semops;
+	uint32_t pending_semops;
 	pthread_mutex_t mutex;
 	struct control_buffer *control_buffer;
 	qb_ringbuffer_t *request_rb;
@@ -122,24 +122,25 @@ struct conn_info {
 	void *private_data;
 	struct qb_list_head list;
 	char setup_msg[sizeof(mar_req_setup_t)];
-	unsigned int setup_bytes_read;
+	uint32_t setup_bytes_read;
 	struct qb_list_head zcb_mapped_qb_list_head;
 	char *sending_allowed_private_data[64];
 };
 
-static int shared_mem_dispatch_bytes_left(const struct conn_info *conn_info);
+static int32_t shared_mem_dispatch_bytes_left(const struct conn_info
+					      *conn_info);
 
 static void outq_flush(struct conn_info *conn_info);
 
-static int priv_change(struct conn_info *conn_info);
+static int32_t priv_change(struct conn_info *conn_info);
 
 static void ipc_disconnect(struct conn_info *conn_info);
 
-static void msg_send(void *conn, const struct iovec *iov, unsigned int iov_len,
-		     int locked);
+static void msg_send(void *conn, const struct iovec *iov, uint32_t iov_len,
+		     int32_t locked);
 
 static qb_hdb_handle_t dummy_stats_create_connection(const char *name,
-						     pid_t pid, int fd)
+						     pid_t pid, int32_t fd)
 {
 	return (0ULL);
 }
@@ -167,12 +168,12 @@ static void sem_post_exit_thread(struct conn_info *conn_info)
 	qb_rb_chunk_write(conn_info->request_rb, conn_info, 4);
 }
 
-static int memory_map(const char *path, size_t bytes, void **buf)
+static int32_t memory_map(const char *path, size_t bytes, void **buf)
 {
-	int fd;
+	int32_t fd;
 	void *addr_orig;
 	void *addr;
-	int res;
+	int32_t res;
 
 	fd = open(path, O_RDWR, 0600);
 
@@ -215,12 +216,12 @@ static int memory_map(const char *path, size_t bytes, void **buf)
 	return (0);
 }
 
-static int circular_memory_map(const char *path, size_t bytes, void **buf)
+static int32_t circular_memory_map(const char *path, size_t bytes, void **buf)
 {
-	int fd;
+	int32_t fd;
 	void *addr_orig;
 	void *addr;
-	int res;
+	int32_t res;
 
 	fd = open(path, O_RDWR, 0600);
 
@@ -273,18 +274,18 @@ static int circular_memory_map(const char *path, size_t bytes, void
**buf)
 	return (0);
 }
 
-static inline int circular_memory_unmap(void *buf, size_t bytes)
+static inline int32_t circular_memory_unmap(void *buf, size_t bytes)
 {
-	int res;
+	int32_t res;
 
 	res = munmap(buf, bytes << 1);
 
 	return (res);
 }
 
-static inline int zcb_free(struct zcb_mapped *zcb_mapped)
+static inline int32_t zcb_free(struct zcb_mapped *zcb_mapped)
 {
-	unsigned int res;
+	uint32_t res;
 
 	res = munmap(zcb_mapped->addr, zcb_mapped->size);
 	qb_list_del(&zcb_mapped->list);
@@ -292,11 +293,11 @@ static inline int zcb_free(struct zcb_mapped *zcb_mapped)
 	return (res);
 }
 
-static inline int zcb_by_addr_free(struct conn_info *conn_info, void *addr)
+static inline int32_t zcb_by_addr_free(struct conn_info *conn_info, void *addr)
 {
 	struct qb_list_head *list;
 	struct zcb_mapped *zcb_mapped;
-	unsigned int res = 0;
+	uint32_t res = 0;
 
 	for (list = conn_info->zcb_mapped_qb_list_head.next;
 	     list != &conn_info->zcb_mapped_qb_list_head; list = list->next) {
@@ -312,7 +313,7 @@ static inline int zcb_by_addr_free(struct conn_info *conn_info, void
*addr)
 	return (res);
 }
 
-static inline int zcb_all_free(struct conn_info *conn_info)
+static inline int32_t zcb_all_free(struct conn_info *conn_info)
 {
 	struct qb_list_head *list;
 	struct zcb_mapped *zcb_mapped;
@@ -329,11 +330,12 @@ static inline int zcb_all_free(struct conn_info *conn_info)
 	return (0);
 }
 
-static inline int zcb_alloc(struct conn_info *conn_info,
-			    const char *path_to_file, size_t size, void **addr)
+static inline int32_t zcb_alloc(struct conn_info *conn_info,
+				const char *path_to_file,
+				size_t size, void **addr)
 {
 	struct zcb_mapped *zcb_mapped;
-	unsigned int res;
+	uint32_t res;
 
 	zcb_mapped = malloc(sizeof(struct zcb_mapped));
 	if (zcb_mapped == NULL) {
@@ -354,10 +356,10 @@ static inline int zcb_alloc(struct conn_info *conn_info,
 	return (0);
 }
 
-static int ipc_thread_active(void *conn)
+static int32_t ipc_thread_active(void *conn)
 {
 	struct conn_info *conn_info = (struct conn_info *)conn;
-	int retval = 0;
+	int32_t retval = 0;
 
 	pthread_mutex_lock(&conn_info->mutex);
 	if (conn_info->state == CONN_STATE_THREAD_ACTIVE) {
@@ -367,10 +369,10 @@ static int ipc_thread_active(void *conn)
 	return (retval);
 }
 
-static int ipc_thread_exiting(void *conn)
+static int32_t ipc_thread_exiting(void *conn)
 {
 	struct conn_info *conn_info = (struct conn_info *)conn;
-	int retval = 1;
+	int32_t retval = 1;
 
 	pthread_mutex_lock(&conn_info->mutex);
 	if (conn_info->state == CONN_STATE_THREAD_INACTIVE) {
@@ -385,9 +387,9 @@ static int ipc_thread_exiting(void *conn)
 /*
  * returns 0 if should be called again, -1 if finished
  */
-static inline int conn_info_destroy(struct conn_info *conn_info)
+static inline int32_t conn_info_destroy(struct conn_info *conn_info)
 {
-	unsigned int res;
+	uint32_t res;
 	void *retval;
 
 	qb_list_del(&conn_info->list);
@@ -491,9 +493,8 @@ static void *serveraddr2void(uint64_t server_addr)
 };
 
 static void zerocopy_operations_process(struct conn_info *conn_info,
-				       qb_ipc_request_header_t **
-				       header_out,
-				       unsigned int *new_message)
+					qb_ipc_request_header_t **
+					header_out, uint32_t * new_message)
 {
 	qb_ipc_request_header_t *header;
 
@@ -504,7 +505,7 @@ static void zerocopy_operations_process(struct conn_info *conn_info,
 		qb_ipc_response_header_t res_header;
 		void *addr = NULL;
 		struct qb_ipcs_zc_header *zc_header;
-		unsigned int res;
+		uint32_t res;
 
 		res = zcb_alloc(conn_info, hdr->path_to_file, hdr->map_size,
 				&addr);
@@ -554,6 +555,7 @@ static void *pthread_ipc_consumer(void *conn)
 	int32_t send_ok;
 	uint32_t new_message;
 	ssize_t size;
+	void *pri_data = NULL;
 
 #if defined(HAVE_PTHREAD_SETSCHEDPARAM) && defined(HAVE_SCHED_GET_PRIORITY_MAX)
 	if (api->sched_policy != 0) {
@@ -564,10 +566,10 @@ static void *pthread_ipc_consumer(void *conn)
 #endif
 
 	for (;;) {
-		size = qb_rb_chunk_peek(conn_info->request_rb, (void**)&header, 2000);
+		size = qb_rb_chunk_peek(conn_info->request_rb,
+					(void **)&header, 2000);
 
 		if (ipc_thread_active(conn_info) == 0) {
-			qb_util_log(LOG_DEBUG,"thread not active");
 			qb_ipcs_refcount_dec(conn_info);
 			pthread_exit(0);
 		}
@@ -588,18 +590,16 @@ static void *pthread_ipc_consumer(void *conn)
 
 		qb_ipcs_refcount_inc(conn);
 
+		pri_data = conn_info->sending_allowed_private_data;
 		send_ok = api->sending_allowed(conn_info->service,
-					       header->id,
-					       header,
-					       conn_info->sending_allowed_private_data);
+					       header->id, header, pri_data);
 
 		/*
 		 * This happens when the message contains some kind of invalid
 		 * parameter, such as an invalid size
 		 */
 		if (send_ok == -1) {
-			response_header.size =
-			    sizeof(qb_ipc_response_header_t);
+			response_header.size = sizeof(qb_ipc_response_header_t);
 			response_header.id = 0;
 			response_header.error = EINVAL;
 			qb_ipcs_response_send(conn_info,
@@ -620,8 +620,7 @@ static void *pthread_ipc_consumer(void *conn)
 			 */
 			api->stats_increment_value(conn_info->stats_handle,
 						   "sem_retry_count");
-			response_header.size =
-			    sizeof(qb_ipc_response_header_t);
+			response_header.size = sizeof(qb_ipc_response_header_t);
 			response_header.id = 0;
 			response_header.error = EAGAIN;
 			qb_ipcs_response_send(conn_info,
@@ -630,18 +629,17 @@ static void *pthread_ipc_consumer(void *conn)
 			qb_rb_chunk_reclaim(conn_info->request_rb);
 		}
 
-		api->
-		    sending_allowed_release
+		api->sending_allowed_release
 		    (conn_info->sending_allowed_private_data);
 		qb_ipcs_refcount_dec(conn);
 	}
 	pthread_exit(0);
 }
 
-static int req_setup_send(struct conn_info *conn_info, int error)
+static int32_t req_setup_send(struct conn_info *conn_info, int32_t error)
 {
 	mar_res_setup_t res_setup;
-	unsigned int res;
+	uint32_t res;
 
 	memset(&res_setup, 0, sizeof(res_setup));
 	res_setup.error = error;
@@ -662,18 +660,18 @@ retry_send:
 	return (0);
 }
 
-static int req_setup_recv(struct conn_info *conn_info)
+static int32_t req_setup_recv(struct conn_info *conn_info)
 {
-	int res;
+	int32_t res;
 	struct msghdr msg_recv;
 	struct iovec iov_recv;
-	int authenticated = 0;
+	int32_t authenticated = 0;
 
 #ifdef QB_LINUX
 	struct cmsghdr *cmsg;
 	char cmsg_cred[CMSG_SPACE(sizeof(struct ucred))];
-	int off = 0;
-	int on = 1;
+	int32_t off = 0;
+	int32_t on = 1;
 	struct ucred *cred;
 #endif
 
@@ -814,7 +812,7 @@ static void ipc_disconnect(struct conn_info *conn_info)
 	sem_post_exit_thread(conn_info);
 }
 
-static int conn_info_create(int fd)
+static int32_t conn_info_create(int32_t fd)
 {
 	struct conn_info *conn_info;
 
@@ -851,9 +849,9 @@ static int conn_info_create(int fd)
  */
 extern void qb_ipcs_ipc_init(struct qb_ipcs_init_state *init_state)
 {
-	int server_fd;
+	int32_t server_fd;
 	struct sockaddr_un un_addr;
-	int res;
+	int32_t res;
 
 	api = init_state;
 	api->stats_create_connection = dummy_stats_create_connection;
@@ -938,7 +936,7 @@ void qb_ipcs_ipc_exit(void)
 {
 	struct qb_list_head *list;
 	struct conn_info *conn_info;
-	unsigned int res;
+	uint32_t res;
 
 	for (list = conn_info_qb_list_head.next;
 	     list != &conn_info_qb_list_head; list = list->next) {
@@ -970,7 +968,7 @@ void qb_ipcs_ipc_exit(void)
 	}
 }
 
-int qb_ipcs_ipc_service_exit(unsigned int service)
+int32_t qb_ipcs_ipc_service_exit(uint32_t service)
 {
 	struct qb_list_head *list, *list_next;
 	struct conn_info *conn_info;
@@ -1025,13 +1023,13 @@ void *qb_ipcs_private_data_get(void *conn)
 	return (conn_info->private_data);
 }
 
-int qb_ipcs_response_send(void *conn, const void *msg, size_t mlen)
+int32_t qb_ipcs_response_send(void *conn, const void *msg, size_t mlen)
 {
 	struct conn_info *conn_info = (struct conn_info *)conn;
 #if _POSIX_THREAD_PROCESS_SHARED < 1
 	struct sembuf sop;
 #endif
-	int res;
+	int32_t res;
 
 	memcpy(conn_info->response_buffer, msg, mlen);
 
@@ -1059,16 +1057,16 @@ retry_semop:
 	return (0);
 }
 
-int qb_ipcs_response_iov_send(void *conn, const struct iovec *iov,
-			      unsigned int iov_len)
+int32_t qb_ipcs_response_iov_send(void *conn, const struct iovec * iov,
+				  uint32_t iov_len)
 {
 	struct conn_info *conn_info = (struct conn_info *)conn;
 #if _POSIX_THREAD_PROCESS_SHARED < 1
 	struct sembuf sop;
 #endif
-	int res;
-	int write_idx = 0;
-	int i;
+	int32_t res;
+	int32_t write_idx = 0;
+	int32_t i;
 
 	for (i = 0; i < iov_len; i++) {
 		memcpy(&conn_info->response_buffer[write_idx],
@@ -1100,11 +1098,11 @@ retry_semop:
 	return (0);
 }
 
-static int shared_mem_dispatch_bytes_left(const struct conn_info *conn_info)
+static int32_t shared_mem_dispatch_bytes_left(const struct conn_info *conn_info)
 {
-	unsigned int n_read;
-	unsigned int n_write;
-	unsigned int bytes_left;
+	uint32_t n_read;
+	uint32_t n_write;
+	uint32_t bytes_left;
 
 	n_read = conn_info->control_buffer->read;
 	n_write = conn_info->control_buffer->write;
@@ -1121,10 +1119,9 @@ static int shared_mem_dispatch_bytes_left(const struct conn_info
*conn_info)
 	return (bytes_left);
 }
 
-static void memcpy_dwrap(struct conn_info *conn_info, void *msg,
-			 unsigned int len)
+static void memcpy_dwrap(struct conn_info *conn_info, void *msg, uint32_t len)
 {
-	unsigned int write_idx;
+	uint32_t write_idx;
 
 	write_idx = conn_info->control_buffer->write;
 
@@ -1136,9 +1133,9 @@ static void memcpy_dwrap(struct conn_info *conn_info, void *msg,
 /**
  * simulate the behaviour in qb_ipcc.c
  */
-static int flow_control_event_send(struct conn_info *conn_info, char event)
+static int32_t flow_control_event_send(struct conn_info *conn_info, char event)
 {
-	int new_fc = 0;
+	int32_t new_fc = 0;
 
 	if (event == MESSAGE_RES_OUTQ_NOT_EMPTY ||
 	    event == MESSAGE_RES_ENABLE_FLOWCONTROL) {
@@ -1166,15 +1163,15 @@ static int flow_control_event_send(struct conn_info *conn_info,
char event)
 	return send(conn_info->fd, &event, 1, MSG_NOSIGNAL);
 }
 
-static void msg_send(void *conn, const struct iovec *iov, unsigned int iov_len,
-		     int locked)
+static void msg_send(void *conn, const struct iovec *iov, uint32_t iov_len,
+		     int32_t locked)
 {
 	struct conn_info *conn_info = (struct conn_info *)conn;
 #if _POSIX_THREAD_PROCESS_SHARED < 1
 	struct sembuf sop;
 #endif
-	int res;
-	int i;
+	int32_t res;
+	int32_t i;
 
 	for (i = 0; i < iov_len; i++) {
 		memcpy_dwrap(conn_info, iov[i].iov_base, iov[i].iov_len);
@@ -1225,9 +1222,9 @@ static void outq_flush(struct conn_info *conn_info)
 {
 	struct qb_list_head *list, *list_next;
 	struct outq_item *outq_item;
-	unsigned int bytes_left;
+	uint32_t bytes_left;
 	struct iovec iov;
-	int res;
+	int32_t res;
 
 	pthread_mutex_lock(&conn_info->mutex);
 	if (qb_list_empty(&conn_info->outq_head)) {
@@ -1259,14 +1256,14 @@ static void outq_flush(struct conn_info *conn_info)
 	pthread_mutex_unlock(&conn_info->mutex);
 }
 
-static int priv_change(struct conn_info *conn_info)
+static int32_t priv_change(struct conn_info *conn_info)
 {
 	mar_req_priv_change req_priv_change;
-	unsigned int res;
+	uint32_t res;
 #if _POSIX_THREAD_PROCESS_SHARED < 1
 	union semun semun;
 	struct semid_ds ipc_set;
-	int i;
+	int32_t i;
 #endif
 
 retry_recv:
@@ -1311,12 +1308,12 @@ retry_recv:
 }
 
 static void msg_send_or_queue(void *conn, const struct iovec *iov,
-			      unsigned int iov_len)
+			      uint32_t iov_len)
 {
 	struct conn_info *conn_info = (struct conn_info *)conn;
-	unsigned int bytes_left;
-	unsigned int bytes_msg = 0;
-	int i;
+	uint32_t bytes_left;
+	uint32_t bytes_msg = 0;
+	int32_t i;
 	struct outq_item *outq_item;
 	char *write_buf = 0;
 
@@ -1384,7 +1381,7 @@ void qb_ipcs_refcount_dec(void *conn)
 	pthread_mutex_unlock(&conn_info->mutex);
 }
 
-int qb_ipcs_dispatch_send(void *conn, const void *msg, size_t mlen)
+int32_t qb_ipcs_dispatch_send(void *conn, const void *msg, size_t mlen)
 {
 	struct iovec iov;
 
@@ -1395,22 +1392,22 @@ int qb_ipcs_dispatch_send(void *conn, const void *msg, size_t
mlen)
 	return (0);
 }
 
-int qb_ipcs_dispatch_iov_send(void *conn, const struct iovec *iov,
-			      unsigned int iov_len)
+int32_t qb_ipcs_dispatch_iov_send(void *conn, const struct iovec * iov,
+				  uint32_t iov_len)
 {
 	msg_send_or_queue(conn, iov, iov_len);
 	return (0);
 }
 
-int qb_ipcs_handler_accept(int fd, int revent, void *data)
+int32_t qb_ipcs_handler_accept(int32_t fd, int32_t revent, void *data)
 {
 	socklen_t addrlen;
 	struct sockaddr_un un_addr;
-	int new_fd;
+	int32_t new_fd;
 #ifdef QB_LINUX
-	int on = 1;
+	int32_t on = 1;
 #endif
-	int res;
+	int32_t res;
 
 	addrlen = sizeof(struct sockaddr_un);
 
@@ -1524,11 +1521,11 @@ static void qb_ipcs_init_conn_stats(struct conn_info *conn)
 				&conn->service, sizeof(conn->service));
 }
 
-int qb_ipcs_handler_dispatch(int fd, int revent, void *context)
+int32_t qb_ipcs_handler_dispatch(int32_t fd, int32_t revent, void *context)
 {
 	mar_req_setup_t *req_setup;
 	struct conn_info *conn_info = (struct conn_info *)context;
-	int res;
+	int32_t res;
 	char buf;
 
 	if (ipc_thread_exiting(conn_info)) {
@@ -1581,8 +1578,8 @@ int qb_ipcs_handler_dispatch(int fd, int revent, void *context)
 		conn_info->control_size = req_setup->control_size;
 
 		conn_info->request_rb = qb_rb_open(req_setup->request_file,
-				 req_setup->request_size,
-				 QB_RB_FLAG_SHARED_PROCESS);
+						   req_setup->request_size,
+						   QB_RB_FLAG_SHARED_PROCESS);
 		conn_info->request_size = req_setup->request_size;
 
 		res = memory_map(req_setup->response_file,
-- 
1.6.6.1

[PATCH 2/3] hdb: move functions into cfile

[Angus Salkeld]

convert int -> int32_t
rename qb_hdb_handle_t -> qb_handle_t
rename DECLARE_HDB_DATABASE -> QB_HDB_DECLARE
rename qb_hdb_handle_database -> qb_hdb

Signed-off-by: Angus Salkeld <asalkeld(a)redhat.com&gt;
---
 include/qb/qbhash.h     |   20 ++--
 include/qb/qbhdb.h      |  387 ++++-------------------------------------------
 include/qb/qbipcc.h     |   28 ++--
 include/qb/qbipcs.h     |   12 +-
 include/qb/qbplugin.h   |    4 +-
 include/qb/qbpoll.h     |   23 ++--
 include/qb/qbrb.h       |    5 +-
 lib/Makefile.am         |    3 +-
 lib/hash.c              |   12 +-
 lib/hdb.c               |  334 ++++++++++++++++++++++++++++++++++++++++
 lib/ipcc.c              |   30 ++--
 lib/ipcs.c              |   14 +-
 lib/logsys.c            |    2 +-
 lib/plugin_loader.c     |   20 ++--
 lib/poll.c              |   30 ++--
 lib/ringbuffer.c        |    9 +-
 lib/ringbuffer.h        |   20 +--
 lib/ringbuffer_helper.c |    6 +-
 tests/bmc.c             |    3 +-
 tests/bmcpt.c           |    2 +-
 tests/bms.c             |    6 +-
 tests/check_hash.c      |    4 +-
 tests/check_plugin.c    |    8 +-
 23 files changed, 488 insertions(+), 494 deletions(-)
 create mode 100644 lib/hdb.c

diff --git a/include/qb/qbhash.h b/include/qb/qbhash.h
index 6a5220b..aecd3c4 100644
--- a/include/qb/qbhash.h
+++ b/include/qb/qbhash.h
@@ -31,39 +31,39 @@ extern "C" {
 #endif
 /* *INDENT-ON* */
 
-int32_t qb_hash_initialize(qb_hdb_handle_t * handle,
+int32_t qb_hash_initialize(qb_handle_t * handle,
 			   uint32_t order, uint32_t context_size);
 
-int32_t qb_hash_key_set(qb_hdb_handle_t handle,
+int32_t qb_hash_key_set(qb_handle_t handle,
 			const char *key, const void *value, uint32_t value_len);
 
-int32_t qb_hash_key_get(qb_hdb_handle_t handle,
+int32_t qb_hash_key_get(qb_handle_t handle,
 			const char *key, void **value, uint64_t * value_len);
 
-int32_t qb_hash_key_context_get(qb_hdb_handle_t handle,
+int32_t qb_hash_key_context_get(qb_handle_t handle,
 				const char *key, void **context);
 
-int32_t qb_hash_key_delete(qb_hdb_handle_t handle, const char *key);
+int32_t qb_hash_key_delete(qb_handle_t handle, const char *key);
 
-int32_t qb_hash_edge_create(qb_hdb_handle_t handle,
+int32_t qb_hash_edge_create(qb_handle_t handle,
 			    const char *source_key,
 			    const char *dest_key, const char *edge_name);
 
-int32_t qb_hash_edge_destroy(qb_hdb_handle_t handle,
+int32_t qb_hash_edge_destroy(qb_handle_t handle,
 			     const char *source_key,
 			     const char *dest_key, const char *edge_name);
 
-int32_t qb_hash_edge_follow(qb_hdb_handle_t handle,
+int32_t qb_hash_edge_follow(qb_handle_t handle,
 			    const char *source_key,
 			    const char *edge_name, char **dest_key);
 
-int32_t qb_hash_edge_value_set(qb_hdb_handle_t handle,
+int32_t qb_hash_edge_value_set(qb_handle_t handle,
 			       const char *source_key,
 			       const char *dest_key,
 			       const char *edge_name,
 			       const void *edge_value, uint64_t edge_value_len);
 
-int32_t qb_hash_edge_value_get(qb_hdb_handle_t handle,
+int32_t qb_hash_edge_value_get(qb_handle_t handle,
 			       const char *source_key,
 			       const char *dest_key,
 			       const char *edge_name,
diff --git a/include/qb/qbhdb.h b/include/qb/qbhdb.h
index 178811b..5cf9661 100644
--- a/include/qb/qbhdb.h
+++ b/include/qb/qbhdb.h
@@ -26,16 +26,12 @@
 #define _GNU_SOURCE
 #endif
 
-#include <errno.h>
-#include <assert.h>
 #include <stdlib.h>
-#include <string.h>
-#include <pthread.h>
 #include <stdint.h>
 #include <inttypes.h>
 #include <qb/qbutil.h>
 
-typedef uint64_t qb_hdb_handle_t;
+typedef uint64_t qb_handle_t;
 
 /*
  * Formatting for string printing on 32/64 bit systems
@@ -43,375 +39,46 @@ typedef uint64_t qb_hdb_handle_t;
 #define QB_HDB_D_FORMAT "%"PRIu64
 #define QB_HDB_X_FORMAT "%"PRIx64
 
-enum QB_HDB_HANDLE_STATE {
-	QB_HDB_HANDLE_STATE_EMPTY,
-	QB_HDB_HANDLE_STATE_PENDINGREMOVAL,
-	QB_HDB_HANDLE_STATE_ACTIVE
-};
-
 struct qb_hdb_handle {
-	int state;
+	int32_t state;
 	void *instance;
-	int check;
-	int ref_count;
+	int32_t check;
+	int32_t ref_count;
 };
 
-struct qb_hdb_handle_database {
-	unsigned int handle_count;
+struct qb_hdb {
+	uint32_t handle_count;
 	struct qb_hdb_handle *handles;
-	unsigned int iterator;
+	uint32_t iterator;
 	void (*destructor) (void *);
 	qb_thread_lock_t *lock;
-	unsigned int first_run;
+	uint32_t first_run;
 };
 
-#define DECLARE_HDB_DATABASE(database_name,destructor_function)		\
-static struct qb_hdb_handle_database (database_name) = {		\
+#define QB_HDB_DECLARE(database_name,destructor_function)		\
+static struct qb_hdb (database_name) = {		\
 	.handle_count	= 0,						\
-	.handles 	= NULL,						\
+	.handles	= NULL,						\
 	.iterator	= 0,						\
 	.destructor	= destructor_function,				\
 	.first_run	= 1						\
 };									\
 
-static inline void qb_hdb_create(struct qb_hdb_handle_database *handle_database)
-{
-	memset(handle_database, 0, sizeof(struct qb_hdb_handle_database));
-	handle_database->lock = qb_thread_lock_create(QB_THREAD_LOCK_SHORT);
-}
-
-static inline void qb_hdb_destroy(struct qb_hdb_handle_database
-				  *handle_database)
-{
-	free(handle_database->handles);
-	qb_thread_lock_destroy(handle_database->lock);
-	memset(handle_database, 0, sizeof(struct qb_hdb_handle_database));
-}
-
-static inline int qb_hdb_handle_create(struct qb_hdb_handle_database
-				       *handle_database, int instance_size,
-				       qb_hdb_handle_t * handle_id_out)
-{
-	int handle;
-	unsigned int check;
-	void *new_handles;
-	int found = 0;
-	void *instance;
-	int i;
-
-	if (handle_database->first_run == 1) {
-		handle_database->first_run = 0;
-		handle_database->lock =
-		    qb_thread_lock_create(QB_THREAD_LOCK_SHORT);
-	}
-	qb_thread_lock(handle_database->lock);
-
-	for (handle = 0; handle < handle_database->handle_count; handle++) {
-		if (handle_database->handles[handle].state ==
-		    QB_HDB_HANDLE_STATE_EMPTY) {
-			found = 1;
-			break;
-		}
-	}
-
-	if (found == 0) {
-		handle_database->handle_count += 1;
-		new_handles =
-		    (struct qb_hdb_handle *)realloc(handle_database->handles,
-						    sizeof(struct qb_hdb_handle)
-						    *
-						    handle_database->
-						    handle_count);
-		if (new_handles == NULL) {
-			qb_thread_unlock(handle_database->lock);
-			errno = ENOMEM;
-			return (-1);
-		}
-		handle_database->handles = new_handles;
-	}
-
-	instance = (void *)malloc(instance_size);
-	if (instance == 0) {
-		errno = ENOMEM;
-		return (-1);
-	}
-
-	/*
-	 * This code makes sure the random number isn't zero
-	 * We use 0 to specify an invalid handle out of the 1^64 address space
-	 * If we get 0 200 times in a row, the RNG may be broken
-	 */
-	for (i = 0; i < 200; i++) {
-		check = random();
-
-		if (check != 0 && check != 0xffffffff) {
-			break;
-		}
-	}
-
-	memset(instance, 0, instance_size);
-
-	handle_database->handles[handle].state = QB_HDB_HANDLE_STATE_ACTIVE;
-
-	handle_database->handles[handle].instance = instance;
-
-	handle_database->handles[handle].ref_count = 1;
-
-	handle_database->handles[handle].check = check;
-
-	*handle_id_out = (((unsigned long long)(check)) << 32) | handle;
-
-	qb_thread_unlock(handle_database->lock);
-
-	return (0);
-}
-
-static inline int qb_hdb_handle_get(struct qb_hdb_handle_database
-				    *handle_database, qb_hdb_handle_t handle_in,
-				    void **instance)
-{
-	unsigned int check =
-	    ((unsigned int)(((unsigned long long)handle_in) >> 32));
-	unsigned int handle = handle_in & 0xffffffff;
-
-	if (handle_database->first_run == 1) {
-		handle_database->first_run = 0;
-		handle_database->lock =
-		    qb_thread_lock_create(QB_THREAD_LOCK_SHORT);
-	}
-	qb_thread_lock(handle_database->lock);
-
-	*instance = NULL;
-	if (handle >= handle_database->handle_count) {
-		qb_thread_unlock(handle_database->lock);
-		errno = EBADF;
-		return (-1);
-	}
-
-	if (handle_database->handles[handle].state !=
-	    QB_HDB_HANDLE_STATE_ACTIVE) {
-		qb_thread_unlock(handle_database->lock);
-		errno = EBADF;
-		return (-1);
-	}
-
-	if (check != 0xffffffff &&
-	    check != handle_database->handles[handle].check) {
-
-		qb_thread_unlock(handle_database->lock);
-		errno = EBADF;
-		return (-1);
-	}
-
-	*instance = handle_database->handles[handle].instance;
-
-	handle_database->handles[handle].ref_count += 1;
-
-	qb_thread_unlock(handle_database->lock);
-	return (0);
-}
-
-static inline int qb_hdb_handle_get_always(struct qb_hdb_handle_database
-					   *handle_database,
-					   qb_hdb_handle_t handle_in,
-					   void **instance)
-{
-	unsigned int check =
-	    ((unsigned int)(((unsigned long long)handle_in) >> 32));
-	unsigned int handle = handle_in & 0xffffffff;
-
-	if (handle_database->first_run == 1) {
-		handle_database->first_run = 0;
-		handle_database->lock =
-		    qb_thread_lock_create(QB_THREAD_LOCK_SHORT);
-	}
-	qb_thread_lock(handle_database->lock);
-
-	*instance = NULL;
-	if (handle >= handle_database->handle_count) {
-		qb_thread_unlock(handle_database->lock);
-		errno = EBADF;
-		return (-1);
-	}
-
-	if (handle_database->handles[handle].state == QB_HDB_HANDLE_STATE_EMPTY) {
-		qb_thread_unlock(handle_database->lock);
-		errno = EBADF;
-		return (-1);
-	}
-
-	if (check != 0xffffffff &&
-	    check != handle_database->handles[handle].check) {
-
-		qb_thread_unlock(handle_database->lock);
-		errno = EBADF;
-		return (-1);
-	}
-
-	*instance = handle_database->handles[handle].instance;
-
-	handle_database->handles[handle].ref_count += 1;
-
-	qb_thread_unlock(handle_database->lock);
-	return (0);
-}
-
-static inline int qb_hdb_handle_put(struct qb_hdb_handle_database
-				    *handle_database, qb_hdb_handle_t handle_in)
-{
-	unsigned int check =
-	    ((unsigned int)(((unsigned long long)handle_in) >> 32));
-	unsigned int handle = handle_in & 0xffffffff;
-
-	if (handle_database->first_run == 1) {
-		handle_database->first_run = 0;
-		handle_database->lock =
-		    qb_thread_lock_create(QB_THREAD_LOCK_SHORT);
-	}
-	qb_thread_lock(handle_database->lock);
-
-	if (handle >= handle_database->handle_count) {
-		qb_thread_unlock(handle_database->lock);
-
-		errno = EBADF;
-		return (-1);
-	}
-
-	if (check != 0xffffffff &&
-	    check != handle_database->handles[handle].check) {
-
-		qb_thread_unlock(handle_database->lock);
-		errno = EBADF;
-		return (-1);
-	}
-
-	handle_database->handles[handle].ref_count -= 1;
-	assert(handle_database->handles[handle].ref_count >= 0);
-
-	if (handle_database->handles[handle].ref_count == 0) {
-		if (handle_database->destructor) {
-			handle_database->destructor(handle_database->
-						    handles[handle].instance);
-		}
-		free(handle_database->handles[handle].instance);
-		memset(&handle_database->handles[handle], 0,
-		       sizeof(struct qb_hdb_handle));
-	}
-	qb_thread_unlock(handle_database->lock);
-	return (0);
-}
-
-static inline int qb_hdb_handle_destroy(struct qb_hdb_handle_database
-					*handle_database,
-					qb_hdb_handle_t handle_in)
-{
-	unsigned int check =
-	    ((unsigned int)(((unsigned long long)handle_in) >> 32));
-	unsigned int handle = handle_in & 0xffffffff;
-	int res;
-
-	if (handle_database->first_run == 1) {
-		handle_database->first_run = 0;
-		handle_database->lock =
-		    qb_thread_lock_create(QB_THREAD_LOCK_SHORT);
-	}
-	qb_thread_lock(handle_database->lock);
-
-	if (handle >= handle_database->handle_count) {
-		qb_thread_unlock(handle_database->lock);
-
-		errno = EBADF;
-		return (-1);
-	}
-
-	if (check != 0xffffffff &&
-	    check != handle_database->handles[handle].check) {
-		qb_thread_unlock(handle_database->lock);
-		errno = EBADF;
-		return (-1);
-	}
-
-	handle_database->handles[handle].state =
-	    QB_HDB_HANDLE_STATE_PENDINGREMOVAL;
-	qb_thread_unlock(handle_database->lock);
-	res = qb_hdb_handle_put(handle_database, handle_in);
-	return (res);
-}
-
-static inline int qb_hdb_handle_refcount_get(struct qb_hdb_handle_database
-					     *handle_database,
-					     qb_hdb_handle_t handle_in)
-{
-	unsigned int check =
-	    ((unsigned int)(((unsigned long long)handle_in) >> 32));
-	unsigned int handle = handle_in & 0xffffffff;
-
-	int refcount = 0;
-
-	if (handle_database->first_run == 1) {
-		handle_database->first_run = 0;
-		handle_database->lock =
-		    qb_thread_lock_create(QB_THREAD_LOCK_SHORT);
-	}
-	qb_thread_lock(handle_database->lock);
-
-	if (handle >= handle_database->handle_count) {
-		qb_thread_unlock(handle_database->lock);
-		errno = EBADF;
-		return (-1);
-	}
-
-	if (check != 0xffffffff &&
-	    check != handle_database->handles[handle].check) {
-		qb_thread_unlock(handle_database->lock);
-		errno = EBADF;
-		return (-1);
-	}
-
-	refcount = handle_database->handles[handle].ref_count;
-
-	qb_thread_unlock(handle_database->lock);
-
-	return (refcount);
-}
-
-static inline void qb_hdb_iterator_reset(struct qb_hdb_handle_database
-					 *handle_database)
-{
-	handle_database->iterator = 0;
-}
-
-static inline int qb_hdb_iterator_next(struct qb_hdb_handle_database
-				       *handle_database, void **instance,
-				       qb_hdb_handle_t * handle)
-{
-	int res = -1;
-
-	while (handle_database->iterator < handle_database->handle_count) {
-		*handle =
-		    ((unsigned long
-		      long)(handle_database->handles[handle_database->iterator].
-			    check) << 32) | handle_database->iterator;
-		res = qb_hdb_handle_get(handle_database, *handle, instance);
-
-		handle_database->iterator += 1;
-		if (res == 0) {
-			break;
-		}
-	}
-	return (res);
-}
-
-static inline unsigned int qb_hdb_base_convert(qb_hdb_handle_t handle)
-{
-	return (handle & 0xffffffff);
-}
-
-static inline unsigned long long qb_hdb_nocheck_convert(unsigned int handle)
-{
-	unsigned long long retvalue = 0xffffffffULL << 32 | handle;
-
-	return (retvalue);
-}
+void qb_hdb_create(struct qb_hdb *hdb);
+void qb_hdb_destroy(struct qb_hdb *hdb);
+int32_t qb_hdb_handle_create(struct qb_hdb *hdb, int32_t instance_size,
+			     qb_handle_t * handle_id_out);
+int32_t qb_hdb_handle_get(struct qb_hdb *hdb, qb_handle_t handle_in,
+			  void **instance);
+int32_t qb_hdb_handle_get_always(struct qb_hdb *hdb, qb_handle_t handle_in,
+				 void **instance);
+int32_t qb_hdb_handle_put(struct qb_hdb *hdb, qb_handle_t handle_in);
+int32_t qb_hdb_handle_destroy(struct qb_hdb *hdb, qb_handle_t handle_in);
+int32_t qb_hdb_handle_refcount_get(struct qb_hdb *hdb, qb_handle_t handle_in);
+void qb_hdb_iterator_reset(struct qb_hdb *hdb);
+int32_t qb_hdb_iterator_next(struct qb_hdb *hdb, void **instance,
+			     qb_handle_t * handle);
+uint32_t qb_hdb_base_convert(qb_handle_t handle);
+uint64_t qb_hdb_nocheck_convert(uint32_t handle);
 
 #endif /* QB_HDB_H_DEFINED */
diff --git a/include/qb/qbipcc.h b/include/qb/qbipcc.h
index 4ccc626..6f37d7a 100644
--- a/include/qb/qbipcc.h
+++ b/include/qb/qbipcc.h
@@ -39,45 +39,43 @@ qb_ipcc_service_connect(const char *socket_name,
 			uint32_t service,
 			size_t request_size,
 			size_t respnse__size,
-			size_t dispatch_size, qb_hdb_handle_t * handle);
+			size_t dispatch_size, qb_handle_t * handle);
 
-int32_t qb_ipcc_service_disconnect(qb_hdb_handle_t handle);
+int32_t qb_ipcc_service_disconnect(qb_handle_t handle);
 
-int32_t qb_ipcc_fd_get(qb_hdb_handle_t handle, int32_t * fd);
+int32_t qb_ipcc_fd_get(qb_handle_t handle, int32_t * fd);
 
-int32_t qb_ipcc_dispatch_get(qb_hdb_handle_t handle, void **buf,
-			     int32_t timeout);
+int32_t qb_ipcc_dispatch_get(qb_handle_t handle, void **buf, int32_t timeout);
 
-int32_t qb_ipcc_dispatch_put(qb_hdb_handle_t handle);
+int32_t qb_ipcc_dispatch_put(qb_handle_t handle);
 
 int32_t
-qb_ipcc_dispatch_flow_control_get(qb_hdb_handle_t handle,
+qb_ipcc_dispatch_flow_control_get(qb_handle_t handle,
 				  uint32_t * flow_control_state);
 
 int32_t
-qb_ipcc_msg_send(qb_hdb_handle_t handle,
-		 const struct iovec *iov, uint32_t iov_len);
+qb_ipcc_msg_send(qb_handle_t handle, const struct iovec *iov, uint32_t iov_len);
 
 int32_t
-qb_ipcc_msg_send_reply_receive(qb_hdb_handle_t handle,
+qb_ipcc_msg_send_reply_receive(qb_handle_t handle,
 			       const struct iovec *iov,
 			       uint32_t iov_len, void *res_msg, size_t res_len);
 
 int32_t
-qb_ipcc_msg_send_reply_receive_in_buf_get(qb_hdb_handle_t handle,
+qb_ipcc_msg_send_reply_receive_in_buf_get(qb_handle_t handle,
 					  const struct iovec *iov,
 					  uint32_t iov_len, void **res_msg);
 
-int32_t qb_ipcc_msg_send_reply_receive_in_buf_put(qb_hdb_handle_t handle);
+int32_t qb_ipcc_msg_send_reply_receive_in_buf_put(qb_handle_t handle);
 
 int32_t
-qb_ipcc_zcb_alloc(qb_hdb_handle_t handle,
+qb_ipcc_zcb_alloc(qb_handle_t handle,
 		  void **buffer, size_t size, size_t header_size);
 
-int32_t qb_ipcc_zcb_free(qb_hdb_handle_t handle, void *buffer);
+int32_t qb_ipcc_zcb_free(qb_handle_t handle, void *buffer);
 
 int32_t
-qb_ipcc_zcb_msg_send_reply_receive(qb_hdb_handle_t handle,
+qb_ipcc_zcb_msg_send_reply_receive(qb_handle_t handle,
 				   void *msg, void *res_msg, size_t res_len);
 
 /* *INDENT-OFF* */
diff --git a/include/qb/qbipcs.h b/include/qb/qbipcs.h
index ed6f5c0..94d031c 100644
--- a/include/qb/qbipcs.h
+++ b/include/qb/qbipcs.h
@@ -61,16 +61,14 @@ struct qb_ipcs_init_state {
 	qb_ipcs_exit_fn_lvalue(*exit_fn_get) (uint32_t service);
 	qb_ipcs_handler_fn_lvalue(*handler_fn_get) (uint32_t service,
 						    uint32_t id);
-	qb_hdb_handle_t(*stats_create_connection) (const char *name, pid_t pid,
+	qb_handle_t(*stats_create_connection) (const char *name, pid_t pid,
 						   int32_t fd);
-	void (*stats_destroy_connection) (qb_hdb_handle_t handle);
-	void (*stats_update_value) (qb_hdb_handle_t handle,
+	void (*stats_destroy_connection) (qb_handle_t handle);
+	void (*stats_update_value) (qb_handle_t handle,
 				    const char *name, const void *value,
 				    size_t value_len);
-	void (*stats_increment_value) (qb_hdb_handle_t handle,
-				       const char *name);
-	void (*stats_decrement_value) (qb_hdb_handle_t handle,
-				       const char *name);
+	void (*stats_increment_value) (qb_handle_t handle, const char *name);
+	void (*stats_decrement_value) (qb_handle_t handle, const char *name);
 };
 
 void qb_ipcs_ipc_init(struct qb_ipcs_init_state *init_state);
diff --git a/include/qb/qbplugin.h b/include/qb/qbplugin.h
index a9ceec1..11996e1 100644
--- a/include/qb/qbplugin.h
+++ b/include/qb/qbplugin.h
@@ -28,11 +28,11 @@ extern "C" {
 #endif
 /* *INDENT-ON* */
 
-int plugin_ifact_reference(qb_hdb_handle_t * handle,
+int plugin_ifact_reference(qb_handle_t * handle,
 			   const char *iface_name,
 			   int version, void **interface, void *context);
 
-int plugin_ifact_release(qb_hdb_handle_t handle);
+int plugin_ifact_release(qb_handle_t handle);
 
 
 /* *INDENT-OFF* */
diff --git a/include/qb/qbpoll.h b/include/qb/qbpoll.h
index 316aece..6a6165c 100644
--- a/include/qb/qbpoll.h
+++ b/include/qb/qbpoll.h
@@ -32,37 +32,36 @@ extern "C" {
 
 typedef void *qb_poll_timer_handle;
 
-qb_hdb_handle_t qb_poll_create(void);
+qb_handle_t qb_poll_create(void);
 
-int qb_poll_destroy(qb_hdb_handle_t hdb_handle);
+int qb_poll_destroy(qb_handle_t hdb_handle);
 
-int qb_poll_dispatch_add(qb_hdb_handle_t handle,
+int qb_poll_dispatch_add(qb_handle_t handle,
 			 int fd,
 			 int events,
 			 void *data,
-			 int (*dispatch_fn) (qb_hdb_handle_t handle,
+			 int (*dispatch_fn) (qb_handle_t handle,
 					     int fd, int revents, void *data));
 
-int qb_poll_dispatch_modify(qb_hdb_handle_t handle,
+int qb_poll_dispatch_modify(qb_handle_t handle,
 			    int fd,
 			    int events,
-			    int (*dispatch_fn) (qb_hdb_handle_t hdb_handle_t,
+			    int (*dispatch_fn) (qb_handle_t hdb_handle_t,
 						int fd,
 						int revents, void *data));
 
-int qb_poll_dispatch_delete(qb_hdb_handle_t handle, int fd);
+int qb_poll_dispatch_delete(qb_handle_t handle, int fd);
 
-int qb_poll_timer_add(qb_hdb_handle_t handle,
+int qb_poll_timer_add(qb_handle_t handle,
 		      int msec_in_future, void *data,
 		      void (*timer_fn) (void *data),
 		      qb_poll_timer_handle * timer_handle_out);
 
-int qb_poll_timer_delete(qb_hdb_handle_t handle,
-			 qb_poll_timer_handle timer_handle);
+int qb_poll_timer_delete(qb_handle_t handle, qb_poll_timer_handle timer_handle);
 
-int qb_poll_run(qb_hdb_handle_t handle);
+int qb_poll_run(qb_handle_t handle);
 
-int qb_poll_stop(qb_hdb_handle_t handle);
+int qb_poll_stop(qb_handle_t handle);
 
 /* *INDENT-OFF* */
 #ifdef __cplusplus
diff --git a/include/qb/qbrb.h b/include/qb/qbrb.h
index 0776a5b..a944e10 100644
--- a/include/qb/qbrb.h
+++ b/include/qb/qbrb.h
@@ -130,7 +130,7 @@ void qb_rb_close(qb_ringbuffer_t * rb);
  * @param rb ringbuffer instance
  * @return name.
  */
-char* qb_rb_name_get(qb_ringbuffer_t * rb);
+char *qb_rb_name_get(qb_ringbuffer_t * rb);
 
 /**
  * Write a chunk to the ring buffer.
@@ -183,7 +183,8 @@ int32_t qb_rb_chunk_commit(qb_ringbuffer_t * rb, size_t len);
  *
  * @return the size of the chunk (0 if buffer empty).
  */
-ssize_t qb_rb_chunk_peek(qb_ringbuffer_t * rb, void **data_out, int32_t ms_timeout);
+ssize_t qb_rb_chunk_peek(qb_ringbuffer_t * rb, void **data_out,
+			 int32_t ms_timeout);
 
 /**
  * Reclaim the oldest chunk.
diff --git a/lib/Makefile.am b/lib/Makefile.am
index f1e1d03..2fb5ebf 100644
--- a/lib/Makefile.am
+++ b/lib/Makefile.am
@@ -44,7 +44,8 @@ lib_LTLIBRARIES		= libqb.la
 libqb_la_CPPFLAGS	= -I$(top_builddir)/include -I$(top_srcdir)/include
 libqb_la_LDFLAGS	= -version-info 0:0:0
 libqb_la_SOURCES	= util.c tsafe.c hash.c poll.c timer.c wthread.c \
-			  ipcc.c ipcs.c logsys.c ringbuffer.c ringbuffer_helper.c
+			  ipcc.c ipcs.c logsys.c ringbuffer.c ringbuffer_helper.c \
+			  hdb.c
 
 pkgconfigdir = $(libdir)/pkgconfig
 pkgconfig_DATA = libqb.pc
diff --git a/lib/hash.c b/lib/hash.c
index daf485b..d02eb67 100644
--- a/lib/hash.c
+++ b/lib/hash.c
@@ -32,7 +32,7 @@
 
 #define FNV_32_PRIME ((uint32_t)0x01000193)
 
-DECLARE_HDB_DATABASE(qb_hash_handle_db, NULL);
+QB_HDB_DECLARE(qb_hash_handle_db, NULL);
 
 struct hash_node {
 	struct qb_list_head list;
@@ -70,7 +70,7 @@ static uint32_t hash_fnv(const void *value, uint32_t valuelen, uint32_t
order)
 	return (res);
 }
 
-int32_t qb_hash_initialize(qb_hdb_handle_t * handle,
+int32_t qb_hash_initialize(qb_handle_t * handle,
 			   uint32_t order, uint32_t context_size)
 {
 	struct hash_table *hash_table;
@@ -113,7 +113,7 @@ hash_destroy:
 	return (-1);
 }
 
-int32_t qb_hash_key_set(qb_hdb_handle_t handle,
+int32_t qb_hash_key_set(qb_handle_t handle,
 			const char *key, const void *value, uint32_t value_len)
 {
 	struct hash_table *hash_table;
@@ -177,7 +177,7 @@ error_exit:
 	return (res);
 }
 
-int32_t qb_hash_key_get(qb_hdb_handle_t handle,
+int32_t qb_hash_key_get(qb_handle_t handle,
 			const char *key, void **value, uint64_t * value_len)
 {
 	struct hash_table *hash_table;
@@ -218,7 +218,7 @@ unlock_exit:
 	return (res);
 }
 
-int32_t qb_hash_key_delete(qb_hdb_handle_t handle, const char *key)
+int32_t qb_hash_key_delete(qb_handle_t handle, const char *key)
 {
 	struct hash_table *hash_table;
 	struct qb_list_head *list;
@@ -258,7 +258,7 @@ unlock_exit:
 	return (res);
 }
 
-int32_t qb_hash_key_context_get(qb_hdb_handle_t handle,
+int32_t qb_hash_key_context_get(qb_handle_t handle,
 				const char *key, void **context)
 {
 	struct hash_table *hash_table;
diff --git a/lib/hdb.c b/lib/hdb.c
new file mode 100644
index 0000000..f71a998
--- /dev/null
+++ b/lib/hdb.c
@@ -0,0 +1,334 @@
+/*
+ * Copyright (C) 2006-2010 Red Hat, Inc.
+ *
+ * Author: Steven Dake <sdake(a)redhat.com&gt;
+ *
+ * This file is part of libqb.
+ *
+ * libqb is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * libqb is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with libqb.  If not, see <http://www.gnu.org/licenses/>;.
+ */
+#include "os_base.h"
+#include <qb/qbutil.h>
+#include <qb/qbhdb.h>
+
+enum QB_HDB_HANDLE_STATE {
+	QB_HDB_HANDLE_STATE_EMPTY,
+	QB_HDB_HANDLE_STATE_PENDINGREMOVAL,
+	QB_HDB_HANDLE_STATE_ACTIVE
+};
+
+void qb_hdb_create(struct qb_hdb *hdb)
+{
+	memset(hdb, 0, sizeof(struct qb_hdb));
+	hdb->lock = qb_thread_lock_create(QB_THREAD_LOCK_SHORT);
+}
+
+void qb_hdb_destroy(struct qb_hdb
+		    *hdb)
+{
+	free(hdb->handles);
+	qb_thread_lock_destroy(hdb->lock);
+	memset(hdb, 0, sizeof(struct qb_hdb));
+}
+
+int32_t qb_hdb_handle_create(struct qb_hdb *hdb, int32_t instance_size,
+			     qb_handle_t * handle_id_out)
+{
+	int32_t handle;
+	uint32_t check;
+	void *new_handles;
+	int32_t found = 0;
+	void *instance;
+	int32_t i;
+
+	if (hdb->first_run == 1) {
+		hdb->first_run = 0;
+		hdb->lock = qb_thread_lock_create(QB_THREAD_LOCK_SHORT);
+	}
+	qb_thread_lock(hdb->lock);
+
+	for (handle = 0; handle < hdb->handle_count; handle++) {
+		if (hdb->handles[handle].state == QB_HDB_HANDLE_STATE_EMPTY) {
+			found = 1;
+			break;
+		}
+	}
+
+	if (found == 0) {
+		hdb->handle_count += 1;
+		new_handles = realloc(hdb->handles,
+				      sizeof(struct qb_hdb_handle) *
+				      hdb->handle_count);
+		if (new_handles == NULL) {
+			qb_thread_unlock(hdb->lock);
+			errno = ENOMEM;
+			return (-1);
+		}
+		hdb->handles = new_handles;
+	}
+
+	instance = malloc(instance_size);
+	if (instance == 0) {
+		errno = ENOMEM;
+		return (-1);
+	}
+
+	/*
+	 * This code makes sure the random number isn't zero
+	 * We use 0 to specify an invalid handle out of the 1^64 address space
+	 * If we get 0 200 times in a row, the RNG may be broken
+	 */
+	for (i = 0; i < 200; i++) {
+		check = random();
+
+		if (check != 0 && check != 0xffffffff) {
+			break;
+		}
+	}
+
+	memset(instance, 0, instance_size);
+
+	hdb->handles[handle].state = QB_HDB_HANDLE_STATE_ACTIVE;
+
+	hdb->handles[handle].instance = instance;
+
+	hdb->handles[handle].ref_count = 1;
+
+	hdb->handles[handle].check = check;
+
+	*handle_id_out = (((uint64_t) (check)) << 32) | handle;
+
+	qb_thread_unlock(hdb->lock);
+
+	return (0);
+}
+
+int32_t qb_hdb_handle_get(struct qb_hdb * hdb, qb_handle_t handle_in,
+			  void **instance)
+{
+	uint32_t check = ((uint32_t) (((uint64_t) handle_in) >> 32));
+	uint32_t handle = handle_in & 0xffffffff;
+
+	if (hdb->first_run == 1) {
+		hdb->first_run = 0;
+		hdb->lock = qb_thread_lock_create(QB_THREAD_LOCK_SHORT);
+	}
+	qb_thread_lock(hdb->lock);
+
+	*instance = NULL;
+	if (handle >= hdb->handle_count) {
+		qb_thread_unlock(hdb->lock);
+		errno = EBADF;
+		return (-1);
+	}
+
+	if (hdb->handles[handle].state != QB_HDB_HANDLE_STATE_ACTIVE) {
+		qb_thread_unlock(hdb->lock);
+		errno = EBADF;
+		return (-1);
+	}
+
+	if (check != 0xffffffff && check != hdb->handles[handle].check) {
+
+		qb_thread_unlock(hdb->lock);
+		errno = EBADF;
+		return (-1);
+	}
+
+	*instance = hdb->handles[handle].instance;
+
+	hdb->handles[handle].ref_count += 1;
+
+	qb_thread_unlock(hdb->lock);
+	return (0);
+}
+
+int32_t qb_hdb_handle_get_always(struct qb_hdb * hdb, qb_handle_t handle_in,
+				 void **instance)
+{
+	uint32_t check = ((uint32_t) (((uint64_t) handle_in) >> 32));
+	uint32_t handle = handle_in & 0xffffffff;
+
+	if (hdb->first_run == 1) {
+		hdb->first_run = 0;
+		hdb->lock = qb_thread_lock_create(QB_THREAD_LOCK_SHORT);
+	}
+	qb_thread_lock(hdb->lock);
+
+	*instance = NULL;
+	if (handle >= hdb->handle_count) {
+		qb_thread_unlock(hdb->lock);
+		errno = EBADF;
+		return (-1);
+	}
+
+	if (hdb->handles[handle].state == QB_HDB_HANDLE_STATE_EMPTY) {
+		qb_thread_unlock(hdb->lock);
+		errno = EBADF;
+		return (-1);
+	}
+
+	if (check != 0xffffffff && check != hdb->handles[handle].check) {
+
+		qb_thread_unlock(hdb->lock);
+		errno = EBADF;
+		return (-1);
+	}
+
+	*instance = hdb->handles[handle].instance;
+
+	hdb->handles[handle].ref_count += 1;
+
+	qb_thread_unlock(hdb->lock);
+	return (0);
+}
+
+int32_t qb_hdb_handle_put(struct qb_hdb * hdb, qb_handle_t handle_in)
+{
+	uint32_t check = ((uint32_t) (((uint64_t) handle_in) >> 32));
+	uint32_t handle = handle_in & 0xffffffff;
+
+	if (hdb->first_run == 1) {
+		hdb->first_run = 0;
+		hdb->lock = qb_thread_lock_create(QB_THREAD_LOCK_SHORT);
+	}
+	qb_thread_lock(hdb->lock);
+
+	if (handle >= hdb->handle_count) {
+		qb_thread_unlock(hdb->lock);
+
+		errno = EBADF;
+		return (-1);
+	}
+
+	if (check != 0xffffffff && check != hdb->handles[handle].check) {
+
+		qb_thread_unlock(hdb->lock);
+		errno = EBADF;
+		return (-1);
+	}
+
+	hdb->handles[handle].ref_count -= 1;
+	assert(hdb->handles[handle].ref_count >= 0);
+
+	if (hdb->handles[handle].ref_count == 0) {
+		if (hdb->destructor) {
+			hdb->destructor(hdb->handles[handle].instance);
+		}
+		free(hdb->handles[handle].instance);
+		memset(&hdb->handles[handle], 0, sizeof(struct qb_hdb_handle));
+	}
+	qb_thread_unlock(hdb->lock);
+	return (0);
+}
+
+int32_t qb_hdb_handle_destroy(struct qb_hdb * hdb, qb_handle_t handle_in)
+{
+	uint32_t check = ((uint32_t) (((uint64_t) handle_in) >> 32));
+	uint32_t handle = handle_in & 0xffffffff;
+	int32_t res;
+
+	if (hdb->first_run == 1) {
+		hdb->first_run = 0;
+		hdb->lock = qb_thread_lock_create(QB_THREAD_LOCK_SHORT);
+	}
+	qb_thread_lock(hdb->lock);
+
+	if (handle >= hdb->handle_count) {
+		qb_thread_unlock(hdb->lock);
+
+		errno = EBADF;
+		return (-1);
+	}
+
+	if (check != 0xffffffff && check != hdb->handles[handle].check) {
+		qb_thread_unlock(hdb->lock);
+		errno = EBADF;
+		return (-1);
+	}
+
+	hdb->handles[handle].state = QB_HDB_HANDLE_STATE_PENDINGREMOVAL;
+	qb_thread_unlock(hdb->lock);
+	res = qb_hdb_handle_put(hdb, handle_in);
+	return (res);
+}
+
+int32_t qb_hdb_handle_refcount_get(struct qb_hdb * hdb, qb_handle_t handle_in)
+{
+	uint32_t check = ((uint32_t) (((uint64_t) handle_in) >> 32));
+	uint32_t handle = handle_in & 0xffffffff;
+
+	int32_t refcount = 0;
+
+	if (hdb->first_run == 1) {
+		hdb->first_run = 0;
+		hdb->lock = qb_thread_lock_create(QB_THREAD_LOCK_SHORT);
+	}
+	qb_thread_lock(hdb->lock);
+
+	if (handle >= hdb->handle_count) {
+		qb_thread_unlock(hdb->lock);
+		errno = EBADF;
+		return (-1);
+	}
+
+	if (check != 0xffffffff && check != hdb->handles[handle].check) {
+		qb_thread_unlock(hdb->lock);
+		errno = EBADF;
+		return (-1);
+	}
+
+	refcount = hdb->handles[handle].ref_count;
+
+	qb_thread_unlock(hdb->lock);
+
+	return (refcount);
+}
+
+void qb_hdb_iterator_reset(struct qb_hdb
+			   *hdb)
+{
+	hdb->iterator = 0;
+}
+
+int32_t qb_hdb_iterator_next(struct qb_hdb *hdb, void **instance,
+			     qb_handle_t * handle)
+{
+	int32_t res = -1;
+	uint64_t checker;
+
+	while (hdb->iterator < hdb->handle_count) {
+		checker = (uint64_t) (hdb->handles[hdb->iterator].check);
+		*handle = (checker << 32) | hdb->iterator;
+		res = qb_hdb_handle_get(hdb, *handle, instance);
+
+		hdb->iterator += 1;
+		if (res == 0) {
+			break;
+		}
+	}
+	return (res);
+}
+
+uint32_t qb_hdb_base_convert(qb_handle_t handle)
+{
+	return (handle & 0xffffffff);
+}
+
+uint64_t qb_hdb_nocheck_convert(uint32_t handle)
+{
+	uint64_t retvalue = 0xffffffffULL << 32 | handle;
+
+	return (retvalue);
+}
diff --git a/lib/ipcc.c b/lib/ipcc.c
index e35f570..975e05c 100644
--- a/lib/ipcc.c
+++ b/lib/ipcc.c
@@ -62,7 +62,7 @@ struct ipc_instance {
 
 void ipc_hdb_destructor(void *context);
 
-DECLARE_HDB_DATABASE(ipc_hdb, ipc_hdb_destructor);
+QB_HDB_DECLARE(ipc_hdb, ipc_hdb_destructor);
 
 #if defined(QB_LINUX) || defined(QB_SOLARIS)
 #define QB_SUN_LEN(a) sizeof(*(a))
@@ -515,7 +515,7 @@ qb_ipcc_service_connect(const char *socket_name,
 			uint32_t service,
 			size_t request_size,
 			size_t response_size,
-			size_t dispatch_size, qb_hdb_handle_t * handle)
+			size_t dispatch_size, qb_handle_t * handle)
 {
 	int32_t request_fd;
 	struct sockaddr_un address;
@@ -718,7 +718,7 @@ error_connect:
 	return (res);
 }
 
-int32_t qb_ipcc_service_disconnect(qb_hdb_handle_t handle)
+int32_t qb_ipcc_service_disconnect(qb_handle_t handle)
 {
 	int32_t res;
 	struct ipc_instance *ipc_instance;
@@ -736,7 +736,7 @@ int32_t qb_ipcc_service_disconnect(qb_hdb_handle_t handle)
 }
 
 int32_t
-qb_ipcc_dispatch_flow_control_get(qb_hdb_handle_t handle,
+qb_ipcc_dispatch_flow_control_get(qb_handle_t handle,
 				  uint32_t * flow_control_state)
 {
 	struct ipc_instance *ipc_instance;
@@ -753,7 +753,7 @@ qb_ipcc_dispatch_flow_control_get(qb_hdb_handle_t handle,
 	return (res);
 }
 
-int32_t qb_ipcc_fd_get(qb_hdb_handle_t handle, int32_t * fd)
+int32_t qb_ipcc_fd_get(qb_handle_t handle, int32_t * fd)
 {
 	struct ipc_instance *ipc_instance;
 	int32_t res;
@@ -769,8 +769,7 @@ int32_t qb_ipcc_fd_get(qb_hdb_handle_t handle, int32_t * fd)
 	return (res);
 }
 
-int32_t qb_ipcc_dispatch_get(qb_hdb_handle_t handle, void **data,
-			     int32_t timeout)
+int32_t qb_ipcc_dispatch_get(qb_handle_t handle, void **data, int32_t timeout)
 {
 	struct pollfd ufds;
 	int32_t poll_events;
@@ -861,7 +860,7 @@ error_put:
 	return (error);
 }
 
-int32_t qb_ipcc_dispatch_put(qb_hdb_handle_t handle)
+int32_t qb_ipcc_dispatch_put(qb_handle_t handle)
 {
 	qb_ipc_response_header_t *header;
 	struct ipc_instance *ipc_instance;
@@ -898,8 +897,7 @@ error_exit:
 }
 
 int32_t
-qb_ipcc_msg_send(qb_hdb_handle_t handle,
-		 const struct iovec * iov, uint32_t iov_len)
+qb_ipcc_msg_send(qb_handle_t handle, const struct iovec * iov, uint32_t iov_len)
 {
 	int32_t res;
 	struct ipc_instance *ipc_instance;
@@ -920,7 +918,7 @@ qb_ipcc_msg_send(qb_hdb_handle_t handle,
 }
 
 int32_t
-qb_ipcc_msg_send_reply_receive(qb_hdb_handle_t handle,
+qb_ipcc_msg_send_reply_receive(qb_handle_t handle,
 			       const struct iovec * iov,
 			       uint32_t iov_len, void *res_msg, size_t res_len)
 {
@@ -949,7 +947,7 @@ error_exit:
 }
 
 int32_t
-qb_ipcc_msg_send_reply_receive_in_buf_get(qb_hdb_handle_t handle,
+qb_ipcc_msg_send_reply_receive_in_buf_get(qb_handle_t handle,
 					  const struct iovec * iov,
 					  uint32_t iov_len, void **res_msg)
 {
@@ -976,7 +974,7 @@ error_exit:
 	return (res);
 }
 
-int32_t qb_ipcc_msg_send_reply_receive_in_buf_put(qb_hdb_handle_t handle)
+int32_t qb_ipcc_msg_send_reply_receive_in_buf_put(qb_handle_t handle)
 {
 	int32_t res;
 	struct ipc_instance *ipc_instance;
@@ -992,7 +990,7 @@ int32_t qb_ipcc_msg_send_reply_receive_in_buf_put(qb_hdb_handle_t
handle)
 }
 
 int32_t
-qb_ipcc_zcb_alloc(qb_hdb_handle_t handle,
+qb_ipcc_zcb_alloc(qb_handle_t handle,
 		  void **buffer, size_t size, size_t header_size)
 {
 	struct ipc_instance *ipc_instance;
@@ -1035,7 +1033,7 @@ qb_ipcc_zcb_alloc(qb_hdb_handle_t handle,
 	return (res);
 }
 
-int32_t qb_ipcc_zcb_free(qb_hdb_handle_t handle, void *buffer)
+int32_t qb_ipcc_zcb_free(qb_handle_t handle, void *buffer)
 {
 	struct ipc_instance *ipc_instance;
 	mar_req_qb_ipcc_zc_free_t req_qb_ipcc_zc_free;
@@ -1073,7 +1071,7 @@ int32_t qb_ipcc_zcb_free(qb_hdb_handle_t handle, void *buffer)
 }
 
 int32_t
-qb_ipcc_zcb_msg_send_reply_receive(qb_hdb_handle_t handle,
+qb_ipcc_zcb_msg_send_reply_receive(qb_handle_t handle,
 				   void *msg, void *res_msg, size_t res_len)
 {
 	struct ipc_instance *ipc_instance;
diff --git a/lib/ipcs.c b/lib/ipcs.c
index 296d668..20c1d7f 100644
--- a/lib/ipcs.c
+++ b/lib/ipcs.c
@@ -28,6 +28,7 @@
 #include "os_base.h"
 #include <sys/mman.h>
 #include <sys/poll.h>
+#include <pthread.h>
 #if defined(HAVE_GETPEERUCRED)
 #include <ucred.h>
 #endif
@@ -103,7 +104,7 @@ struct conn_info {
 	int32_t notify_flow_control_enabled;
 	int32_t flow_control_state;
 	int32_t refcount;
-	qb_hdb_handle_t stats_handle;
+	qb_handle_t stats_handle;
 #if _POSIX_THREAD_PROCESS_SHARED < 1
 	key_t semkey;
 	int32_t semid;
@@ -139,24 +140,23 @@ static void ipc_disconnect(struct conn_info *conn_info);
 static void msg_send(void *conn, const struct iovec *iov, uint32_t iov_len,
 		     int32_t locked);
 
-static qb_hdb_handle_t dummy_stats_create_connection(const char *name,
-						     pid_t pid, int32_t fd)
+static qb_handle_t dummy_stats_create_connection(const char *name,
+						 pid_t pid, int32_t fd)
 {
 	return (0ULL);
 }
 
-static void dummy_stats_destroy_connection(qb_hdb_handle_t handle)
+static void dummy_stats_destroy_connection(qb_handle_t handle)
 {
 }
 
-static void dummy_stats_update_value(qb_hdb_handle_t handle,
+static void dummy_stats_update_value(qb_handle_t handle,
 				     const char *name,
 				     const void *value, size_t value_size)
 {
 }
 
-static void dummy_stats_increment_value(qb_hdb_handle_t handle,
-					const char *name)
+static void dummy_stats_increment_value(qb_handle_t handle, const char *name)
 {
 }
 
diff --git a/lib/logsys.c b/lib/logsys.c
index b5ccf9f..cb6e51b 100644
--- a/lib/logsys.c
+++ b/lib/logsys.c
@@ -951,7 +951,7 @@ void _logsys_log_rec(uint32_t rec_ident,
 	qb_thread_lock(logsys_flt_lock);
 
 	flt_data = qb_rb_chunk_alloc(rb,
-				       (record_reclaim_size * sizeof(uint32_t)));
+				     (record_reclaim_size * sizeof(uint32_t)));
 	assert(flt_data != NULL);
 	idx = 0;
 
diff --git a/lib/plugin_loader.c b/lib/plugin_loader.c
index 8a17ee9..9636a6b 100644
--- a/lib/plugin_loader.c
+++ b/lib/plugin_loader.c
@@ -37,21 +37,21 @@
 struct plugin_component_instance {
 	struct plugin_iface *ifaces;
 	int iface_count;
-	qb_hdb_handle_t comp_handle;
+	qb_handle_t comp_handle;
 	void *dl_handle;
 	int refcount;
 	char library_name[256];
 };
 
 struct plugin_iface_instance {
-	qb_hdb_handle_t component_handle;
+	qb_handle_t component_handle;
 	void *context;
 	void (*destructor) (void *context);
 };
 
-DECLARE_HDB_DATABASE(plugin_component_instance_database, NULL);
+QB_HDB_DECLARE(plugin_component_instance_database, NULL);
 
-DECLARE_HDB_DATABASE(plugin_iface_instance_database, NULL);
+QB_HDB_DECLARE(plugin_iface_instance_database, NULL);
 
 /*
 static struct hdb_handle_database plugin_component_instance_database = {
@@ -67,7 +67,7 @@ static struct hdb_handle_database plugin_iface_instance_database = {
 };
 */
 
-static qb_hdb_handle_t g_component_handle = 0xFFFFFFFF;
+static qb_handle_t g_component_handle = 0xFFFFFFFF;
 
 #if defined(QB_LINUX) || defined(QB_SOLARIS)
 static int plugin_select_so(const struct dirent *dirent)
@@ -110,7 +110,7 @@ static inline struct plugin_component_instance *plugin_comp_find(const
char
 {
 	struct plugin_component_instance *instance;
 	void *instance_p = NULL;
-	qb_hdb_handle_t component_handle = 0;
+	qb_handle_t component_handle = 0;
 	int i;
 
 	/*
@@ -141,7 +141,7 @@ static inline int plugin_lib_loaded(char *library_name)
 {
 	struct plugin_component_instance *instance;
 	void *instance_p = NULL;
-	qb_hdb_handle_t component_handle = 0;
+	qb_handle_t component_handle = 0;
 
 	/*
 	 * Try to find interface in already loaded component
@@ -450,7 +450,7 @@ found:
 
 static unsigned int plugin_initialized = 0;
 
-int plugin_ifact_reference(qb_hdb_handle_t * iface_handle,
+int plugin_ifact_reference(qb_handle_t * iface_handle,
 			   const char *iface_name,
 			   int version, void **iface, void *context)
 {
@@ -511,7 +511,7 @@ found:
 	return (0);
 }
 
-int plugin_ifact_release(qb_hdb_handle_t handle)
+int plugin_ifact_release(qb_handle_t handle)
 {
 	struct plugin_iface_instance *iface_instance;
 	int res = 0;
@@ -534,7 +534,7 @@ int plugin_ifact_release(qb_hdb_handle_t handle)
 void plugin_component_register(struct plugin_comp *comp)
 {
 	struct plugin_component_instance *instance;
-	static qb_hdb_handle_t comp_handle;
+	static qb_handle_t comp_handle;
 
 	qb_hdb_handle_create(&plugin_component_instance_database,
 			     sizeof(struct plugin_component_instance),
diff --git a/lib/poll.c b/lib/poll.c
index 8cedc6f..640fe20 100644
--- a/lib/poll.c
+++ b/lib/poll.c
@@ -34,7 +34,7 @@
 #include "tlist.h"
 #include "util_int.h"
 
-typedef int (*dispatch_fn_t) (qb_hdb_handle_t hdb_handle, int fd, int revents,
+typedef int (*dispatch_fn_t) (qb_handle_t hdb_handle, int fd, int revents,
 			      void *data);
 
 struct qb_poll_entry {
@@ -51,11 +51,11 @@ struct qb_poll_instance {
 	int stop_requested;
 };
 
-DECLARE_HDB_DATABASE(poll_instance_database, NULL);
+QB_HDB_DECLARE(poll_instance_database, NULL);
 
-qb_hdb_handle_t qb_poll_create(void)
+qb_handle_t qb_poll_create(void)
 {
-	qb_hdb_handle_t handle;
+	qb_handle_t handle;
 	struct qb_poll_instance *poll_instance;
 	unsigned int res;
 
@@ -85,7 +85,7 @@ error_exit:
 	return (-1);
 }
 
-int qb_poll_destroy(qb_hdb_handle_t handle)
+int qb_poll_destroy(qb_handle_t handle)
 {
 	struct qb_poll_instance *poll_instance;
 	int res = 0;
@@ -108,11 +108,11 @@ error_exit:
 	return (res);
 }
 
-int qb_poll_dispatch_add(qb_hdb_handle_t handle,
+int qb_poll_dispatch_add(qb_handle_t handle,
 			 int fd,
 			 int events,
 			 void *data,
-			 int (*dispatch_fn) (qb_hdb_handle_t hdb_handle_t,
+			 int (*dispatch_fn) (qb_handle_t hdb_handle_t,
 					     int fd, int revents, void *data))
 {
 	struct qb_poll_instance *poll_instance;
@@ -183,10 +183,10 @@ error_exit:
 	return (res);
 }
 
-int qb_poll_dispatch_modify(qb_hdb_handle_t handle,
+int qb_poll_dispatch_modify(qb_handle_t handle,
 			    int fd,
 			    int events,
-			    int (*dispatch_fn) (qb_hdb_handle_t hdb_handle_t,
+			    int (*dispatch_fn) (qb_handle_t hdb_handle_t,
 						int fd,
 						int revents, void *data))
 {
@@ -223,7 +223,7 @@ error_exit:
 	return (res);
 }
 
-int qb_poll_dispatch_delete(qb_hdb_handle_t handle, int fd)
+int qb_poll_dispatch_delete(qb_handle_t handle, int fd)
 {
 	struct qb_poll_instance *poll_instance;
 	int i;
@@ -257,7 +257,7 @@ error_exit:
 	return (res);
 }
 
-int qb_poll_timer_add(qb_hdb_handle_t handle,
+int qb_poll_timer_add(qb_handle_t handle,
 		      int msec_duration, void *data,
 		      void (*timer_fn) (void *data),
 		      qb_poll_timer_handle * timer_handle_out)
@@ -287,7 +287,7 @@ error_exit:
 	return (res);
 }
 
-int qb_poll_timer_delete(qb_hdb_handle_t handle, qb_poll_timer_handle th)
+int qb_poll_timer_delete(qb_handle_t handle, qb_poll_timer_handle th)
 {
 	struct qb_poll_instance *poll_instance;
 	int res = 0;
@@ -310,7 +310,7 @@ error_exit:
 	return (res);
 }
 
-int qb_poll_stop(qb_hdb_handle_t handle)
+int qb_poll_stop(qb_handle_t handle)
 {
 	struct qb_poll_instance *poll_instance;
 	unsigned int res;
@@ -329,7 +329,7 @@ error_exit:
 	return (res);
 }
 
-int qb_poll_run(qb_hdb_handle_t handle)
+int qb_poll_run(qb_handle_t handle)
 {
 	struct qb_poll_instance *poll_instance;
 	int i;
@@ -401,7 +401,7 @@ error_exit:
 }
 
 #ifdef COMPILE_OUT
-void qb_poll_print_state(qb_hdb_handle_t handle, int fd)
+void qb_poll_print_state(qb_handle_t handle, int fd)
 {
 	struct qb_poll_instance *poll_instance;
 	int i;
diff --git a/lib/ringbuffer.c b/lib/ringbuffer.c
index e006e6f..dc01011 100644
--- a/lib/ringbuffer.c
+++ b/lib/ringbuffer.c
@@ -226,7 +226,7 @@ void qb_rb_close(qb_ringbuffer_t * rb)
 	free(rb);
 }
 
-char* qb_rb_name_get(qb_ringbuffer_t * rb)
+char *qb_rb_name_get(qb_ringbuffer_t * rb)
 {
 	return rb->shared_hdr->hdr_path;
 }
@@ -452,8 +452,7 @@ void qb_rb_chunk_reclaim(qb_ringbuffer_t * rb)
 	rb->unlock_fn(rb);
 }
 
-ssize_t qb_rb_chunk_peek(qb_ringbuffer_t * rb, void **data_out, int32_t
-		timeout)
+ssize_t qb_rb_chunk_peek(qb_ringbuffer_t * rb, void **data_out, int32_t timeout)
 {
 	uint32_t read_pt;
 	uint32_t chunk_size;
@@ -463,8 +462,8 @@ ssize_t qb_rb_chunk_peek(qb_ringbuffer_t * rb, void **data_out,
int32_t
 	res = rb->sem_timedwait_fn(rb, timeout);
 	if (res == -1 && errno == ETIMEDOUT && rb->shared_hdr->count >
0) {
 		qb_util_log(LOG_ERR,
-			"sem timedout but count is %d",
-			rb->shared_hdr->count);
+			    "sem timedout but count is %d",
+			    rb->shared_hdr->count);
 	} else if (res == -1 && errno != EIDRM) {
 		if (errno != ETIMEDOUT) {
 			qb_util_log(LOG_ERR,
diff --git a/lib/ringbuffer.h b/lib/ringbuffer.h
index e19b7ec..ffa304e 100644
--- a/lib/ringbuffer.h
+++ b/lib/ringbuffer.h
@@ -40,18 +40,18 @@
 #include <qb/qbutil.h>
 #include <qb/qbrb.h>
 
-
 struct qb_ringbuffer_s;
 
-int32_t qb_rb_lock_create(struct qb_ringbuffer_s * rb, uint32_t flags);
-typedef int32_t (*qb_rb_lock_fn_t) (struct qb_ringbuffer_s * rb);
-typedef int32_t (*qb_rb_unlock_fn_t) (struct qb_ringbuffer_s * rb);
-typedef int32_t (*qb_rb_lock_destroy_fn_t) (struct qb_ringbuffer_s * rb);
+int32_t qb_rb_lock_create(struct qb_ringbuffer_s *rb, uint32_t flags);
+typedef int32_t(*qb_rb_lock_fn_t) (struct qb_ringbuffer_s * rb);
+typedef int32_t(*qb_rb_unlock_fn_t) (struct qb_ringbuffer_s * rb);
+typedef int32_t(*qb_rb_lock_destroy_fn_t) (struct qb_ringbuffer_s * rb);
 
-int32_t qb_rb_sem_create(struct qb_ringbuffer_s * rb, uint32_t flags);
-typedef int32_t (*qb_rb_sem_post_fn_t) (struct qb_ringbuffer_s * rb);
-typedef int32_t (*qb_rb_sem_timedwait_fn_t) (struct qb_ringbuffer_s * rb, int32_t
ms_timeout);
-typedef int32_t (*qb_rb_sem_destroy_fn_t) (struct qb_ringbuffer_s * rb);
+int32_t qb_rb_sem_create(struct qb_ringbuffer_s *rb, uint32_t flags);
+typedef int32_t(*qb_rb_sem_post_fn_t) (struct qb_ringbuffer_s * rb);
+typedef int32_t(*qb_rb_sem_timedwait_fn_t) (struct qb_ringbuffer_s * rb,
+					    int32_t ms_timeout);
+typedef int32_t(*qb_rb_sem_destroy_fn_t) (struct qb_ringbuffer_s * rb);
 
 struct qb_ringbuffer_shared_s {
 	volatile uint32_t write_pt;
@@ -92,6 +92,4 @@ union semun {
 
 #define RB_NS_IN_MSEC  1000000ULL
 
-
 #endif /* _RINGBUFFER_H_ */
-
diff --git a/lib/ringbuffer_helper.c b/lib/ringbuffer_helper.c
index 5a13bf1..85a369d 100644
--- a/lib/ringbuffer_helper.c
+++ b/lib/ringbuffer_helper.c
@@ -44,7 +44,7 @@ static int32_t my_posix_sem_timedwait(qb_ringbuffer_t * rb, int32_t
ms_timeout)
 		ts_timeout.tv_nsec = (ms_timeout % 1000) * RB_NS_IN_MSEC;
 	}
 
- sem_wait_again:
+sem_wait_again:
 	if (ms_timeout > 0) {
 		res = sem_timedwait(&rb->shared_hdr->posix_sem, &ts_timeout);
 	} else if (ms_timeout == 0) {
@@ -57,8 +57,8 @@ static int32_t my_posix_sem_timedwait(qb_ringbuffer_t * rb, int32_t
ms_timeout)
 			goto sem_wait_again;
 		} else if (errno != ETIMEDOUT) {
 			qb_util_log(LOG_ERR,
-				"error waiting for semaphore : %s",
-				strerror(errno));
+				    "error waiting for semaphore : %s",
+				    strerror(errno));
 		}
 	}
 	return res;
diff --git a/tests/bmc.c b/tests/bmc.c
index 93d2db7..f071829 100644
--- a/tests/bmc.c
+++ b/tests/bmc.c
@@ -22,6 +22,7 @@
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <qb/qbipcc.h>
+#include <errno.h>
 #include <stdio.h>
 #include <stdint.h>
 #include <string.h>
@@ -81,7 +82,7 @@ static void bm_finish(const char *operation, int size)
 	printf("MB/sec %9.3f\n", mbs_per_sec);
 }
 
-qb_hdb_handle_t bmc_ipc_handle;
+qb_handle_t bmc_ipc_handle;
 
 static void bmc_connect(void)
 {
diff --git a/tests/bmcpt.c b/tests/bmcpt.c
index 2243cda..f7d40c4 100644
--- a/tests/bmcpt.c
+++ b/tests/bmcpt.c
@@ -32,7 +32,7 @@
 #define ITERATIONS 10000000
 
 struct bm_ctx {
-	qb_hdb_handle_t bmc_ipc_handle;
+	qb_handle_t bmc_ipc_handle;
 	struct timeval tv1;
 	struct timeval tv2;
 	struct timeval tv_elapsed;
diff --git a/tests/bms.c b/tests/bms.c
index 7a775e3..6aef6b1 100644
--- a/tests/bms.c
+++ b/tests/bms.c
@@ -49,7 +49,7 @@
 int blocking = 1;
 int verbose = 0;
 
-static qb_hdb_handle_t bms_poll_handle;
+static qb_handle_t bms_poll_handle;
 
 struct lib_handler {
 	void (*lib_handler_fn) (void *conn, const void *msg);
@@ -212,7 +212,7 @@ static void ipc_fatal_error(const char *error_msg)
 	exit(1);
 }
 
-static int bms_poll_handler_accept(qb_hdb_handle_t handle,
+static int bms_poll_handler_accept(qb_handle_t handle,
 				   int fd, int revent, void *context)
 {
 	if (verbose) {
@@ -221,7 +221,7 @@ static int bms_poll_handler_accept(qb_hdb_handle_t handle,
 	return (qb_ipcs_handler_accept(fd, revent, context));
 }
 
-static int bms_poll_handler_dispatch(qb_hdb_handle_t handle,
+static int bms_poll_handler_dispatch(qb_handle_t handle,
 				     int fd, int revent, void *context)
 {
 	return (qb_ipcs_handler_dispatch(fd, revent, context));
diff --git a/tests/check_hash.c b/tests/check_hash.c
index 18937aa..89fb78f 100644
--- a/tests/check_hash.c
+++ b/tests/check_hash.c
@@ -29,11 +29,11 @@ START_TEST(test_hash_load)
 	char word[1000];
 	FILE *fp;
 	int res = 0;
-	qb_hdb_handle_t handle = 0;
+	qb_handle_t handle = 0;
 	void *value;
 	uint64_t value_len;
 
-	if (access("/usr/shar/dict/words", R_OK) != 0 ) {
+	if (access("/usr/share/dict/words", R_OK) != 0) {
 		printf("no dict/words - not testing\n");
 		return;
 	}
diff --git a/tests/check_plugin.c b/tests/check_plugin.c
index a3a1a6c..a3a00f6 100644
--- a/tests/check_plugin.c
+++ b/tests/check_plugin.c
@@ -33,15 +33,15 @@ struct iface {
 
 START_TEST(test_plugin)
 {
-	qb_hdb_handle_t a_ifact_handle_ver0;
-	qb_hdb_handle_t b_ifact_handle_ver0;
+	qb_handle_t a_ifact_handle_ver0;
+	qb_handle_t b_ifact_handle_ver0;
 	struct iface *a_iface_ver0;
 	struct iface *a_iface_ver1;
 	void *a_iface_ver0_p;
 	void *a_iface_ver1_p;
 
-	qb_hdb_handle_t a_ifact_handle_ver1;
-	qb_hdb_handle_t b_ifact_handle_ver1;
+	qb_handle_t a_ifact_handle_ver1;
+	qb_handle_t b_ifact_handle_ver1;
 	struct iface *b_iface_ver0;
 	struct iface *b_iface_ver1;
 	void *b_iface_ver0_p;
-- 
1.6.6.1

[PATCH 3/3] list: rename QB_DECLARE_LIST_INIT -> QB_LIST_DECLARE

[Angus Salkeld]

Signed-off-by: Angus Salkeld <asalkeld(a)redhat.com&gt;
---
 include/qb/qblist.h |    4 ++--
 lib/ipcs.c          |    4 ++--
 lib/logsys.c        |    2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/include/qb/qblist.h b/include/qb/qblist.h
index bf3373a..d28880c 100644
--- a/include/qb/qblist.h
+++ b/include/qb/qblist.h
@@ -40,10 +40,10 @@ struct qb_list_head {
 };
 
 /**
- * @def QB_DECLARE_LIST_INIT()
+ * @def QB_LIST_DECLARE()
  * Declare and initialize a list head.
  */
-#define QB_DECLARE_LIST_INIT(name) \
+#define QB_LIST_DECLARE(name) \
     struct qb_list_head name = { &(name), &(name) }
 
 /**
diff --git a/lib/ipcs.c b/lib/ipcs.c
index 20c1d7f..b99268b 100644
--- a/lib/ipcs.c
+++ b/lib/ipcs.c
@@ -58,9 +58,9 @@
 
 static struct qb_ipcs_init_state *api = NULL;
 
-QB_DECLARE_LIST_INIT(conn_info_qb_list_head);
+QB_LIST_DECLARE(conn_info_qb_list_head);
 
-QB_DECLARE_LIST_INIT(conn_info_exit_qb_list_head);
+QB_LIST_DECLARE(conn_info_exit_qb_list_head);
 
 struct outq_item {
 	void *msg;
diff --git a/lib/logsys.c b/lib/logsys.c
index cb6e51b..5449f75 100644
--- a/lib/logsys.c
+++ b/lib/logsys.c
@@ -149,7 +149,7 @@ static int32_t logsys_dropped_messages = 0;
 
 void *qb_logsys_rec_end;
 
-static QB_DECLARE_LIST_INIT(logsys_print_finished_records);
+static QB_LIST_DECLARE(logsys_print_finished_records);
 
 #define FDMAX_ARGS	64
 
-- 
1.6.6.1