rewrited triton library

7 files changed, 271 insertions, 110 deletions

diff --git a/accel-pptpd/triton/CMakeLists.txt b/accel-pptpd/triton/CMakeLists.txt
index b11025d..fd6b518 100644
--- a/accel-pptpd/triton/CMakeLists.txt
+++ b/accel-pptpd/triton/CMakeLists.txt
@@ -6,6 +6,7 @@ SET(sources_c
 	conf_file.c
 	loader.c
 	log.c
+	mempool.c
 )
 INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR})
 ADD_DEFINITIONS("-DUSE_SPINLOCK")
diff --git a/accel-pptpd/triton/md.c b/accel-pptpd/triton/md.c
index c1aefcf..3cb47a6 100644
--- a/accel-pptpd/triton/md.c
+++ b/accel-pptpd/triton/md.c
@@ -16,6 +16,8 @@ static struct epoll_event *epoll_events;
 static pthread_t md_thr;
 static void *md_thread(void *arg);
 
+static mempool_t *md_pool;
+
 int md_init(void)
 {
 	epoll_fd = epoll_create(1);
@@ -30,6 +32,8 @@ int md_init(void)
 		return -1;
 	}
 
+	md_pool = mempool_create(sizeof(struct _triton_md_handler_t));
+
 	return 0;
 }
 void md_run(void)
@@ -49,7 +53,7 @@ void md_terminate(void)
 static void *md_thread(void *arg)
 {
 	int i,n,r;
-	struct triton_md_handler_t *h;
+	struct _triton_md_handler_t *h;
 
 	while(1) {
 		n = epoll_wait(epoll_fd, epoll_events, max_events, -1);
@@ -61,13 +65,16 @@ static void *md_thread(void *arg)
 		}
 		
 		for(i = 0; i < n; i++) {
-			h = (struct triton_md_handler_t *)epoll_events[i].data.ptr;
+			h = (struct _triton_md_handler_t *)epoll_events[i].data.ptr;
 			spin_lock(&h->ctx->lock);
-			h->trig_epoll_events |= epoll_events[i].events;
-			if (!h->pending) {
-				list_add_tail(&h->entry2, &h->ctx->pending_handlers);
-				h->pending = 1;
-				r = triton_queue_ctx(h->ctx);
+			if (h->ud) {
+				h->trig_epoll_events |= epoll_events[i].events;
+				if (!h->pending) {
+					list_add_tail(&h->entry2, &h->ctx->pending_handlers);
+					h->pending = 1;
+					r = triton_queue_ctx(h->ctx);
+				} else
+					r = 0;
 			} else
 				r = 0;
 			spin_unlock(&h->ctx->lock);
@@ -79,25 +86,37 @@ static void *md_thread(void *arg)
 	return NULL;
 }
 
-void __export triton_md_register_handler(struct triton_md_handler_t *h)
+void __export triton_md_register_handler(struct triton_ctx_t *ctx, struct triton_md_handler_t *ud)
 {
+	struct _triton_md_handler_t *h = mempool_alloc(md_pool);
+	memset(h, 0, sizeof(*h));
+	h->ud = ud;
 	h->epoll_event.data.ptr = h;
-	if (!h->ctx)
-		h->ctx = default_ctx;
+	if (ctx)
+		h->ctx = (struct _triton_ctx_t *)ctx->tpd;
+	else
+		h->ctx = (struct _triton_ctx_t *)default_ctx->tpd;
+	ud->tpd = h;
 	spin_lock(&h->ctx->lock);
 	list_add_tail(&h->entry, &h->ctx->handlers);
 	spin_unlock(&h->ctx->lock);
 }
-void __export triton_md_unregister_handler(struct triton_md_handler_t *h)
+void __export triton_md_unregister_handler(struct triton_md_handler_t *ud)
 {
+	struct _triton_md_handler_t *h = (struct _triton_md_handler_t *)ud->tpd;
+	triton_md_disable_handler(ud, MD_MODE_READ | MD_MODE_WRITE);
 	spin_lock(&h->ctx->lock);
 	list_del(&h->entry);
 	if (h->pending)
 		list_del(&h->entry2);
+	h->ud = NULL;
 	spin_unlock(&h->ctx->lock);
+	sched_yield();
+	mempool_free(h);
 }
-int __export triton_md_enable_handler(struct triton_md_handler_t *h, int mode)
+int __export triton_md_enable_handler(struct triton_md_handler_t *ud, int mode)
 {
+	struct _triton_md_handler_t *h = (struct _triton_md_handler_t *)ud->tpd;
 	int r;
 	int events = h->epoll_event.events;
 
@@ -109,17 +128,18 @@ int __export triton_md_enable_handler(struct triton_md_handler_t *h, int mode)
 	h->epoll_event.events |= EPOLLET;
 	
 	if (events)
-		r = epoll_ctl(epoll_fd, EPOLL_CTL_MOD, h->fd, &h->epoll_event);
+		r = epoll_ctl(epoll_fd, EPOLL_CTL_MOD, h->ud->fd, &h->epoll_event);
 	else
-		r = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, h->fd, &h->epoll_event);
+		r = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, h->ud->fd, &h->epoll_event);
 
 	if (r)
 		triton_log_error("md:epoll_ctl: %s",strerror(errno));
 
 	return r;
 }
-int __export triton_md_disable_handler(struct triton_md_handler_t *h,int mode)
+int __export triton_md_disable_handler(struct triton_md_handler_t *ud,int mode)
 {
+	struct _triton_md_handler_t *h = (struct _triton_md_handler_t *)ud->tpd;
 	int r=0;
 
 	if (!h->epoll_event.events)
@@ -131,10 +151,10 @@ int __export triton_md_disable_handler(struct triton_md_handler_t *h,int mode)
 		h->epoll_event.events &= ~EPOLLOUT;
 
 	if (h->epoll_event.events & (EPOLLIN | EPOLLOUT))
-		r = epoll_ctl(epoll_fd, EPOLL_CTL_MOD, h->fd, &h->epoll_event);
+		r = epoll_ctl(epoll_fd, EPOLL_CTL_MOD, h->ud->fd, &h->epoll_event);
 	else {
 		h->epoll_event.events = 0;
-		r = epoll_ctl(epoll_fd, EPOLL_CTL_DEL, h->fd, NULL);
+		r = epoll_ctl(epoll_fd, EPOLL_CTL_DEL, h->ud->fd, NULL);
 	}
 
 	if (r)
diff --git a/accel-pptpd/triton/mempool.c b/accel-pptpd/triton/mempool.c
new file mode 100644
index 0000000..973fec5
--- /dev/null
+++ b/accel-pptpd/triton/mempool.c
@@ -0,0 +1,67 @@
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "triton_p.h"
+
+struct _mempool_t
+{
+	int size;
+	struct list_head items;
+	spinlock_t lock;
+	uint64_t magic;
+};
+
+struct _item_t
+{
+	struct _mempool_t *owner;
+	struct list_head entry;
+	uint64_t magic;
+	char ptr[0];
+};
+
+mempool_t *mempool_create(int size)
+{
+	struct _mempool_t *p = malloc(sizeof(*p));
+
+	memset(p, 0, sizeof(*p));
+	INIT_LIST_HEAD(&p->items);
+	spinlock_init(&p->lock);
+	p->size = size;
+	p->magic = (uint64_t)random() * (uint64_t)random();
+
+	return (mempool_t *)p;
+}
+
+void *mempool_alloc(mempool_t *pool)
+{
+	struct _mempool_t *p = (struct _mempool_t *)pool;
+	struct _item_t *it;
+
+	spin_lock(&p->lock);
+	if (!list_empty(&p->items)) {
+		it = list_entry(p->items.next, typeof(*it), entry);
+		list_del(&it->entry);
+		spin_unlock(&p->lock);
+		return it->ptr;
+	}
+	spin_unlock(&p->lock);
+	it = malloc(sizeof(*it) + p->size);
+	it->owner = p;
+	it->magic = p->magic;
+	return it->ptr;
+}
+
+void mempool_free(void *ptr)
+{
+	struct _item_t *it = container_of(ptr, typeof(*it), ptr);
+
+	if (it->magic != it->owner->magic) {
+		triton_log_error("mempool: memory corruption detected");
+		abort();
+	}
+	spin_lock(&it->owner->lock);
+	list_add_tail(&it->entry,&it->owner->items);
+	spin_unlock(&it->owner->lock);
+}
+
diff --git a/accel-pptpd/triton/timer.c b/accel-pptpd/triton/timer.c
index 5f7de93..f34c19d 100644
--- a/accel-pptpd/triton/timer.c
+++ b/accel-pptpd/triton/timer.c
@@ -16,6 +16,8 @@ static struct epoll_event *epoll_events;
 static pthread_t timer_thr;
 static void *timer_thread(void *arg);
 
+static mempool_t *timer_pool;
+
 int timer_init(void)
 {
 	epoll_fd = epoll_create(1);
@@ -30,6 +32,8 @@ int timer_init(void)
 		return -1;
 	}
 
+	timer_pool = mempool_create(sizeof(struct _triton_timer_t));
+
 	return 0;
 }
 
@@ -50,7 +54,7 @@ void timer_terminate(void)
 void *timer_thread(void *arg)
 {
 	int i,n,r;
-	struct triton_timer_t *t;
+	struct _triton_timer_t *t;
 	
 	while(1) {
 		n = epoll_wait(epoll_fd, epoll_events, max_events, -1);
@@ -62,11 +66,17 @@ void *timer_thread(void *arg)
 		}
 		
 		for(i = 0; i < n; i++) {
-			t = (struct triton_timer_t *)epoll_events[i].data.ptr;
+			t = (struct _triton_timer_t *)epoll_events[i].data.ptr;
 			spin_lock(&t->ctx->lock);
-			list_add_tail(&t->entry2, &t->ctx->pending_timers);
-			t->pending = 1;
-			r=triton_queue_ctx(t->ctx);
+			if (t->ud) {
+				if (!t->pending) {
+					list_add_tail(&t->entry2, &t->ctx->pending_timers);
+					t->pending = 1;
+					r = triton_queue_ctx(t->ctx);
+				} else
+					r = 0;
+			} else
+				r = 0;
 			spin_unlock(&t->ctx->lock);
 			if (r)
 				triton_thread_wakeup(t->ctx->thread);
@@ -76,20 +86,30 @@ void *timer_thread(void *arg)
 	return NULL;
 }
 
-int __export triton_timer_add(struct triton_timer_t *t, int abs_time)
+int __export triton_timer_add(struct triton_ctx_t *ctx, struct triton_timer_t *ud, int abs_time)
 {
+	struct _triton_timer_t *t = mempool_alloc(timer_pool);
+
+	memset(t, 0, sizeof(*t));
+	t->ud = ud;
 	t->epoll_event.data.ptr = t;
 	t->epoll_event.events = EPOLLIN | EPOLLET;
-	if (!t->ctx)
-		t->ctx = default_ctx;
+	if (ctx)
+		t->ctx = (struct _triton_ctx_t *)ctx->tpd;
+	else
+		t->ctx = (struct _triton_ctx_t *)default_ctx->tpd;
 	t->fd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK);
 	if (t->fd < 0) {
 		triton_log_error("timer:timerfd_create: %s" ,strerror(errno));
+		mempool_free(t);
 		return -1;
 	}
 	
-	if (triton_timer_mod(t, abs_time)) {
+	ud->tpd = t;
+
+	if (triton_timer_mod(ud, abs_time)) {
 		close(t->fd);
+		mempool_free(t);
 		return -1;
 	}
 	
@@ -100,24 +120,28 @@ int __export triton_timer_add(struct triton_timer_t *t, int abs_time)
 	if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, t->fd, &t->epoll_event)) {
 		triton_log_error("timer:epoll_ctl: %s", strerror(errno));
 		spin_lock(&t->ctx->lock);
+		t->ud = NULL;
 		list_del(&t->entry);
 		spin_unlock(&t->ctx->lock);
 		close(t->fd);
+		mempool_free(t);
+		ud->tpd = NULL;
 		return -1;
 	}
 
 	return 0;
 }
-int __export triton_timer_mod(struct triton_timer_t *t,int abs_time)
+int __export triton_timer_mod(struct triton_timer_t *ud,int abs_time)
 {
+	struct _triton_timer_t *t = (struct _triton_timer_t *)ud->tpd;
 	struct itimerspec ts =	{
-		.it_value.tv_sec = t->expire_tv.tv_sec,
-		.it_value.tv_nsec = t->expire_tv.tv_usec * 1000,
-		.it_interval.tv_sec = t->period / 1000,
-		.it_interval.tv_nsec = t->period % 1000 * 1000,
+		.it_value.tv_sec = ud->expire_tv.tv_sec,
+		.it_value.tv_nsec = ud->expire_tv.tv_usec * 1000,
+		.it_interval.tv_sec = ud->period / 1000,
+		.it_interval.tv_nsec = (ud->period % 1000) * 1000,
 	};
 
-	if (t->expire_tv.tv_sec == 0 && t->expire_tv.tv_usec == 0)
+	if (ud->expire_tv.tv_sec == 0 && ud->expire_tv.tv_usec == 0)
 		ts.it_value = ts.it_interval;
 
 	if (timerfd_settime(t->fd, abs_time ? TFD_TIMER_ABSTIME : 0, &ts, NULL)) {
@@ -127,14 +151,18 @@ int __export triton_timer_mod(struct triton_timer_t *t,int abs_time)
 
 	return 0;
 }
-void __export triton_timer_del(struct triton_timer_t *t)
+void __export triton_timer_del(struct triton_timer_t *ud)
 {
+	struct _triton_timer_t *t = (struct _triton_timer_t *)ud->tpd;
 	epoll_ctl(epoll_fd, EPOLL_CTL_DEL, t->fd, &t->epoll_event);
 	close(t->fd);
 	spin_lock(&t->ctx->lock);
 	list_del(&t->entry);
 	if (t->pending)
 		list_del(&t->entry2);
+	t->ud = NULL;
 	spin_unlock(&t->ctx->lock);
+	sched_yield();
+	mempool_free(t);
 }
 
diff --git a/accel-pptpd/triton/triton.c b/accel-pptpd/triton/triton.c
index 121e695..8c8d5a3 100644
--- a/accel-pptpd/triton/triton.c
+++ b/accel-pptpd/triton/triton.c
@@ -22,17 +22,20 @@ static LIST_HEAD(ctx_list);
 struct triton_ctx_t *default_ctx;
 static int terminate;
 
-void triton_thread_wakeup(struct triton_thread_t *thread)
+static mempool_t *ctx_pool;
+
+void triton_thread_wakeup(struct _triton_thread_t *thread)
 {
 	pthread_kill(thread->thread, SIGUSR1);
 }
 
-static void* triton_thread(struct triton_thread_t *thread)
+static void* triton_thread(struct _triton_thread_t *thread)
 {
-	struct triton_md_handler_t *h;
-	struct triton_timer_t *t;
+	struct _triton_md_handler_t *h;
+	struct _triton_timer_t *t;
 	sigset_t set;
 	int sig;
+	uint64_t tt;
 
 	sigemptyset(&set);
 	sigaddset(&set, SIGUSR1);
@@ -43,7 +46,8 @@ static void* triton_thread(struct triton_thread_t *thread)
 
 cont:
 		if (thread->ctx->need_close) {
-			thread->ctx->close(thread->ctx);
+			if (thread->ctx->ud->close)
+				thread->ctx->ud->close(thread->ctx->ud);
 			thread->ctx->need_close = 0;
 		}
 
@@ -52,9 +56,10 @@ cont:
 			if (!list_empty(&thread->ctx->pending_timers)) {
 				t = list_entry(thread->ctx->pending_timers.next, typeof(*t), entry2);
 				list_del(&t->entry2);
+				t->pending = 0;
 				spin_unlock(&thread->ctx->lock);
-				if (t->expire(t))
-					continue;
+				read(t->fd, &tt, sizeof(tt));
+				t->ud->expire(t->ud);
 			}
 			if (!list_empty(&thread->ctx->pending_handlers)) {
 				h = list_entry(thread->ctx->pending_handlers.next, typeof(*h), entry2);
@@ -63,12 +68,12 @@ cont:
 				spin_unlock(&thread->ctx->lock);
 
 				if (h->trig_epoll_events & (EPOLLIN | EPOLLERR | EPOLLHUP))
-					if (h->read)
-						if (h->read(h))
+					if (h->ud->read)
+						if (h->ud->read(h->ud))
 							continue;
 				if (h->trig_epoll_events & (EPOLLOUT | EPOLLERR | EPOLLHUP))
-					if (h->write)
-						if (h->write(h))
+					if (h->ud->write)
+						if (h->ud->write(h->ud))
 							continue;
 				h->trig_epoll_events = 0;
 				continue;
@@ -76,7 +81,7 @@ cont:
 			thread->ctx->thread = NULL;
 			spin_unlock(&thread->ctx->lock);
 			if (thread->ctx->need_free)
-				thread->ctx->free(thread->ctx);
+				mempool_free(thread->ctx);
 			thread->ctx = NULL;
 			break;
 		}
@@ -101,9 +106,9 @@ cont:
 	}
 }
 
-struct triton_thread_t *create_thread()
+struct _triton_thread_t *create_thread()
 {
-	struct triton_thread_t *thread = malloc(sizeof(*thread));
+	struct _triton_thread_t *thread = malloc(sizeof(*thread));
 	if (!thread)
 		return NULL;
 
@@ -116,7 +121,7 @@ struct triton_thread_t *create_thread()
 	return thread;
 }
 
-int triton_queue_ctx(struct triton_ctx_t *ctx)
+int triton_queue_ctx(struct _triton_ctx_t *ctx)
 {
 	if (ctx->thread || ctx->queued)
 		return 0;
@@ -137,21 +142,46 @@ int triton_queue_ctx(struct triton_ctx_t *ctx)
 	return 1;
 }
 
-void __export triton_register_ctx(struct triton_ctx_t *ctx)
+void __export triton_register_ctx(struct triton_ctx_t *ud)
 {
+	struct _triton_ctx_t *ctx = mempool_alloc(ctx_pool);
+
+	memset(ctx, 0, sizeof(*ctx));
+	ctx->ud = ud;
 	spinlock_init(&ctx->lock);
 	INIT_LIST_HEAD(&ctx->handlers);
 	INIT_LIST_HEAD(&ctx->timers);
 	INIT_LIST_HEAD(&ctx->pending_handlers);
 	INIT_LIST_HEAD(&ctx->pending_timers);
 
+	ud->tpd = ctx;
+
 	spin_lock(&ctx_list_lock);
 	list_add_tail(&ctx->entry, &ctx_list);
 	spin_unlock(&ctx_list_lock);
 }
 
-void __export triton_unregister_ctx(struct triton_ctx_t *ctx)
+void __export triton_unregister_ctx(struct triton_ctx_t *ud)
 {
+	struct _triton_ctx_t *ctx = (struct _triton_ctx_t *)ud->tpd;
+
+	if (!list_empty(&ctx->handlers)) {
+		triton_log_error("BUG:ctx:triton_unregister_ctx: handlers is not empty");
+		abort();
+	}
+	if (!list_empty(&ctx->pending_handlers)) {
+		triton_log_error("BUG:ctx:triton_unregister_ctx: pending_handlers is not empty");
+		abort();
+	}
+	if (!list_empty(&ctx->timers)) {
+		triton_log_error("BUG:ctx:triton_unregister_ctx: timers is not empty");
+		abort();
+	}
+	if (!list_empty(&ctx->pending_timers)) {
+		triton_log_error("BUG:ctx:triton_unregister_ctx: pending_timers is not empty");
+		abort();
+	}
+
 	ctx->need_free = 1;
 	spin_lock(&ctx_list_lock);
 	list_del(&ctx->entry);
@@ -160,7 +190,9 @@ void __export triton_unregister_ctx(struct triton_ctx_t *ctx)
 
 int __export triton_init(const char *conf_file)
 {
-	default_ctx=malloc(sizeof(*default_ctx));
+	ctx_pool = mempool_create(sizeof(struct _triton_ctx_t));
+
+	default_ctx = malloc(sizeof(*default_ctx));
 	if (!default_ctx) {
 		fprintf(stderr,"cann't allocate memory\n");
 		return -1;
@@ -184,7 +216,7 @@ int __export triton_init(const char *conf_file)
 
 void __export triton_run()
 {
-	struct triton_thread_t *t;
+	struct _triton_thread_t *t;
 	int i;
 
 	for(i = 0; i < thread_count; i++) {
@@ -202,8 +234,8 @@ void __export triton_run()
 
 void __export triton_terminate()
 {
-	struct triton_ctx_t *ctx;
-	struct triton_thread_t *t;
+	struct _triton_ctx_t *ctx;
+	struct _triton_thread_t *t;
 	
 	md_terminate();
 	timer_terminate();
diff --git a/accel-pptpd/triton/triton.h b/accel-pptpd/triton/triton.h
index 2cc4edb..2543a23 100644
--- a/accel-pptpd/triton/triton.h
+++ b/accel-pptpd/triton/triton.h
@@ -2,79 +2,35 @@
 #define TRITON_H
 
 #include <sys/time.h>
-#include <pthread.h>
-#include <sys/epoll.h>
 
 #include "list.h"
-#include "spinlock.h"
-
-struct triton_thread_t
-{
-	struct list_head entry;
-	struct list_head entry2;
-	pthread_t thread;
-	int terminate:1;
-	struct triton_ctx_t *ctx;
-};
 
 struct triton_ctx_t
 {
-	struct list_head entry;
-	struct list_head entry2;
-	spinlock_t lock;
-	struct list_head handlers;
-	struct list_head timers;
-
-	struct triton_thread_t *thread;
-	struct list_head pending_handlers;
-	struct list_head pending_timers;
-	int queued:1;
-	int need_close:1;
-	int need_free:1;
-
+	const void *tpd; // triton private data, don't touch!
 	void (*close)(struct triton_ctx_t*);
 	void (*free)(struct triton_ctx_t*);
 };
 
 struct triton_md_handler_t
 {
-	//triton part
-	//==========
-	struct list_head entry;
-	struct list_head entry2;
-	struct triton_ctx_t *ctx;
-	struct epoll_event epoll_event;
-	uint32_t trig_epoll_events;
-	int pending:1;
-	//=========
-
-	//user part
-	//=========
+	const void *tpd; // triton private data, don't touch!
 	int fd;
-
 	int (*read)(struct triton_md_handler_t *);
 	int (*write)(struct triton_md_handler_t *);
-	//=========
 };
 
 struct triton_timer_t
 {
-	struct list_head entry;
-	struct list_head entry2;
-	struct epoll_event epoll_event;
-	struct triton_ctx_t *ctx;
-	int fd;
-	int pending:1;
-
+	const void *tpd; // triton private data, don't touch!
 	struct timeval expire_tv;
 	int period;
-	int (*expire)(struct triton_timer_t *);
+	void (*expire)(struct triton_timer_t *);
 };
 
 struct conf_option_t
 {
 	struct list_head entry;
-
 	char *name;
 	char *val;
 };
@@ -90,14 +46,14 @@ void triton_unregister_ctx(struct triton_ctx_t *);
 
 #define MD_MODE_READ 1
 #define MD_MODE_WRITE 2
-void triton_md_register_handler(struct triton_md_handler_t *h);
+void triton_md_register_handler(struct triton_ctx_t *, struct triton_md_handler_t *);
 void triton_md_unregister_handler(struct triton_md_handler_t *h);
 int triton_md_enable_handler(struct triton_md_handler_t *h, int mode);
 int triton_md_disable_handler(struct triton_md_handler_t *h,int mode);
 
-int triton_timer_add(struct triton_timer_t*,int abs_time);
-int triton_timer_mod(struct triton_timer_t*,int abs_time);
-void triton_timer_del(struct triton_timer_t*);
+int triton_timer_add(struct triton_ctx_t *ctx, struct triton_timer_t*,int abs_time);
+int triton_timer_mod(struct triton_timer_t *,int abs_time);
+void triton_timer_del(struct triton_timer_t *);
 
 struct conf_sect_t *conf_get_section(const char *name);
 char *conf_get_opt(const char *sect, const char *name);
@@ -117,6 +73,7 @@ void triton_terminate(void);
 
 
 #define __init __attribute__((constructor))
+#define __export __attribute__((visibility("default")))
 
 #undef offsetof
 #ifdef __compiler_offsetof
@@ -129,6 +86,4 @@ void triton_terminate(void);
 	const typeof( ((type *)0)->member ) *__mptr = (ptr);	\
 	(type *)( (char *)__mptr - offsetof(type,member) );})
 
-#define __export __attribute__((visibility("default")))
-
 #endif
diff --git a/accel-pptpd/triton/triton_p.h b/accel-pptpd/triton/triton_p.h
index 385f355..24850bf 100644
--- a/accel-pptpd/triton/triton_p.h
+++ b/accel-pptpd/triton/triton_p.h
@@ -1,8 +1,66 @@
 #ifndef TRITON_P_H
 #define TRITON_P_H
 
+#include <pthread.h>
+#include <sys/epoll.h>
+
 #include "triton.h"
 #include "list.h"
+#include "spinlock.h"
+
+struct _triton_thread_t
+{
+	struct list_head entry;
+	struct list_head entry2;
+	pthread_t thread;
+	int terminate:1;
+	struct _triton_ctx_t *ctx;
+};
+
+struct _triton_ctx_t
+{
+	struct list_head entry;
+	struct list_head entry2;
+	spinlock_t lock;
+	struct list_head handlers;
+	struct list_head timers;
+
+	struct _triton_thread_t *thread;
+	struct list_head pending_handlers;
+	struct list_head pending_timers;
+	int queued:1;
+	int need_close:1;
+	int need_free:1;
+
+	struct triton_ctx_t *ud;
+};
+
+struct _triton_md_handler_t
+{
+	struct list_head entry;
+	struct list_head entry2;
+	struct _triton_ctx_t *ctx;
+	struct epoll_event epoll_event;
+	uint32_t trig_epoll_events;
+	int pending:1;
+	struct triton_md_handler_t *ud;
+};
+
+struct _triton_timer_t
+{
+	struct list_head entry;
+	struct list_head entry2;
+	struct epoll_event epoll_event;
+	struct _triton_ctx_t *ctx;
+	int fd;
+	int pending:1;
+	struct triton_timer_t *ud;
+};
+
+typedef void * mempool_t;
+mempool_t *mempool_create(int size);
+void *mempool_alloc(mempool_t*);
+void mempool_free(void*);
 
 int log_init(void);
 int md_init();
@@ -12,8 +70,8 @@ int timer_init();
 void timer_run();
 void timer_terminate();
 struct triton_ctx_t *default_ctx;
-int triton_queue_ctx(struct triton_ctx_t*);
-void triton_thread_wakeup(struct triton_thread_t*);
+int triton_queue_ctx(struct _triton_ctx_t*);
+void triton_thread_wakeup(struct _triton_thread_t*);
 int conf_load(const char *fname);
 void triton_log_error(const char *fmt,...);
 void triton_log_debug(const char *fmt,...);