From 75a28b0fcc69041735d610e2b31dda1c46051089 Mon Sep 17 00:00:00 2001
From: Cloud Wu <cloudwu@gmail.com>
Date: Tue, 22 Apr 2014 12:26:08 +0800
Subject: [PATCH 1/3] use skynet malloc api directly

---
 service-src/databuffer.h     |  6 ++---
 service-src/hashid.h         |  8 +++----
 service-src/service_gate.c   | 16 ++++++-------
 service-src/service_harbor.c | 46 ++++++++++++++++++------------------
 service-src/service_logger.c |  4 ++--
 service-src/service_master.c | 16 ++++++-------
 service-src/service_snlua.c  |  6 ++---
 skynet-src/skynet_env.c      |  3 +--
 skynet-src/skynet_error.c    |  4 ++--
 skynet-src/skynet_handle.c   | 17 +++++++------
 skynet-src/skynet_main.c     |  1 -
 skynet-src/skynet_module.c   |  3 +--
 skynet-src/skynet_monitor.c  |  5 ++--
 skynet-src/skynet_mq.c       | 20 ++++++++--------
 skynet-src/skynet_server.c   | 23 +++++++++---------
 skynet-src/skynet_socket.c   |  7 +++---
 skynet-src/skynet_start.c    |  8 +++----
 skynet-src/skynet_timer.c    |  7 +++---
 skynet-src/socket_server.c   |  5 ++--
 19 files changed, 98 insertions(+), 107 deletions(-)

diff --git a/service-src/databuffer.h b/service-src/databuffer.h
index ec2ca53f..1563466c 100644
--- a/service-src/databuffer.h
+++ b/service-src/databuffer.h
@@ -39,7 +39,7 @@ messagepool_free(struct messagepool *pool) {
 	while(p) {
 		struct messagepool_list *tmp = p;
 		p=p->next;
-		free(tmp);
+		skynet_free(tmp);
 	}
 	pool->pool = NULL;
 	pool->freelist = NULL;
@@ -54,7 +54,7 @@ _return_message(struct databuffer *db, struct messagepool *mp) {
 	} else {
 		db->head = m->next;
 	}
-	free(m->buffer);
+	skynet_free(m->buffer);
 	m->buffer = NULL;
 	m->size = 0;
 	m->next = mp->freelist;
@@ -95,7 +95,7 @@ databuffer_push(struct databuffer *db, struct messagepool *mp, void *data, int s
 		m = mp->freelist;
 		mp->freelist = m->next;
 	} else {
-		struct messagepool_list * mpl = malloc(sizeof(*mpl));
+		struct messagepool_list * mpl = skynet_malloc(sizeof(*mpl));
 		struct message * temp = mpl->pool;
 		int i;
 		for (i=1;i<MESSAGEPOOL;i++) {
diff --git a/service-src/hashid.h b/service-src/hashid.h
index 501addcd..10d6be84 100644
--- a/service-src/hashid.h
+++ b/service-src/hashid.h
@@ -29,19 +29,19 @@ hashid_init(struct hashid *hi, int max) {
 	hi->hashmod = hashcap - 1;
 	hi->cap = max;
 	hi->count = 0;
-	hi->id = malloc(max * sizeof(struct hashid_node));
+	hi->id = skynet_malloc(max * sizeof(struct hashid_node));
 	for (i=0;i<max;i++) {
 		hi->id[i].id = -1;
 		hi->id[i].next = NULL;
 	}
-	hi->hash = malloc(hashcap * sizeof(struct hashid_node *));
+	hi->hash = skynet_malloc(hashcap * sizeof(struct hashid_node *));
 	memset(hi->hash, 0, hashcap * sizeof(struct hashid_node *));
 }
 
 static void
 hashid_clear(struct hashid *hi) {
-	free(hi->id);
-	free(hi->hash);
+	skynet_free(hi->id);
+	skynet_free(hi->hash);
 	hi->id = NULL;
 	hi->hash = NULL;
 	hi->hashmod = 1;
diff --git a/service-src/service_gate.c b/service-src/service_gate.c
index fc1553c4..84d11c4d 100644
--- a/service-src/service_gate.c
+++ b/service-src/service_gate.c
@@ -36,7 +36,7 @@ struct gate {
 
 struct gate *
 gate_create(void) {
-	struct gate * g = malloc(sizeof(*g));
+	struct gate * g = skynet_malloc(sizeof(*g));
 	memset(g,0,sizeof(*g));
 	g->listen_id = -1;
 	return g;
@@ -57,8 +57,8 @@ gate_release(struct gate *g) {
 	}
 	messagepool_free(&g->mp);
 	hashid_clear(&g->hash);
-	free(g->conn);
-	free(g);
+	skynet_free(g->conn);
+	skynet_free(g);
 }
 
 static void
@@ -164,17 +164,17 @@ static void
 _forward(struct gate *g, struct connection * c, int size) {
 	struct skynet_context * ctx = g->ctx;
 	if (g->broker) {
-		void * temp = malloc(size);
+		void * temp = skynet_malloc(size);
 		databuffer_read(&c->buffer,&g->mp,temp, size);
 		skynet_send(ctx, 0, g->broker, g->client_tag | PTYPE_TAG_DONTCOPY, 0, temp, size);
 		return;
 	}
 	if (c->agent) {
-		void * temp = malloc(size);
+		void * temp = skynet_malloc(size);
 		databuffer_read(&c->buffer,&g->mp,temp, size);
 		skynet_send(ctx, c->client, c->agent, g->client_tag | PTYPE_TAG_DONTCOPY, 0 , temp, size);
 	} else if (g->watchdog) {
-		char * tmp = malloc(size + 32);
+		char * tmp = skynet_malloc(size + 32);
 		int n = snprintf(tmp,32,"%d data ",c->id);
 		databuffer_read(&c->buffer,&g->mp,tmp+n,size);
 		skynet_send(ctx, 0, g->watchdog, PTYPE_TEXT | PTYPE_TAG_DONTCOPY, 0, tmp, size + n);
@@ -215,7 +215,7 @@ dispatch_socket_message(struct gate *g, const struct skynet_socket_message * mes
 		} else {
 			skynet_error(ctx, "Drop unknown connection %d message", message->id);
 			skynet_socket_close(ctx, message->id);
-			free(message->buffer);
+			skynet_free(message->buffer);
 		}
 		break;
 	}
@@ -369,7 +369,7 @@ gate_init(struct gate *g , struct skynet_context * ctx, char * parm) {
 	g->ctx = ctx;
 
 	hashid_init(&g->hash, max);
-	g->conn = malloc(max * sizeof(struct connection));
+	g->conn = skynet_malloc(max * sizeof(struct connection));
 	memset(g->conn, 0, max *sizeof(struct connection));
 	g->max_connection = max;
 	int i;
diff --git a/service-src/service_harbor.c b/service-src/service_harbor.c
index 1e2d2496..4c5fe48b 100644
--- a/service-src/service_harbor.c
+++ b/service-src/service_harbor.c
@@ -66,12 +66,12 @@ _push_queue(struct msg_queue * queue, const void * buffer, size_t sz, struct rem
 	// If there is only 1 free slot which is reserved to distinguish full/empty
 	// of circular buffer, expand it.
 	if (((queue->tail + 1) % queue->size) == queue->head) {
-		struct msg * new_buffer = malloc(queue->size * 2 * sizeof(struct msg));
+		struct msg * new_buffer = skynet_malloc(queue->size * 2 * sizeof(struct msg));
 		int i;
 		for (i=0;i<queue->size-1;i++) {
 			new_buffer[i] = queue->data[(i+queue->head) % queue->size];
 		}
-		free(queue->data);
+		skynet_free(queue->data);
 		queue->data = new_buffer;
 		queue->head = 0;
 		queue->tail = queue->size - 1;
@@ -80,7 +80,7 @@ _push_queue(struct msg_queue * queue, const void * buffer, size_t sz, struct rem
 	struct msg * slot = &queue->data[queue->tail];
 	queue->tail = (queue->tail + 1) % queue->size;
 
-	slot->buffer = malloc(sz + sizeof(*header));
+	slot->buffer = skynet_malloc(sz + sizeof(*header));
 	memcpy(slot->buffer, buffer, sz);
 	memcpy(slot->buffer + sz, header, sizeof(*header));
 	slot->size = sz + sizeof(*header);
@@ -98,11 +98,11 @@ _pop_queue(struct msg_queue * queue) {
 
 static struct msg_queue *
 _new_queue() {
-	struct msg_queue * queue = malloc(sizeof(*queue));
+	struct msg_queue * queue = skynet_malloc(sizeof(*queue));
 	queue->size = DEFAULT_QUEUE_SIZE;
 	queue->head = 0;
 	queue->tail = 0;
-	queue->data = malloc(DEFAULT_QUEUE_SIZE * sizeof(struct msg));
+	queue->data = skynet_malloc(DEFAULT_QUEUE_SIZE * sizeof(struct msg));
 
 	return queue;
 }
@@ -113,11 +113,11 @@ _release_queue(struct msg_queue *queue) {
 		return;
 	struct msg * m = _pop_queue(queue);
 	while (m) {
-		free(m->buffer);
+		skynet_free(m->buffer);
 		m = _pop_queue(queue);
 	}
-	free(queue->data);
-	free(queue);
+	skynet_free(queue->data);
+	skynet_free(queue);
 }
 
 static struct keyvalue *
@@ -148,7 +148,7 @@ _hash_erase(struct hashmap * hash, char name[GLOBALNAME_LENGTH) {
 		if (node->hash == h && strncmp(node->key, name, GLOBALNAME_LENGTH) == 0) {
 			_release_queue(node->queue);
 			*ptr->next = node->next;
-			free(node);
+			skynet_free(node);
 			return;
 		}
 		*ptr = &(node->next);
@@ -161,7 +161,7 @@ _hash_insert(struct hashmap * hash, const char name[GLOBALNAME_LENGTH]) {
 	uint32_t *ptr = (uint32_t *)name;
 	uint32_t h = ptr[0] ^ ptr[1] ^ ptr[2] ^ ptr[3];
 	struct keyvalue ** pkv = &hash->node[h % HASH_SIZE];
-	struct keyvalue * node = malloc(sizeof(*node));
+	struct keyvalue * node = skynet_malloc(sizeof(*node));
 	memcpy(node->key, name, GLOBALNAME_LENGTH);
 	node->next = *pkv;
 	node->queue = NULL;
@@ -174,7 +174,7 @@ _hash_insert(struct hashmap * hash, const char name[GLOBALNAME_LENGTH]) {
 
 static struct hashmap * 
 _hash_new() {
-	struct hashmap * h = malloc(sizeof(struct hashmap));
+	struct hashmap * h = skynet_malloc(sizeof(struct hashmap));
 	memset(h,0,sizeof(*h));
 	return h;
 }
@@ -187,18 +187,18 @@ _hash_delete(struct hashmap *hash) {
 		while (node) {
 			struct keyvalue * next = node->next;
 			_release_queue(node->queue);
-			free(node);
+			skynet_free(node);
 			node = next;
 		}
 	}
-	free(hash);
+	skynet_free(hash);
 }
 
 ///////////////
 
 struct harbor *
 harbor_create(void) {
-	struct harbor * h = malloc(sizeof(*h));
+	struct harbor * h = skynet_malloc(sizeof(*h));
 	h->ctx = NULL;
 	h->id = 0;
 	h->master_fd = -1;
@@ -219,17 +219,17 @@ harbor_release(struct harbor *h) {
 	if (h->master_fd >= 0) {
 		skynet_socket_close(ctx, h->master_fd);
 	}
-	free(h->master_addr);
-	free(h->local_addr);
+	skynet_free(h->master_addr);
+	skynet_free(h->local_addr);
 	int i;
 	for (i=0;i<REMOTE_MAX;i++) {
 		if (h->remote_fd[i] >= 0) {
 			skynet_socket_close(ctx, h->remote_fd[i]);
-			free(h->remote_addr[i]);
+			skynet_free(h->remote_addr[i]);
 		}
 	}
 	_hash_delete(h->map);
-	free(h);
+	skynet_free(h);
 }
 
 static int
@@ -288,7 +288,7 @@ _message_to_header(const uint32_t *message, struct remote_message_header *header
 
 static void
 _send_package(struct skynet_context *ctx, int fd, const void * buffer, size_t sz) {
-	uint8_t * sendbuf = malloc(sz+4);
+	uint8_t * sendbuf = skynet_malloc(sz+4);
 	to_bigendian(sendbuf, sz);
 	memcpy(sendbuf+4, buffer, sz);
 
@@ -300,7 +300,7 @@ _send_package(struct skynet_context *ctx, int fd, const void * buffer, size_t sz
 static void
 _send_remote(struct skynet_context * ctx, int fd, const char * buffer, size_t sz, struct remote_message_header * cookie) {
 	uint32_t sz_header = sz+sizeof(*cookie);
-	uint8_t * sendbuf = malloc(sz_header+4);
+	uint8_t * sendbuf = skynet_malloc(sz_header+4);
 	to_bigendian(sendbuf, sz_header);
 	memcpy(sendbuf+4, buffer, sz);
 	_header_to_message(cookie, sendbuf+4+sz);
@@ -319,7 +319,7 @@ _update_remote_address(struct harbor *h, int harbor_id, const char * ipaddr) {
 	struct skynet_context * context = h->ctx;
 	if (h->remote_fd[harbor_id] >=0) {
 		skynet_socket_close(context, h->remote_fd[harbor_id]);
-		free(h->remote_addr[harbor_id]);
+		skynet_free(h->remote_addr[harbor_id]);
 		h->remote_addr[harbor_id] = NULL;
 	}
 	h->remote_fd[harbor_id] = _connect_to(h, ipaddr, false);
@@ -484,7 +484,7 @@ _mainloop(struct skynet_context * context, void * ud, int type, int session, uin
 		const struct skynet_socket_message * message = msg;
 		switch(message->type) {
 		case SKYNET_SOCKET_TYPE_DATA:
-			free(message->buffer);
+			skynet_free(message->buffer);
 			skynet_error(context, "recv invalid socket message (size=%d)", message->ud);
 			break;
 		case SKYNET_SOCKET_TYPE_ACCEPT:
@@ -552,7 +552,7 @@ _mainloop(struct skynet_context * context, void * ud, int type, int session, uin
 				return 0;
 			}
 		}
-		free((void *)rmsg->message);
+		skynet_free((void *)rmsg->message);
 		return 0;
 	}
 	}
diff --git a/service-src/service_logger.c b/service-src/service_logger.c
index 9ec7c5d9..c78cf4d6 100644
--- a/service-src/service_logger.c
+++ b/service-src/service_logger.c
@@ -11,7 +11,7 @@ struct logger {
 
 struct logger *
 logger_create(void) {
-	struct logger * inst = malloc(sizeof(*inst));
+	struct logger * inst = skynet_malloc(sizeof(*inst));
 	inst->handle = NULL;
 	inst->close = 0;
 	return inst;
@@ -22,7 +22,7 @@ logger_release(struct logger * inst) {
 	if (inst->close) {
 		fclose(inst->handle);
 	}
-	free(inst);
+	skynet_free(inst);
 }
 
 static int
diff --git a/service-src/service_master.c b/service-src/service_master.c
index 0ef3255d..b5d8a560 100644
--- a/service-src/service_master.c
+++ b/service-src/service_master.c
@@ -32,7 +32,7 @@ struct master {
 
 struct master *
 master_create() {
-	struct master *m = malloc(sizeof(*m));
+	struct master *m = skynet_malloc(sizeof(*m));
 	int i;
 	for (i=0;i<REMOTE_MAX;i++) {
 		m->remote_fd[i] = -1;
@@ -53,17 +53,17 @@ master_release(struct master * m) {
 			assert(ctx);
 			skynet_socket_close(ctx, fd);
 		}
-		free(m->remote_addr[i]);
+		skynet_free(m->remote_addr[i]);
 	}
 	for (i=0;i<HASH_SIZE;i++) {
 		struct name * node = m->map.node[i];
 		while (node) {
 			struct name * next = node->next;
-			free(node);
+			skynet_free(node);
 			node = next;
 		}
 	}
-	free(m);
+	skynet_free(m);
 }
 
 static struct name *
@@ -85,7 +85,7 @@ _insert_name(struct master *m, char name[GLOBALNAME_LENGTH]) {
 	uint32_t *ptr = (uint32_t *)name;
 	uint32_t h = ptr[0] ^ ptr[1] ^ ptr[2] ^ ptr[3];
 	struct name **pname = &m->map.node[h % HASH_SIZE];
-	struct name * node = malloc(sizeof(*node));
+	struct name * node = skynet_malloc(sizeof(*node));
 	memcpy(node->key, name, GLOBALNAME_LENGTH);
 	node->next = *pname;
 	node->hash = h;
@@ -133,7 +133,7 @@ to_bigendian(uint8_t *buffer, uint32_t n) {
 
 static void
 _send_to(struct master *m, int id, const void * buf, int sz, uint32_t handle) {
-	uint8_t * buffer= (uint8_t *)malloc(4 + sz + 12);
+	uint8_t * buffer= (uint8_t *)skynet_malloc(4 + sz + 12);
 	to_bigendian(buffer, sz+12);
 	memcpy(buffer+4, buf, sz);
 	to_bigendian(buffer+4+sz, 0);
@@ -196,8 +196,8 @@ _update_address(struct master *m, int harbor_id, const char * buffer, size_t sz)
 	if (m->remote_fd[harbor_id] >= 0) {
 		close_harbor(m, harbor_id);
 	}
-	free(m->remote_addr[harbor_id]);
-	char * addr = malloc(sz+1);
+	skynet_free(m->remote_addr[harbor_id]);
+	char * addr = skynet_malloc(sz+1);
 	memcpy(addr, buffer, sz);
 	addr[sz] = '\0';
 	m->remote_addr[harbor_id] = addr;
diff --git a/service-src/service_snlua.c b/service-src/service_snlua.c
index 86437a89..c162a528 100644
--- a/service-src/service_snlua.c
+++ b/service-src/service_snlua.c
@@ -253,7 +253,7 @@ _launch(struct skynet_context * context, void *ud, int type, int session, uint32
 int
 snlua_init(struct snlua *l, struct skynet_context *ctx, const char * args) {
 	int sz = strlen(args);
-	char * tmp = malloc(sz+1);
+	char * tmp = skynet_malloc(sz+1);
 	memcpy(tmp, args, sz+1);
 	skynet_callback(ctx, l , _launch);
 	const char * self = skynet_command(ctx, "REG", NULL);
@@ -265,7 +265,7 @@ snlua_init(struct snlua *l, struct skynet_context *ctx, const char * args) {
 
 struct snlua *
 snlua_create(void) {
-	struct snlua * l = malloc(sizeof(*l));
+	struct snlua * l = skynet_malloc(sizeof(*l));
 	memset(l,0,sizeof(*l));
 	l->L = lua_newstate(skynet_lalloc, NULL);
 	l->init = _init;
@@ -275,5 +275,5 @@ snlua_create(void) {
 void
 snlua_release(struct snlua *l) {
 	lua_close(l->L);
-	free(l);
+	skynet_free(l);
 }
diff --git a/skynet-src/skynet_env.c b/skynet-src/skynet_env.c
index c2778d3b..9dbbcf9c 100644
--- a/skynet-src/skynet_env.c
+++ b/skynet-src/skynet_env.c
@@ -1,4 +1,3 @@
-// include skynet.h first for malloc hook
 #include "skynet.h"
 #include "skynet_env.h"
 
@@ -49,7 +48,7 @@ skynet_setenv(const char *key, const char *value) {
 
 void
 skynet_env_init() {
-	E = malloc(sizeof(*E));
+	E = skynet_malloc(sizeof(*E));
 	E->lock = 0;
 	E->L = luaL_newstate();
 }
diff --git a/skynet-src/skynet_error.c b/skynet-src/skynet_error.c
index a3c7b807..b9c53efd 100644
--- a/skynet-src/skynet_error.c
+++ b/skynet-src/skynet_error.c
@@ -34,14 +34,14 @@ skynet_error(struct skynet_context * context, const char *msg, ...) {
 		int max_size = LOG_MESSAGE_SIZE;
 		for (;;) {
 			max_size *= 2;
-			data = malloc(max_size);
+			data = skynet_malloc(max_size);
 			va_start(ap,msg);
 			len = vsnprintf(data, max_size, msg, ap);
 			va_end(ap);
 			if (len < max_size) {
 				break;
 			}
-			free(data);
+			skynet_free(data);
 		}
 	}
 
diff --git a/skynet-src/skynet_handle.c b/skynet-src/skynet_handle.c
index baa6d200..dea99e4f 100644
--- a/skynet-src/skynet_handle.c
+++ b/skynet-src/skynet_handle.c
@@ -1,4 +1,3 @@
-// include skynet.h first for malloc hook
 #include "skynet.h"
 
 #include "skynet_handle.h"
@@ -54,14 +53,14 @@ skynet_handle_register(struct skynet_context *ctx) {
 			}
 		}
 		assert((s->slot_size*2 - 1) <= HANDLE_MASK);
-		struct skynet_context ** new_slot = malloc(s->slot_size * 2 * sizeof(struct skynet_context *));
+		struct skynet_context ** new_slot = skynet_malloc(s->slot_size * 2 * sizeof(struct skynet_context *));
 		memset(new_slot, 0, s->slot_size * 2 * sizeof(struct skynet_context *));
 		for (i=0;i<s->slot_size;i++) {
 			int hash = skynet_context_handle(s->slot[i]) & (s->slot_size * 2 - 1);
 			assert(new_slot[hash] == NULL);
 			new_slot[hash] = s->slot[i];
 		}
-		free(s->slot);
+		skynet_free(s->slot);
 		s->slot = new_slot;
 		s->slot_size *= 2;
 	}
@@ -83,7 +82,7 @@ skynet_handle_retire(uint32_t handle) {
 		int j=0, n=s->name_count;
 		for (i=0; i<n; ++i) {
 			if (s->name[i].handle == handle) {
-				free(s->name[i].name);
+				skynet_free(s->name[i].name);
 				continue;
 			} else if (i!=j) {
 				s->name[j] = s->name[i];
@@ -169,7 +168,7 @@ static void
 _insert_name_before(struct handle_storage *s, char *name, uint32_t handle, int before) {
 	if (s->name_count >= s->name_cap) {
 		s->name_cap *= 2;
-		struct handle_name * n = malloc(s->name_cap * sizeof(struct handle_name));
+		struct handle_name * n = skynet_malloc(s->name_cap * sizeof(struct handle_name));
 		int i;
 		for (i=0;i<before;i++) {
 			n[i] = s->name[i];
@@ -177,7 +176,7 @@ _insert_name_before(struct handle_storage *s, char *name, uint32_t handle, int b
 		for (i=before;i<s->name_count;i++) {
 			n[i+1] = s->name[i];
 		}
-		free(s->name);
+		skynet_free(s->name);
 		s->name = n;
 	} else {
 		int i;
@@ -228,9 +227,9 @@ skynet_handle_namehandle(uint32_t handle, const char *name) {
 void 
 skynet_handle_init(int harbor) {
 	assert(H==NULL);
-	struct handle_storage * s = malloc(sizeof(*H));
+	struct handle_storage * s = skynet_malloc(sizeof(*H));
 	s->slot_size = DEFAULT_SLOT_SIZE;
-	s->slot = malloc(s->slot_size * sizeof(struct skynet_context *));
+	s->slot = skynet_malloc(s->slot_size * sizeof(struct skynet_context *));
 	memset(s->slot, 0, s->slot_size * sizeof(struct skynet_context *));
 
 	rwlock_init(&s->lock);
@@ -239,7 +238,7 @@ skynet_handle_init(int harbor) {
 	s->handle_index = 1;
 	s->name_cap = 2;
 	s->name_count = 0;
-	s->name = malloc(s->name_cap * sizeof(struct handle_name));
+	s->name = skynet_malloc(s->name_cap * sizeof(struct handle_name));
 
 	H = s;
 
diff --git a/skynet-src/skynet_main.c b/skynet-src/skynet_main.c
index 11ff87b2..ec60e2a1 100644
--- a/skynet-src/skynet_main.c
+++ b/skynet-src/skynet_main.c
@@ -1,4 +1,3 @@
-// include skynet.h first for malloc hook
 #include "skynet.h"
 
 #include "skynet_imp.h"
diff --git a/skynet-src/skynet_module.c b/skynet-src/skynet_module.c
index a39288a9..66dd4629 100644
--- a/skynet-src/skynet_module.c
+++ b/skynet-src/skynet_module.c
@@ -1,4 +1,3 @@
-// include skynet.h first for malloc hook
 #include "skynet.h"
 
 #include "skynet_module.h"
@@ -153,7 +152,7 @@ skynet_module_instance_release(struct skynet_module *m, void *inst) {
 
 void 
 skynet_module_init(const char *path) {
-	struct modules *m = malloc(sizeof(*m));
+	struct modules *m = skynet_malloc(sizeof(*m));
 	m->count = 0;
 	m->path = skynet_strdup(path);
 	m->lock = 0;
diff --git a/skynet-src/skynet_monitor.c b/skynet-src/skynet_monitor.c
index e0cf9b49..9ee302e5 100644
--- a/skynet-src/skynet_monitor.c
+++ b/skynet-src/skynet_monitor.c
@@ -1,4 +1,3 @@
-// include skynet.h first for malloc hook
 #include "skynet.h"
 
 #include "skynet_monitor.h"
@@ -17,14 +16,14 @@ struct skynet_monitor {
 
 struct skynet_monitor * 
 skynet_monitor_new() {
-	struct skynet_monitor * ret = malloc(sizeof(*ret));
+	struct skynet_monitor * ret = skynet_malloc(sizeof(*ret));
 	memset(ret, 0, sizeof(*ret));
 	return ret;
 }
 
 void 
 skynet_monitor_delete(struct skynet_monitor *sm) {
-	free(sm);
+	skynet_free(sm);
 }
 
 void 
diff --git a/skynet-src/skynet_mq.c b/skynet-src/skynet_mq.c
index a8e13db5..f0e48440 100644
--- a/skynet-src/skynet_mq.c
+++ b/skynet-src/skynet_mq.c
@@ -83,7 +83,7 @@ skynet_globalmq_pop() {
 
 struct message_queue * 
 skynet_mq_create(uint32_t handle) {
-	struct message_queue *q = malloc(sizeof(*q));
+	struct message_queue *q = skynet_malloc(sizeof(*q));
 	q->handle = handle;
 	q->cap = DEFAULT_QUEUE_SIZE;
 	q->head = 0;
@@ -92,15 +92,15 @@ skynet_mq_create(uint32_t handle) {
 	q->in_global = MQ_IN_GLOBAL;
 	q->release = 0;
 	q->lock_session = 0;
-	q->queue = malloc(sizeof(struct skynet_message) * q->cap);
+	q->queue = skynet_malloc(sizeof(struct skynet_message) * q->cap);
 
 	return q;
 }
 
 static void 
 _release(struct message_queue *q) {
-	free(q->queue);
-	free(q);
+	skynet_free(q->queue);
+	skynet_free(q);
 }
 
 uint32_t 
@@ -148,7 +148,7 @@ skynet_mq_pop(struct message_queue *q, struct skynet_message *message) {
 
 static void
 expand_queue(struct message_queue *q) {
-	struct skynet_message *new_queue = malloc(sizeof(struct skynet_message) * q->cap * 2);
+	struct skynet_message *new_queue = skynet_malloc(sizeof(struct skynet_message) * q->cap * 2);
 	int i;
 	for (i=0;i<q->cap;i++) {
 		new_queue[i] = q->queue[(q->head + i) % q->cap];
@@ -157,7 +157,7 @@ expand_queue(struct message_queue *q) {
 	q->tail = q->cap;
 	q->cap *= 2;
 	
-	free(q->queue);
+	skynet_free(q->queue);
 	q->queue = new_queue;
 }
 
@@ -239,10 +239,10 @@ skynet_mq_unlock(struct message_queue *q) {
 
 void 
 skynet_mq_init() {
-	struct global_queue *q = malloc(sizeof(*q));
+	struct global_queue *q = skynet_malloc(sizeof(*q));
 	memset(q,0,sizeof(*q));
-	q->queue = malloc(MAX_GLOBAL_MQ * sizeof(struct message_queue *));
-	q->flag = malloc(MAX_GLOBAL_MQ * sizeof(bool));
+	q->queue = skynet_malloc(MAX_GLOBAL_MQ * sizeof(struct message_queue *));
+	q->flag = skynet_malloc(MAX_GLOBAL_MQ * sizeof(bool));
 	memset(q->flag, 0, sizeof(bool) * MAX_GLOBAL_MQ);
 	Q=q;
 }
@@ -286,7 +286,7 @@ _drop_queue(struct message_queue *q) {
 	int s = 0;
 	while(!skynet_mq_pop(q, &msg)) {
 		++s;
-		free(msg.data);
+		skynet_free(msg.data);
 	}
 	_release(q);
 	return s;
diff --git a/skynet-src/skynet_server.c b/skynet-src/skynet_server.c
index 16cbe3ec..4c879cb2 100644
--- a/skynet-src/skynet_server.c
+++ b/skynet-src/skynet_server.c
@@ -1,4 +1,3 @@
-// include skynet.h first for malloc hook
 #include "skynet.h"
 
 #include "skynet_server.h"
@@ -97,7 +96,7 @@ skynet_context_new(const char * name, const char *param) {
 	void *inst = skynet_module_instance_create(mod);
 	if (inst == NULL)
 		return NULL;
-	struct skynet_context * ctx = malloc(sizeof(*ctx));
+	struct skynet_context * ctx = skynet_malloc(sizeof(*ctx));
 	CHECKCALLING_INIT(ctx)
 
 	ctx->mod = mod;
@@ -152,7 +151,7 @@ static void
 _delete_context(struct skynet_context *ctx) {
 	skynet_module_instance_release(ctx->mod, ctx->instance);
 	skynet_mq_mark_release(ctx->queue);
-	free(ctx);
+	skynet_free(ctx);
 	_context_dec();
 }
 
@@ -204,7 +203,7 @@ _dispatch_message(struct skynet_context *ctx, struct skynet_message *msg) {
 	int type = msg->sz >> HANDLE_REMOTE_SHIFT;
 	size_t sz = msg->sz & HANDLE_MASK;
 	if (!ctx->cb(ctx, ctx->cb_ud, type, msg->session, msg->source, msg->data, sz)) {
-		free(msg->data);
+		skynet_free(msg->data);
 	}
 	handle_tls = 0xffffffff;
 	CHECKCALLING_END(ctx)
@@ -236,7 +235,7 @@ skynet_context_message_dispatch(struct skynet_monitor *sm) {
 	skynet_monitor_trigger(sm, msg.source , handle);
 
 	if (ctx->cb == NULL) {
-		free(msg.data);
+		skynet_free(msg.data);
 		skynet_error(NULL, "Drop message from %x to %x without callback , size = %d",msg.source, handle, (int)msg.sz);
 	} else {
 		_dispatch_message(ctx, &msg);
@@ -323,7 +322,7 @@ skynet_command(struct skynet_context * context, const char * cmd , const char *
 			return skynet_handle_namehandle(context->handle, param + 1);
 		} else {
 			assert(context->handle!=0);
-			struct remote_name *rname = malloc(sizeof(*rname));
+			struct remote_name *rname = skynet_malloc(sizeof(*rname));
 			_copy_name(rname->name, param);
 			rname->handle = context->handle;
 			skynet_harbor_register(rname);
@@ -355,7 +354,7 @@ skynet_command(struct skynet_context * context, const char * cmd , const char *
 		if (name[0] == '.') {
 			return skynet_handle_namehandle(handle_id, name + 1);
 		} else {
-			struct remote_name *rname = malloc(sizeof(*rname));
+			struct remote_name *rname = skynet_malloc(sizeof(*rname));
 			_copy_name(rname->name, name);
 			rname->handle = handle_id;
 			skynet_harbor_register(rname);
@@ -491,7 +490,7 @@ _filter_args(struct skynet_context * context, int type, int *session, void ** da
 	}
 
 	if (needcopy && *data) {
-		char * msg = malloc(*sz+1);
+		char * msg = skynet_malloc(*sz+1);
 		memcpy(msg, *data, *sz);
 		msg[*sz] = '\0';
 		*data = msg;
@@ -513,7 +512,7 @@ skynet_send(struct skynet_context * context, uint32_t source, uint32_t destinati
 		return session;
 	}
 	if (skynet_harbor_message_isremote(destination)) {
-		struct remote_message * rmsg = malloc(sizeof(*rmsg));
+		struct remote_message * rmsg = skynet_malloc(sizeof(*rmsg));
 		rmsg->destination.handle = destination;
 		rmsg->message = data;
 		rmsg->sz = sz;
@@ -526,7 +525,7 @@ skynet_send(struct skynet_context * context, uint32_t source, uint32_t destinati
 		smsg.sz = sz;
 
 		if (skynet_context_push(destination, &smsg)) {
-			free(data);
+			skynet_free(data);
 			skynet_error(NULL, "Drop message from %x to %x (type=%d)(size=%d)", source, destination, type&0xff, (int)(sz & HANDLE_MASK));
 			return -1;
 		}
@@ -544,7 +543,7 @@ skynet_sendname(struct skynet_context * context, const char * addr , int type, i
 		des = skynet_handle_findname(addr + 1);
 		if (des == 0) {
 			if (type & PTYPE_TAG_DONTCOPY) {
-  			free(data);
+  			skynet_free(data);
   		}
 			skynet_error(context, "Drop message to %s", addr);
 			return session;
@@ -552,7 +551,7 @@ skynet_sendname(struct skynet_context * context, const char * addr , int type, i
 	} else {
 		_filter_args(context, type, &session, (void **)&data, &sz);
 
-		struct remote_message * rmsg = malloc(sizeof(*rmsg));
+		struct remote_message * rmsg = skynet_malloc(sizeof(*rmsg));
 		_copy_name(rmsg->destination.name, addr);
 		rmsg->destination.handle = 0;
 		rmsg->message = data;
diff --git a/skynet-src/skynet_socket.c b/skynet-src/skynet_socket.c
index 49e31ed6..3654d591 100644
--- a/skynet-src/skynet_socket.c
+++ b/skynet-src/skynet_socket.c
@@ -1,4 +1,3 @@
-// include skynet.h first for malloc hook
 #include "skynet.h"
 
 #include "skynet_socket.h"
@@ -43,7 +42,7 @@ forward_message(int type, bool padding, struct socket_message * result) {
 			sz += 1;
 		}
 	}
-	sm = (struct skynet_socket_message *)malloc(sz);
+	sm = (struct skynet_socket_message *)skynet_malloc(sz);
 	sm->type = type;
 	sm->id = result->id;
 	sm->ud = result->ud;
@@ -63,7 +62,7 @@ forward_message(int type, bool padding, struct socket_message * result) {
 	if (skynet_context_push((uint32_t)result->opaque, &message)) {
 		// todo: report somewhere to close socket
 		// don't call skynet_socket_close here (It will block mainloop)
-		free(sm);
+		skynet_free(sm);
 	}
 }
 
@@ -106,7 +105,7 @@ int
 skynet_socket_send(struct skynet_context *ctx, int id, void *buffer, int sz) {
 	int64_t wsz = socket_server_send(SOCKET_SERVER, id, buffer, sz);
 	if (wsz < 0) {
-		free(buffer);
+		skynet_free(buffer);
 		return -1;
 	} else if (wsz > 1024 * 1024) {
 		int kb4 = wsz / 1024 / 4;
diff --git a/skynet-src/skynet_start.c b/skynet-src/skynet_start.c
index 4a4eb949..bdb8c811 100644
--- a/skynet-src/skynet_start.c
+++ b/skynet-src/skynet_start.c
@@ -72,8 +72,8 @@ free_monitor(struct monitor *m) {
 	}
 	pthread_mutex_destroy(&m->mutex);
 	pthread_cond_destroy(&m->cond);
-	free(m->m);
-	free(m);
+	skynet_free(m->m);
+	skynet_free(m);
 }
 
 static void *
@@ -140,12 +140,12 @@ static void
 _start(int thread) {
 	pthread_t pid[thread+3];
 
-	struct monitor *m = malloc(sizeof(*m));
+	struct monitor *m = skynet_malloc(sizeof(*m));
 	memset(m, 0, sizeof(*m));
 	m->count = thread;
 	m->sleep = 0;
 
-	m->m = malloc(thread * sizeof(struct skynet_monitor *));
+	m->m = skynet_malloc(thread * sizeof(struct skynet_monitor *));
 	int i;
 	for (i=0;i<thread;i++) {
 		m->m[i] = skynet_monitor_new();
diff --git a/skynet-src/skynet_timer.c b/skynet-src/skynet_timer.c
index ab9d3829..489f8d09 100644
--- a/skynet-src/skynet_timer.c
+++ b/skynet-src/skynet_timer.c
@@ -1,4 +1,3 @@
-// include skynet.h first for malloc hook
 #include "skynet.h"
 
 #include "skynet_timer.h"
@@ -93,7 +92,7 @@ add_node(struct timer *T,struct timer_node *node)
 static void
 timer_add(struct timer *T,void *arg,size_t sz,int time)
 {
-	struct timer_node *node = (struct timer_node *)malloc(sizeof(*node)+sz);
+	struct timer_node *node = (struct timer_node *)skynet_malloc(sizeof(*node)+sz);
 	memcpy(node+1,arg,sz);
 
 	while (__sync_lock_test_and_set(&T->lock,1)) {};
@@ -147,7 +146,7 @@ timer_execute(struct timer *T) {
 			
 			struct timer_node * temp = current;
 			current=current->next;
-			free(temp);	
+			skynet_free(temp);	
 		} while (current);
 	}
 }
@@ -170,7 +169,7 @@ timer_update(struct timer *T)
 static struct timer *
 timer_create_timer()
 {
-	struct timer *r=(struct timer *)malloc(sizeof(struct timer));
+	struct timer *r=(struct timer *)skynet_malloc(sizeof(struct timer));
 	memset(r,0,sizeof(*r));
 
 	int i,j;
diff --git a/skynet-src/socket_server.c b/skynet-src/socket_server.c
index f898a4a3..b3ea5e0a 100644
--- a/skynet-src/socket_server.c
+++ b/skynet-src/socket_server.c
@@ -1,4 +1,3 @@
-// include skynet.h first for malloc hook
 #include "skynet.h"
 
 #include "socket_server.h"
@@ -128,8 +127,8 @@ union sockaddr_all {
 	struct sockaddr_in6 v6;
 };
 
-#define MALLOC malloc
-#define FREE free
+#define MALLOC skynet_malloc
+#define FREE skynet_free
 
 static void
 socket_keepalive(int fd) {

From 61c8c765f459bb66d302684605b8ea63ada401bf Mon Sep 17 00:00:00 2001
From: Cloud Wu <cloudwu@gmail.com>
Date: Tue, 22 Apr 2014 15:17:16 +0800
Subject: [PATCH 2/3] use skynet_malloc api

---
 lualib-src/lua-bson.c      |  9 ++++-----
 lualib-src/lua-memory.c    |  3 ---
 lualib-src/lua-mongo.c     |  9 ++++-----
 lualib-src/lua-netpack.c   | 29 ++++++++++++++---------------
 lualib-src/lua-seri.c      | 17 ++++++++---------
 lualib-src/lua-socket.c    | 13 ++++++-------
 skynet-src/skynet_malloc.h |  4 ++++
 7 files changed, 40 insertions(+), 44 deletions(-)

diff --git a/lualib-src/lua-bson.c b/lualib-src/lua-bson.c
index 04907181..e129f62b 100644
--- a/lualib-src/lua-bson.c
+++ b/lualib-src/lua-bson.c
@@ -1,5 +1,4 @@
-// include skynet.h first for malloc hook
-#include "skynet.h"
+#include "skynet_malloc.h"
 
 #include <lua.h>
 #include <lauxlib.h>
@@ -74,7 +73,7 @@ struct bson_reader {
 static inline void
 bson_destroy(struct bson *b) {
 	if (b->ptr != b->buffer) {
-		free(b->ptr);
+		skynet_free(b->ptr);
 	}
 }
 
@@ -94,10 +93,10 @@ bson_reserve(struct bson *b, int sz) {
 	} while (b->cap <= b->size + sz);
 
 	if (b->ptr == b->buffer) {
-		b->ptr = malloc(b->cap);
+		b->ptr = skynet_malloc(b->cap);
 		memcpy(b->ptr, b->buffer, b->size);
 	} else {
-		b->ptr = realloc(b->ptr, b->cap);
+		b->ptr = skynet_realloc(b->ptr, b->cap);
 	}
 }
 
diff --git a/lualib-src/lua-memory.c b/lualib-src/lua-memory.c
index e05d853a..fa7c026c 100644
--- a/lualib-src/lua-memory.c
+++ b/lualib-src/lua-memory.c
@@ -1,6 +1,3 @@
-// include skynet.h first for malloc hook
-#include "skynet.h"
-
 #include <lua.h>
 #include <lauxlib.h>
 
diff --git a/lualib-src/lua-mongo.c b/lualib-src/lua-mongo.c
index 9c956b0a..166e6683 100644
--- a/lualib-src/lua-mongo.c
+++ b/lualib-src/lua-mongo.c
@@ -1,5 +1,4 @@
-// include skynet.h first for malloc hook
-#include "skynet.h"
+#include "skynet_malloc.h"
 
 #include <lua.h>
 #include <lauxlib.h>
@@ -68,7 +67,7 @@ get_length(const document buffer) {
 static inline void
 buffer_destroy(struct buffer *b) {
 	if (b->ptr != b->buffer) {
-		free(b->ptr);
+		skynet_free(b->ptr);
 	}
 }
 
@@ -88,10 +87,10 @@ buffer_reserve(struct buffer *b, int sz) {
 	} while (b->cap <= b->size + sz);
 
 	if (b->ptr == b->buffer) {
-		b->ptr = malloc(b->cap);
+		b->ptr = skynet_malloc(b->cap);
 		memcpy(b->ptr, b->buffer, b->size);
 	} else {
-		b->ptr = realloc(b->ptr, b->cap);
+		b->ptr = skynet_realloc(b->ptr, b->cap);
 	}
 }
 
diff --git a/lualib-src/lua-netpack.c b/lualib-src/lua-netpack.c
index 8f3bbd0a..a95ed4d7 100644
--- a/lualib-src/lua-netpack.c
+++ b/lualib-src/lua-netpack.c
@@ -1,5 +1,4 @@
-// include skynet.h first for malloc hook
-#include "skynet.h"
+#include "skynet_malloc.h"
 
 #include "skynet_socket.h"
 
@@ -51,7 +50,7 @@ clear_list(struct uncomplete * uc) {
 	while (uc) {
 		void * tmp = uc;
 		uc = uc->next;
-		free(tmp);
+		skynet_free(tmp);
 	}
 }
 
@@ -71,7 +70,7 @@ lclear(lua_State *L) {
 	}
 	for (i=q->head;i<q->tail;i++) {
 		struct netpack *np = &q->queue[i % q->cap];
-		free(np->buffer);
+		skynet_free(np->buffer);
 	}
 	q->head = q->tail = 0;
 
@@ -147,7 +146,7 @@ expand_queue(lua_State *L, struct queue *q) {
 static void
 push_data(lua_State *L, int fd, void *buffer, int size, int clone) {
 	if (clone) {
-		void * tmp = malloc(size);
+		void * tmp = skynet_malloc(size);
 		memcpy(tmp, buffer, size);
 		buffer = tmp;
 	}
@@ -167,7 +166,7 @@ static struct uncomplete *
 save_uncomplete(lua_State *L, int fd) {
 	struct queue *q = get_queue(L);
 	int h = hash_fd(fd);
-	struct uncomplete * uc = malloc(sizeof(struct uncomplete));
+	struct uncomplete * uc = skynet_malloc(sizeof(struct uncomplete));
 	memset(uc, 0, sizeof(*uc));
 	uc->next = q->hash[h];
 	uc->pack.id = fd;
@@ -198,7 +197,7 @@ push_more(lua_State *L, int fd, uint8_t *buffer, int size) {
 		struct uncomplete * uc = save_uncomplete(L, fd);
 		uc->read = size;
 		uc->pack.size = pack_size;
-		uc->pack.buffer = malloc(pack_size);
+		uc->pack.buffer = skynet_malloc(pack_size);
 		memcpy(uc->pack.buffer, buffer, size);
 		return;
 	}
@@ -225,7 +224,7 @@ filter_data_(lua_State *L, int fd, uint8_t * buffer, int size) {
 			++buffer;
 			--size;
 			uc->pack.size = pack_size;
-			uc->pack.buffer = malloc(pack_size);
+			uc->pack.buffer = skynet_malloc(pack_size);
 			uc->read = 0;
 		}
 		int need = uc->pack.size - uc->read;
@@ -245,12 +244,12 @@ filter_data_(lua_State *L, int fd, uint8_t * buffer, int size) {
 			lua_pushinteger(L, fd);
 			lua_pushlightuserdata(L, uc->pack.buffer);
 			lua_pushinteger(L, uc->pack.size);
-			free(uc);
+			skynet_free(uc);
 			return 5;
 		}
 		// more data
 		push_data(L, fd, uc->pack.buffer, uc->pack.size, 0);
-		free(uc);
+		skynet_free(uc);
 		push_more(L, fd, buffer, size);
 		lua_pushvalue(L, lua_upvalueindex(TYPE_MORE));
 		return 2;
@@ -269,7 +268,7 @@ filter_data_(lua_State *L, int fd, uint8_t * buffer, int size) {
 			struct uncomplete * uc = save_uncomplete(L, fd);
 			uc->read = size;
 			uc->pack.size = pack_size;
-			uc->pack.buffer = malloc(pack_size);
+			uc->pack.buffer = skynet_malloc(pack_size);
 			memcpy(uc->pack.buffer, buffer, size);
 			return 1;
 		}
@@ -277,7 +276,7 @@ filter_data_(lua_State *L, int fd, uint8_t * buffer, int size) {
 			// just one package
 			lua_pushvalue(L, lua_upvalueindex(TYPE_DATA));
 			lua_pushinteger(L, fd);
-			void * result = malloc(pack_size);
+			void * result = skynet_malloc(pack_size);
 			memcpy(result, buffer, size);
 			lua_pushlightuserdata(L, result);
 			lua_pushinteger(L, size);
@@ -298,7 +297,7 @@ filter_data(lua_State *L, int fd, uint8_t * buffer, int size) {
 	int ret = filter_data_(L, fd, buffer, size);
 	// buffer is the data of socket message, it malloc at socket_server.c : function forward_message .
 	// it should be free before return,
-	free(buffer);
+	skynet_free(buffer);
 	return ret;
 }
 
@@ -419,7 +418,7 @@ lpack(lua_State *L) {
 		return luaL_error(L, "Invalid size (too long) of data : %d", (int)len);
 	}
 
-	uint8_t * buffer = malloc(len + 2);
+	uint8_t * buffer = skynet_malloc(len + 2);
 	write_size(buffer, len);
 	memcpy(buffer+2, ptr, len);
 
@@ -460,7 +459,7 @@ ltostring(lua_State *L) {
 		lua_pushliteral(L, "");
 	} else {
 		lua_pushlstring(L, (const char *)ptr, size);
-		free(ptr);
+		skynet_free(ptr);
 	}
 	return 1;
 }
diff --git a/lualib-src/lua-seri.c b/lualib-src/lua-seri.c
index 2e3b96d3..69e1c2af 100644
--- a/lualib-src/lua-seri.c
+++ b/lualib-src/lua-seri.c
@@ -2,8 +2,7 @@
   https://github.com/cloudwu/lua-serialize
  */
 
-// include skynet.h first for malloc hook
-#include "skynet.h"
+#include "skynet_malloc.h"
 
 #include <lua.h>
 #include <lauxlib.h>
@@ -50,7 +49,7 @@ struct read_block {
 
 inline static struct block *
 blk_alloc(void) {
-	struct block *b = malloc(sizeof(struct block));
+	struct block *b = skynet_malloc(sizeof(struct block));
 	b->next = NULL;
 	return b;
 }
@@ -113,7 +112,7 @@ wb_free(struct write_block *wb) {
 	struct block *blk = wb->head;
 	while (blk) {
 		struct block * next = blk->next;
-		free(blk);
+		skynet_free(blk);
 		blk = next;
 	}
 	wb->head = NULL;
@@ -145,7 +144,7 @@ rb_read(struct read_block *rb, void *buffer, int sz) {
 
 	if (rb->ptr == BLOCK_SIZE) {
 		struct block * next = rb->current->next;
-		free(rb->current);
+		skynet_free(rb->current);
 		rb->current = next;
 		rb->ptr = 0;
 	}
@@ -168,7 +167,7 @@ rb_read(struct read_block *rb, void *buffer, int sz) {
 
 	for (;;) {
 		struct block * next = rb->current->next;
-		free(rb->current);
+		skynet_free(rb->current);
 		rb->current = next;
 
 		if (sz < BLOCK_SIZE) {
@@ -188,7 +187,7 @@ static void
 rb_close(struct read_block *rb) {
 	while (rb->current) {
 		struct block * next = rb->current->next;
-		free(rb->current);
+		skynet_free(rb->current);
 		rb->current = next;
 	}
 	rb->len = 0;
@@ -549,7 +548,7 @@ _seri(lua_State *L, struct block *b) {
 	memcpy(&len, b->buffer ,sizeof(len));
 
 	len -= 4;
-	uint8_t * buffer = malloc(len);
+	uint8_t * buffer = skynet_malloc(len);
 	uint8_t * ptr = buffer;
 	int sz = len;
 	if (len < BLOCK_SIZE - 4) {
@@ -622,7 +621,7 @@ _luaseri_pack(lua_State *L) {
 
 	while (b) {
 		struct block * next = b->next;
-		free(b);
+		skynet_free(b);
 		b = next;
 	}
 
diff --git a/lualib-src/lua-socket.c b/lualib-src/lua-socket.c
index fb66d93d..c3ba9f3b 100644
--- a/lualib-src/lua-socket.c
+++ b/lualib-src/lua-socket.c
@@ -1,5 +1,4 @@
-// include skynet.h first for malloc hook
-#include "skynet.h"
+#include "skynet_malloc.h"
 
 #include <stdlib.h>
 #include <string.h>
@@ -38,7 +37,7 @@ lfreepool(lua_State *L) {
 	for (i=0;i<sz;i++) {
 		struct buffer_node *node = &pool[i];
 		if (node->msg) {
-			free(node->msg);
+			skynet_free(node->msg);
 			node->msg = NULL;
 		}
 	}
@@ -143,7 +142,7 @@ return_free_node(lua_State *L, int pool, struct socket_buffer *sb) {
 	lua_rawgeti(L,pool,1);
 	free_node->next = lua_touserdata(L,-1);
 	lua_pop(L,1);
-	free(free_node->msg);
+	skynet_free(free_node->msg);
 	free_node->msg = NULL;
 
 	free_node->sz = 0;
@@ -253,7 +252,7 @@ static int
 ldrop(lua_State *L) {
 	void * msg = lua_touserdata(L,1);
 	luaL_checkinteger(L,2);
-	free(msg);
+	skynet_free(msg);
 	return 0;
 }
 
@@ -324,7 +323,7 @@ static int
 lstr2p(lua_State *L) {
 	size_t sz = 0;
 	const char * str = luaL_checklstring(L,1,&sz);
-	void *ptr = malloc(sz);
+	void *ptr = skynet_malloc(sz);
 	memcpy(ptr, str, sz);
 	lua_pushlightuserdata(L, ptr);
 	lua_pushinteger(L, (int)sz);
@@ -414,7 +413,7 @@ get_buffer(lua_State *L, int *sz) {
 	} else {
 		size_t len = 0;
 		const char * str =  luaL_checklstring(L, 2, &len);
-		buffer = malloc(len);
+		buffer = skynet_malloc(len);
 		memcpy(buffer, str, len);
 		*sz = (int)len;
 	}
diff --git a/skynet-src/skynet_malloc.h b/skynet-src/skynet_malloc.h
index d3c6400c..0d1b9980 100644
--- a/skynet-src/skynet_malloc.h
+++ b/skynet-src/skynet_malloc.h
@@ -3,11 +3,15 @@
 
 #include <stddef.h>
 
+#ifdef SKYNET_MALLOC_RENAME
+
 #define malloc skynet_malloc
 #define calloc skynet_calloc
 #define realloc skynet_realloc
 #define free skynet_free
 
+#endif
+
 void * skynet_malloc(size_t sz);
 void * skynet_calloc(size_t nmemb,size_t size);
 void * skynet_realloc(void *ptr, size_t size);

From a99befd44c309495eab9ed6b8c3fc1f7bf9b9e0c Mon Sep 17 00:00:00 2001
From: Cloud Wu <cloudwu@gmail.com>
Date: Tue, 22 Apr 2014 15:27:45 +0800
Subject: [PATCH 3/3] use skynet_malloc in skynet_realloc

---
 skynet-src/malloc_hook.c | 2 +-
 skynet-src/skynet_main.c | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/skynet-src/malloc_hook.c b/skynet-src/malloc_hook.c
index 36048988..19f6e3ad 100644
--- a/skynet-src/malloc_hook.c
+++ b/skynet-src/malloc_hook.c
@@ -158,7 +158,7 @@ skynet_malloc(size_t size) {
 
 void *
 skynet_realloc(void *ptr, size_t size) {
-    if (ptr == NULL) return malloc(size);
+    if (ptr == NULL) return skynet_malloc(size);
 
     void* rawptr = clean_prefix(ptr);
     void *newptr = je_realloc(rawptr, size+PREFIX_SIZE);
diff --git a/skynet-src/skynet_main.c b/skynet-src/skynet_main.c
index ec60e2a1..8cebd00e 100644
--- a/skynet-src/skynet_main.c
+++ b/skynet-src/skynet_main.c
@@ -93,7 +93,7 @@ main(int argc, char *argv[]) {
 
 	struct skynet_config config;
 
-	struct lua_State *L = luaL_newstate();
+	struct lua_State *L = lua_newstate(skynet_lalloc, NULL);
 	luaL_openlibs(L);	// link lua lib
 	lua_close(L);