33 changed files with 647 additions and 1705 deletions
--- a/debian/changelog
+++ b/debian/changelog
@ -1,63 +1,3 @@
-libserverframe (1.2.11-1) unstable; urgency=medium
-
-  * upgrade to 1.2.11-1
-
- -- YuQing <384681@qq.com>  Sun, 23 Nov 2025 10:48:22 +0000
-
-libserverframe (1.2.11-1) unstable; urgency=medium
-
-  * upgrade to 1.2.11-1
-
- -- YuQing <384681@qq.com>  Sun, 23 Nov 2025 10:00:56 +0000
-
-libserverframe (1.2.11-1) unstable; urgency=medium
-
-  * upgrade to 1.2.11-1
-
- -- YuQing <384681@qq.com>  Sun, 23 Nov 2025 09:06:43 +0000
-
-libserverframe (1.2.8-1) unstable; urgency=medium
-
-  * upgrade to 1.2.8-1
-
- -- YuQing <384681@qq.com>  Sat, 16 Aug 2025 16:32:03 +0000
-
-libserverframe (1.2.7-1) unstable; urgency=medium
-
-  * upgrade to 1.2.7-1
-
- -- YuQing <384681@qq.com>  Sun, 06 Apr 2025 16:56:40 +0000
-
-libserverframe (1.2.5-1) unstable; urgency=medium
-
-  * upgrade to 1.2.5-1
-
- -- YuQing <384681@qq.com>  Sun, 29 Sep 2024 15:24:39 +0000
-
-libserverframe (1.2.4-1) unstable; urgency=medium
-
-  * upgrade to 1.2.4-1
-
- -- YuQing <384681@qq.com>  Sat, 15 Jun 2024 14:45:44 +0000
-
-libserverframe (1.2.3-1) unstable; urgency=medium
-
-  * upgrade to 1.2.3-1
-
- -- YuQing <384681@qq.com>  Sun, 17 Mar 2024 15:11:04 +0000
-
-libserverframe (1.2.2-1) unstable; urgency=medium
-
-  * upgrade to 1.2.2-1
-
- -- YuQing <384681@qq.com>  Wed, 31 Jan 2024 12:00:10 +0000
-
-libserverframe (1.2.1-1) unstable; urgency=medium
-
-  * upgrade to 1.2.1-1
-
- -- YuQing <384681@qq.com>  Mon, 01 Jan 2024 11:24:45 +0000
-
 libserverframe (1.2.0-3) unstable; urgency=medium

  * upgrade to 1.2.0-3
--- a/debian/substvars
+++ b/debian/substvars
@ -1 +1 @@
-libfastcommon:Version=1.0.83
+libfastcommon:Version=1.0.70
--- a/libserverframe.spec
+++ b/libserverframe.spec
@ -2,7 +2,7 @@
 %define CommitVersion %(echo $COMMIT_VERSION)

 Name: libserverframe
-Version: 1.2.11
+Version: 1.2.1
 Release: 1%{?dist}
 Summary: network framework library
 License: AGPL v3.0
@ -12,9 +12,9 @@ Source: http://github.com/happyfish100/libserverframe/%{name}-%{version}.tar.gz

 BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)

-BuildRequires: libfastcommon-devel >= 1.0.83
+BuildRequires: libfastcommon-devel >= 1.0.71
 Requires: %__cp %__mv %__chmod %__grep %__mkdir %__install %__id
-Requires: libfastcommon >= 1.0.83
+Requires: libfastcommon >= 1.0.71

 %description
 common framework library 
--- a/make.sh
+++ b/make.sh
@ -8,14 +8,11 @@ LIB_VERSION=lib64
 DEBUG_FLAG=0

 if [ -f /usr/include/fastcommon/_os_define.h ]; then
-  OS_BITS=$(grep -F OS_BITS /usr/include/fastcommon/_os_define.h | awk '{print $NF;}')
-  USE_URING=$(grep -F IOEVENT_USE_URING /usr/include/fastcommon/_os_define.h | awk '{print $NF;}')
+  OS_BITS=$(fgrep OS_BITS /usr/include/fastcommon/_os_define.h | awk '{print $NF;}')
 elif [ -f /usr/local/include/fastcommon/_os_define.h ]; then
-  OS_BITS=$(grep -F OS_BITS /usr/local/include/fastcommon/_os_define.h | awk '{print $NF;}')
-  USE_URING=$(grep -F IOEVENT_USE_URING /usr/local/include/fastcommon/_os_define.h | awk '{print $NF;}')
+  OS_BITS=$(fgrep OS_BITS /usr/local/include/fastcommon/_os_define.h | awk '{print $NF;}')
 else
  OS_BITS=64
-  USE_URING=''
 fi

 uname=$(uname)
@ -52,9 +49,6 @@ LIBS=''
 uname=$(uname)
 if [ "$uname" = "Linux" ]; then
  CFLAGS="$CFLAGS"
-  if [ -n "$USE_URING" ]; then
-    LIBS="$LIBS -luring"
-  fi
 elif [ "$uname" = "FreeBSD" ] || [ "$uname" = "Darwin" ]; then
  CFLAGS="$CFLAGS"
  if [ "$uname" = "Darwin" ]; then
@ -83,19 +77,19 @@ elif [ "$uname" = "HP-UX" ]; then
  fi
 elif [ "$uname" = "FreeBSD" ]; then
  if [ -f /usr/lib/libc_r.so ]; then
-    line=$(nm -D /usr/lib/libc_r.so | grep -F pthread_create | grep -w T)
+    line=$(nm -D /usr/lib/libc_r.so | grep pthread_create | grep -w T)
    if [ $? -eq 0 ]; then
      LIBS="$LIBS -lc_r"
      have_pthread=1
    fi
  elif [ -f /lib64/libc_r.so ]; then
-    line=$(nm -D /lib64/libc_r.so | grep -F pthread_create | grep -w T)
+    line=$(nm -D /lib64/libc_r.so | grep pthread_create | grep -w T)
    if [ $? -eq 0 ]; then
      LIBS="$LIBS -lc_r"
      have_pthread=1
    fi
  elif [ -f /usr/lib64/libc_r.so ]; then
-    line=$(nm -D /usr/lib64/libc_r.so | grep -F pthread_create | grep -w T)
+    line=$(nm -D /usr/lib64/libc_r.so | grep pthread_create | grep -w T)
    if [ $? -eq 0 ]; then
      LIBS="$LIBS -lc_r"
      have_pthread=1
@ -104,7 +98,7 @@ elif [ "$uname" = "FreeBSD" ]; then
 fi

 if [ $have_pthread -eq 0 ] && [ "$uname" = "Linux" ]; then
-   /sbin/ldconfig -p | grep -w libpthread.so > /dev/null
+   /sbin/ldconfig -p | fgrep libpthread.so > /dev/null
   if [ $? -eq 0 ]; then
      LIBS="$LIBS -lpthread"
   else
@ -138,7 +132,6 @@ fi

 cd ..
 cp Makefile.in Makefile
-sed_replace "s#\\\$(CC)#gcc#g" Makefile
 sed_replace "s#\\\$(CFLAGS)#$CFLAGS#g" Makefile
 sed_replace "s#\\\$(LIBS)#$LIBS#g" Makefile
 sed_replace "s#\\\$(TARGET_PREFIX)#$TARGET_PREFIX#g" Makefile
--- a/src/idempotency/client/client_channel.c
+++ b/src/idempotency/client/client_channel.c
@ -194,7 +194,7 @@ static struct fast_task_info *alloc_channel_task(IdempotencyClientChannel
        return NULL;
    }

-    fc_safe_strcpy(task->server_ip, server_ip);
+    snprintf(task->server_ip, sizeof(task->server_ip), "%s", server_ip);
    task->port = port;
    task->arg = channel;
    task->thread_data = g_sf_context.thread_data +
@ -203,8 +203,7 @@ static struct fast_task_info *alloc_channel_task(IdempotencyClientChannel
    channel->last_connect_time = g_current_time;
    if ((*err_no=sf_nio_notify(task, SF_NIO_STAGE_CONNECT)) != 0) {
        channel->in_ioevent = 0;   //rollback
-        __sync_sub_and_fetch(&task->reffer_count, 1);
-        free_queue_push(task);
+        sf_release_task(task);
        return NULL;
    }
    return task;
@ -214,15 +213,6 @@ int idempotency_client_channel_check_reconnect(
        IdempotencyClientChannel *channel)
 {
    int result;
-    char formatted_ip[FORMATTED_IP_SIZE];
-
-#if IOEVENT_USE_URING
-    struct fast_task_info *task;
-    task = channel->task;
-    if (SF_CTX->use_io_uring && FC_ATOMIC_GET(task->reffer_count) > 1) {
-        return 0;
-    }
-#endif

    if (!__sync_bool_compare_and_swap(&channel->in_ioevent, 0, 1)) {
        return 0;
@ -233,16 +223,11 @@ int idempotency_client_channel_check_reconnect(
        channel->last_connect_time = g_current_time;
    }

-    if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
-        format_ip_address(channel->task->server_ip, formatted_ip);
    logDebug("file: "__FILE__", line: %d, "
-                "trigger connect to server %s:%u", __LINE__,
-                formatted_ip, channel->task->port);
-    }
+            "trigger connect to server %s:%u",
+            __LINE__, channel->task->server_ip,
+            channel->task->port);

-    if (channel->task->event.fd >= 0) {
-        channel->task->handler->close_connection(channel->task);
-    }
    __sync_bool_compare_and_swap(&channel->task->canceled, 1, 0);
    if ((result=sf_nio_notify(channel->task, SF_NIO_STAGE_CONNECT)) == 0) {
        channel->last_connect_time = g_current_time;
@ -267,10 +252,7 @@ struct idempotency_client_channel *idempotency_client_channel_get(
    IdempotencyClientChannel *current;
    IdempotencyClientChannel *channel;

-    key_len = strlen(server_ip);
-    memcpy(key, server_ip, key_len);
-    *(key + key_len++) = '-';
-    key_len += fc_itoa(server_port, key + key_len);
+    key_len = snprintf(key, sizeof(key), "%s-%u", server_ip, server_port);
    hash_code = fc_simple_hash(key, key_len);
    bucket = channel_context.htable.buckets +
        hash_code % channel_context.htable.capacity;
@ -354,8 +336,8 @@ int idempotency_client_channel_push(struct idempotency_client_channel *channel,
    receipt->req_id = req_id;
    fc_queue_push_ex(&channel->queue, receipt, &notify);
    if (notify) {
-        if (FC_ATOMIC_GET(channel->in_ioevent)) {
-            if (FC_ATOMIC_GET(channel->established)) {
+        if (__sync_add_and_fetch(&channel->in_ioevent, 0)) {
+            if (__sync_add_and_fetch(&channel->established, 0)) {
                sf_nio_notify(channel->task, SF_NIO_STAGE_CONTINUE);
            }
        } else {
--- a/src/idempotency/client/client_channel.h
+++ b/src/idempotency/client/client_channel.h
@ -76,22 +76,20 @@ static inline void idempotency_client_channel_set_id_key(
 static inline int idempotency_client_channel_check_wait_ex(
        struct idempotency_client_channel *channel, const int timeout)
 {
-    if (FC_ATOMIC_GET(channel->established)) {
+    if (__sync_add_and_fetch(&channel->established, 0)) {
        return 0;
    }

    idempotency_client_channel_check_reconnect(channel);
    lcp_timedwait_sec(&channel->lcp, timeout);
-    if (FC_ATOMIC_GET(channel->established)) {
+    if (__sync_add_and_fetch(&channel->established, 0)) {
        return 0;
    } else {
        /*
-        char formatted_ip[FORMATTED_IP_SIZE];
-        format_ip_address(channel->task->server_ip, formatted_ip);
        logInfo("file: "__FILE__", line: %d, "
                "channel_check fail, server %s:%u, in_ioevent: %d, "
                "canceled: %d, req count: %"PRId64, __LINE__,
-                formatted_ip, channel->task->port,
+                channel->task->server_ip, channel->task->port,
                __sync_add_and_fetch(&channel->in_ioevent, 0),
                __sync_add_and_fetch(&channel->task->canceled, 0),
                channel->task->req_count);
--- a/src/idempotency/client/client_types.h
+++ b/src/idempotency/client/client_types.h
@ -67,6 +67,7 @@ typedef struct idempotency_receipt_global_vars {
    struct {
        int task_padding_size;
        sf_init_connection_callback init_connection;
+        struct ibv_pd *pd;
    } rdma;
    IdempotencyReceiptThreadContext *thread_contexts;
 } IdempotencyReceiptGlobalVars;
--- a/src/idempotency/client/receipt_handler.c
+++ b/src/idempotency/client/receipt_handler.c
@ -46,15 +46,14 @@ static IdempotencyReceiptGlobalVars receipt_global_vars;
 #define RECEIPT_THREAD_CONTEXTS  receipt_global_vars.thread_contexts
 #define TASK_PADDING_SIZE        receipt_global_vars.rdma.task_padding_size
 #define RDMA_INIT_CONNECTION     receipt_global_vars.rdma.init_connection
+#define RDMA_PD                  receipt_global_vars.rdma.pd

-static int receipt_init_task(struct fast_task_info *task, void *arg)
+static int receipt_init_task(struct fast_task_info *task)
 {
-#if IOEVENT_USE_URING
-    FC_URING_IS_CLIENT(task) = true;
-#endif
-
+    task->connect_timeout = SF_G_CONNECT_TIMEOUT; //for client side
+    task->network_timeout = SF_G_NETWORK_TIMEOUT;
    if (RDMA_INIT_CONNECTION != NULL) {
-        return RDMA_INIT_CONNECTION(task, arg);
+        return RDMA_INIT_CONNECTION(task, RDMA_PD);
    } else {
        return 0;
    }
@ -63,13 +62,11 @@ static int receipt_init_task(struct fast_task_info *task, void *arg)
 static int receipt_recv_timeout_callback(struct fast_task_info *task)
 {
    IdempotencyClientChannel *channel;
-    char formatted_ip[FORMATTED_IP_SIZE];

-    format_ip_address(task->server_ip, formatted_ip);
    if (SF_NIO_TASK_STAGE_FETCH(task) == SF_NIO_STAGE_CONNECT) {
        logError("file: "__FILE__", line: %d, "
                "connect to server %s:%u timeout",
-                __LINE__, formatted_ip, task->port);
+                __LINE__, task->server_ip, task->port);
        return ETIMEDOUT;
    }

@ -77,12 +74,12 @@ static int receipt_recv_timeout_callback(struct fast_task_info *task)
    if (channel->waiting_resp_qinfo.head != NULL) {
        logError("file: "__FILE__", line: %d, "
                "waiting receipt response from server %s:%u timeout",
-                __LINE__, formatted_ip, task->port);
+                __LINE__, task->server_ip, task->port);
    } else {
        logError("file: "__FILE__", line: %d, "
                "%s server %s:%u timeout, channel established: %d",
                __LINE__, task->nio_stages.current == SF_NIO_STAGE_SEND ?
-                "send to" : "recv from", formatted_ip, task->port,
+                "send to" : "recv from", task->server_ip, task->port,
                FC_ATOMIC_GET(channel->established));
    }

@ -92,10 +89,10 @@ static int receipt_recv_timeout_callback(struct fast_task_info *task)
 static void receipt_task_finish_cleanup(struct fast_task_info *task)
 {
    IdempotencyClientChannel *channel;
-    char formatted_ip[FORMATTED_IP_SIZE];

    if (task->event.fd >= 0) {
        sf_task_detach_thread(task);
+        task->handler->close_connection(task);
    }

    sf_nio_reset_task_length(task);
@ -107,12 +104,9 @@ static void receipt_task_finish_cleanup(struct fast_task_info *task)
    __sync_bool_compare_and_swap(&channel->established, 1, 0);
    __sync_bool_compare_and_swap(&channel->in_ioevent, 1, 0);

-    if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
-        format_ip_address(task->server_ip, formatted_ip);
    logDebug("file: "__FILE__", line: %d, "
            "receipt task for server %s:%u exit",
-                __LINE__, formatted_ip, task->port);
-    }
+            __LINE__, task->server_ip, task->port);
 }

 static void setup_channel_request(struct fast_task_info *task)
@ -253,14 +247,11 @@ static inline int receipt_expect_body_length(struct fast_task_info *task,
        const int expect_body_len)
 {
    int body_len;
-    char formatted_ip[FORMATTED_IP_SIZE];
-
    body_len = task->recv.ptr->length - sizeof(SFCommonProtoHeader);
    if (body_len != expect_body_len) {
-        format_ip_address(task->server_ip, formatted_ip);
        logError("file: "__FILE__", line: %d, "
                "server %s:%u, response body length: %d != %d", __LINE__,
-                formatted_ip, task->port, body_len, expect_body_len);
+                task->server_ip, task->port, body_len, expect_body_len);
        return EINVAL;
    }

@ -273,7 +264,6 @@ static int deal_setup_channel_response(struct fast_task_info *task)
    IdempotencyReceiptThreadContext *thread_ctx;
    SFProtoSetupChannelResp *resp;
    IdempotencyClientChannel *channel;
-    char formatted_ip[FORMATTED_IP_SIZE];
    int channel_id;
    int channel_key;
    int buffer_size;
@ -285,12 +275,11 @@ static int deal_setup_channel_response(struct fast_task_info *task)
    }

    channel = (IdempotencyClientChannel *)task->arg;
-    if (FC_ATOMIC_GET(channel->established)) {
-        format_ip_address(task->server_ip, formatted_ip);
+    if (__sync_add_and_fetch(&channel->established, 0)) {
        logWarning("file: "__FILE__", line: %d, "
                "response from server %s:%u, unexpected cmd: "
                "SETUP_CHANNEL_RESP, ignore it!",
-                __LINE__, formatted_ip, task->port);
+                __LINE__, task->server_ip, task->port);
        return 0;
    }

@ -327,7 +316,6 @@ static inline int deal_report_req_receipt_response(struct fast_task_info *task)
    IdempotencyClientChannel *channel;
    IdempotencyClientReceipt *current;
    IdempotencyClientReceipt *deleted;
-    char formatted_ip[FORMATTED_IP_SIZE];

    if ((result=receipt_expect_body_length(task, 0)) != 0) {
        return result;
@ -335,11 +323,10 @@ static inline int deal_report_req_receipt_response(struct fast_task_info *task)

    channel = (IdempotencyClientChannel *)task->arg;
    if (channel->waiting_resp_qinfo.head == NULL) {
-        format_ip_address(task->server_ip, formatted_ip);
        logWarning("file: "__FILE__", line: %d, "
                "response from server %s:%u, unexpect cmd: "
                "REPORT_REQ_RECEIPT_RESP", __LINE__,
-                formatted_ip, task->port);
+                task->server_ip, task->port);
        return EINVAL;
    }

@ -361,7 +348,6 @@ static int receipt_deal_task(struct fast_task_info *task, const int stage)
 {
    int result;
    SFCommonProtoHeader *header;
-    char formatted_ip[FORMATTED_IP_SIZE];

    do {
        if (stage == SF_NIO_STAGE_HANDSHAKE) {
@ -389,11 +375,10 @@ static int receipt_deal_task(struct fast_task_info *task, const int stage)

            msg_len = SF_RECV_BODY_LENGTH(task);
            message = SF_PROTO_RECV_BODY(task);
-            format_ip_address(task->server_ip, formatted_ip);
            logError("file: "__FILE__", line: %d, "
                    "response from server %s:%u, cmd: %d (%s), "
                    "status: %d, error info: %.*s", __LINE__,
-                    formatted_ip, task->port, header->cmd,
+                    task->server_ip, task->port, header->cmd,
                    sf_get_cmd_caption(header->cmd),
                    result, msg_len, message);
            break;
@ -412,18 +397,14 @@ static int receipt_deal_task(struct fast_task_info *task, const int stage)
                break;
            case SF_SERVICE_PROTO_CLOSE_CHANNEL_RESP:
                result = ECONNRESET; //force to close socket
-                if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
-                    format_ip_address(task->server_ip, formatted_ip);
                logDebug("file: "__FILE__", line: %d, "
                    "close channel to server %s:%u !!!",
-                            __LINE__, formatted_ip, task->port);
-                }
+                    __LINE__, task->server_ip, task->port);
                break;
            default:
-                format_ip_address(task->server_ip, formatted_ip);
                logError("file: "__FILE__", line: %d, "
                        "response from server %s:%u, unexpect cmd: %d (%s)",
-                        __LINE__, formatted_ip, task->port, header->cmd,
+                        __LINE__, task->server_ip, task->port, header->cmd,
                        sf_get_cmd_caption(header->cmd));
                result = EINVAL;
                break;
@ -468,7 +449,6 @@ static void receipt_thread_close_idle_channel(
 {
    IdempotencyClientChannel *channel;
    IdempotencyClientChannel *tmp;
-    char formatted_ip[FORMATTED_IP_SIZE];

    fc_list_for_each_entry_safe(channel, tmp, &thread_ctx->head, dlink) {
        if (channel->task->pending_send_count > 0) {
@ -478,12 +458,9 @@ static void receipt_thread_close_idle_channel(
        if (g_current_time - channel->last_report_time >
                 g_idempotency_client_cfg.channel_max_idle_time)
        {
-            if (FC_LOG_BY_LEVEL(LOG_DEBUG)) {
-                format_ip_address(channel->task->server_ip, formatted_ip);
            logDebug("file: "__FILE__", line: %d, "
                    "close channel to server %s:%u because idle too long",
-                        __LINE__, formatted_ip, channel->task->port);
-            }
+                    __LINE__, channel->task->server_ip, channel->task->port);
            close_channel_request(channel->task);
        }
    }
@ -523,12 +500,10 @@ static int do_init(FCAddressPtrArray *address_array)
 {
    const int task_arg_size = 0;
    const bool double_buffers = false;
-    const bool need_shrink_task_buffer = false;
    const bool explicit_post_recv = false;
    int result;
    int bytes;
    SFNetworkHandler *rdma_handler;
-    struct ibv_pd *pd;

    bytes = sizeof(IdempotencyReceiptThreadContext) * SF_G_WORK_THREADS;
    RECEIPT_THREAD_CONTEXTS = (IdempotencyReceiptThreadContext *)
@ -545,19 +520,19 @@ static int do_init(FCAddressPtrArray *address_array)

        TASK_PADDING_SIZE = rdma_handler->get_connection_size();
        RDMA_INIT_CONNECTION = rdma_handler->init_connection;
-        pd = rdma_handler->pd;
+        RDMA_PD = rdma_handler->pd;
    } else {
        TASK_PADDING_SIZE = 0;
        RDMA_INIT_CONNECTION = NULL;
-        pd = NULL;
+        RDMA_PD = NULL;
    }
    return sf_service_init_ex2(&g_sf_context, "idemp-receipt",
            receipt_alloc_thread_extra_data, receipt_thread_loop_callback,
            NULL, sf_proto_set_body_length, NULL, NULL, receipt_deal_task,
            receipt_task_finish_cleanup, receipt_recv_timeout_callback,
            1000, sizeof(SFCommonProtoHeader), TASK_PADDING_SIZE,
-            task_arg_size, double_buffers, need_shrink_task_buffer,
-            explicit_post_recv, receipt_init_task, pd, NULL);
+            task_arg_size, double_buffers, explicit_post_recv,
+            receipt_init_task, NULL);
 }

 int receipt_handler_init(FCAddressPtrArray *address_array)
@ -569,6 +544,7 @@ int receipt_handler_init(FCAddressPtrArray *address_array)
    }

    sf_enable_thread_notify(true);
+    sf_set_remove_from_ready_list(false);
    fc_sleep_ms(100);

    return 0;
--- a/src/sf_binlog_index.c
+++ b/src/sf_binlog_index.c
@ -186,11 +186,9 @@ static int save(SFBinlogIndexContext *ctx, const char *filename)
    result = 0;
    p = buff;
    bend = buff + sizeof(buff);
-
-    p += fc_itoa(ctx->index_array.count, p);
-    *p++ = ' ';
-    p += fc_itoa(ctx->last_version, p);
-    *p++ = '\n';
+    p += sprintf(p, "%d %"PRId64"\n",
+            ctx->index_array.count,
+            ctx->last_version);

    index = ctx->index_array.indexes;
    for (i=0; i<ctx->index_array.count; i++) {
@ -229,7 +227,7 @@ int sf_binlog_index_save(SFBinlogIndexContext *ctx)
    int result;
    char tmp_filename[PATH_MAX];

-    fc_combine_two_strings(ctx->filename, "tmp", '.', tmp_filename);
+    snprintf(tmp_filename, sizeof(tmp_filename), "%s.tmp", ctx->filename);
    if ((result=save(ctx, tmp_filename)) != 0) {
        return result;
    }
--- a/src/sf_binlog_writer.c
+++ b/src/sf_binlog_writer.c
@ -168,7 +168,6 @@ static int deal_binlog_records(SFBinlogWriterThread *thread,
        SFBinlogWriterBuffer *wb_head, uint32_t *last_timestamp)
 {
    int result;
-    bool skip_empty_file;
    SFBinlogWriterBuffer *wbuffer;
    SFBinlogWriterBuffer *current;

@ -197,16 +196,12 @@ static int deal_binlog_records(SFBinlogWriterThread *thread,
                        thread->mblock, current);
                break;
            case SF_BINLOG_BUFFER_TYPE_ROTATE_FILE:
-                flush_writer_files(thread);
-                skip_empty_file = current->version.first;
-                if (!(skip_empty_file && current->writer->fw.file.size == 0)) {
                if ((result=sf_file_writer_set_binlog_write_index(&current->
                                writer->fw, current->writer->fw.binlog.
                                last_index + 1)) != 0)
                {
                    return result;
                }
-                }
                fast_mblock_free_object(&current->writer->
                        thread->mblock, current);
                break;
@ -305,7 +300,7 @@ void sf_binlog_writer_finish(SFBinlogWriterInfo *writer)
    uint32_t last_timestamp;
    int count;

-    if (writer->fw.file.name.str != NULL) {
+    if (writer->fw.file.name != NULL) {
        while (writer->thread->running && !fc_queue_empty(
                    &writer->thread->queue))
        {
@ -333,8 +328,8 @@ void sf_binlog_writer_finish(SFBinlogWriterInfo *writer)
            deal_binlog_records(writer->thread, wb_head, &last_timestamp);
        }

-        free(writer->fw.file.name.str);
-        writer->fw.file.name.str = NULL;
+        free(writer->fw.file.name);
+        writer->fw.file.name = NULL;
    }

    if (writer->fw.file.fd >= 0) {
@ -347,7 +342,6 @@ static void *binlog_writer_func(void *arg)
 {
    SFBinlogWriterThread *thread;
    SFBinlogWriterBuffer *wb_head;
-    uint32_t last_record_time;
    uint32_t current_timestamp;
    uint32_t last_timestamp;
    int result;
@ -357,12 +351,13 @@ static void *binlog_writer_func(void *arg)
 #ifdef OS_LINUX
    {
        char thread_name[64];
-        fc_combine_two_strings(thread->name, "writer", '-', thread_name);
+        snprintf(thread_name, sizeof(thread_name),
+                "%s-writer", thread->name);
        prctl(PR_SET_NAME, thread_name);
    }
 #endif

-    last_record_time = current_timestamp = last_timestamp = 0;
+    current_timestamp = last_timestamp = 0;
    thread->running = true;
    while (SF_G_CONTINUE_FLAG) {
        wb_head = (SFBinlogWriterBuffer *)fc_queue_pop_all(&thread->queue);
@ -371,7 +366,7 @@ static void *binlog_writer_func(void *arg)
        }

        if ((result=deal_binlog_records(thread, wb_head,
-                        &last_record_time)) != 0)
+                        &current_timestamp)) != 0)
        {
            if (result != ERRNO_THREAD_EXIT) {
                logCrit("file: "__FILE__", line: %d, "
@ -384,8 +379,6 @@ static void *binlog_writer_func(void *arg)

        if (fc_queue_empty(&thread->queue)) {
            current_timestamp = 0;
-        } else {
-            current_timestamp = last_record_time;
        }
        if ((current_timestamp == 0 && last_timestamp != 0) ||
                (current_timestamp > last_timestamp))
@ -400,12 +393,6 @@ static void *binlog_writer_func(void *arg)
            }
            PTHREAD_MUTEX_UNLOCK(&thread->flow_ctrol.lcp.lock);
        }
-
-        if (thread->write_interval_ms > 0 &&
-                last_record_time == g_current_time)
-        {
-            fc_sleep_ms(thread->write_interval_ms);
-        }
    }

    thread->running = false;
@ -443,23 +430,20 @@ static void binlog_wbuffer_destroy_func(void *element, void *args)

 int sf_binlog_writer_init_normal_ex(SFBinlogWriterInfo *writer,
        const char *data_path, const char *subdir_name,
-        const char *file_prefix, const int max_record_size,
-        const int buffer_size, const int64_t file_rotate_size,
-        const bool call_fsync)
+        const char *file_prefix, const int buffer_size,
+        const int64_t file_rotate_size, const bool call_fsync)
 {
    memset(writer, 0, sizeof(*writer));
    writer->order_by = SF_BINLOG_WRITER_TYPE_ORDER_BY_NONE;
    return sf_file_writer_init(&writer->fw, data_path, subdir_name,
-            file_prefix, max_record_size, buffer_size,
-            file_rotate_size, call_fsync);
+            file_prefix, buffer_size, file_rotate_size, call_fsync);
 }

 int sf_binlog_writer_init_by_version_ex(SFBinlogWriterInfo *writer,
        const char *data_path, const char *subdir_name,
-        const char *file_prefix, const int max_record_size,
-        const uint64_t next_version, const int buffer_size,
-        const int ring_size, const int64_t file_rotate_size,
-        const bool call_fsync)
+        const char *file_prefix, const uint64_t next_version,
+        const int buffer_size, const int ring_size,
+        const int64_t file_rotate_size, const bool call_fsync)
 {
    int bytes;

@ -478,15 +462,13 @@ int sf_binlog_writer_init_by_version_ex(SFBinlogWriterInfo *writer,
    binlog_writer_set_next_version(writer, next_version);
    writer->flush.in_queue = false;
    return sf_file_writer_init(&writer->fw, data_path, subdir_name,
-            file_prefix, max_record_size, buffer_size,
-            file_rotate_size, call_fsync);
+            file_prefix, buffer_size, file_rotate_size, call_fsync);
 }

 int sf_binlog_writer_init_thread_ex(SFBinlogWriterThread *thread,
        const char *name, SFBinlogWriterInfo *writer, const short order_mode,
-        const int write_interval_ms, const int max_delay,
-        const int max_record_size, const bool use_fixed_buffer_size,
-        const bool passive_write)
+        const int max_delay, const int max_record_size, const bool
+        use_fixed_buffer_size, const bool passive_write)
 {
    const int alloc_elements_once = 1024;
    const int64_t alloc_elements_limit = 0;
@ -496,11 +478,10 @@ int sf_binlog_writer_init_thread_ex(SFBinlogWriterThread *thread,
    pthread_t tid;
    struct fast_mblock_object_callbacks callbacks;

-    fc_safe_strcpy(thread->name, name);
+    snprintf(thread->name, sizeof(thread->name), "%s", name);
    thread->order_mode = order_mode;
    thread->use_fixed_buffer_size = use_fixed_buffer_size;
    thread->passive_write = passive_write;
-    thread->write_interval_ms = write_interval_ms;
    thread->flow_ctrol.max_delay = max_delay;
    writer->fw.cfg.max_record_size = max_record_size;
    writer->thread = thread;
@ -627,12 +608,10 @@ int sf_binlog_writer_change_write_index(SFBinlogWriterInfo *writer,
            SF_BINLOG_BUFFER_TYPE_SET_WRITE_INDEX, write_index);
 }

-int sf_binlog_writer_rotate_file_ex(SFBinlogWriterInfo *writer,
-        const bool skip_empty_file)
+int sf_binlog_writer_rotate_file(SFBinlogWriterInfo *writer)
 {
    return sf_binlog_writer_push_directive(writer,
-            SF_BINLOG_BUFFER_TYPE_ROTATE_FILE,
-            skip_empty_file ? 1 : 0);
+            SF_BINLOG_BUFFER_TYPE_ROTATE_FILE, 0);
 }

 int sf_binlog_writer_flush_file(SFBinlogWriterInfo *writer)
--- a/src/sf_binlog_writer.h
+++ b/src/sf_binlog_writer.h
@ -72,7 +72,6 @@ typedef struct binlog_writer_thread {
    bool use_fixed_buffer_size;
    bool passive_write;
    char order_mode;
-    int write_interval_ms;
    struct {
        int max_delay;  //in seconds
        volatile uint32_t last_timestamp;
@ -113,64 +112,61 @@ extern "C" {

 int sf_binlog_writer_init_normal_ex(SFBinlogWriterInfo *writer,
        const char *data_path, const char *subdir_name,
-        const char *file_prefix, const int max_record_size,
-        const int buffer_size, const int64_t file_rotate_size,
-        const bool call_fsync);
+        const char *file_prefix, const int buffer_size,
+        const int64_t file_rotate_size, const bool call_fsync);

 int sf_binlog_writer_init_by_version_ex(SFBinlogWriterInfo *writer,
        const char *data_path, const char *subdir_name,
-        const char *file_prefix, const int max_record_size,
-        const uint64_t next_version, const int buffer_size,
-        const int ring_size, const int64_t file_rotate_size,
-        const bool call_fsync);
+        const char *file_prefix, const uint64_t next_version,
+        const int buffer_size, const int ring_size,
+        const int64_t file_rotate_size, const bool call_fsync);

 int sf_binlog_writer_init_thread_ex(SFBinlogWriterThread *thread,
        const char *name, SFBinlogWriterInfo *writer, const short order_mode,
-        const int write_interval_ms, const int max_delay,
-        const int max_record_size, const bool use_fixed_buffer_size,
-        const bool passive_write);
+        const int max_delay, const int max_record_size, const bool
+        use_fixed_buffer_size, const bool passive_write);

-#define sf_binlog_writer_init_normal(writer, data_path, \
-        subdir_name, max_record_size, buffer_size)      \
+#define sf_binlog_writer_init_normal(writer,  \
+        data_path, subdir_name, buffer_size)  \
    sf_binlog_writer_init_normal_ex(writer, data_path, subdir_name, \
-            SF_BINLOG_FILE_PREFIX_STR, max_record_size, buffer_size, \
+            SF_BINLOG_FILE_PREFIX, buffer_size, \
            SF_BINLOG_DEFAULT_ROTATE_SIZE, true)

-#define sf_binlog_writer_init_by_version(writer, data_path, subdir_name, \
-        max_record_size, next_version, buffer_size, ring_size)           \
+#define sf_binlog_writer_init_by_version(writer, data_path,   \
+        subdir_name, next_version, buffer_size, ring_size)    \
    sf_binlog_writer_init_by_version_ex(writer, data_path, subdir_name, \
-            SF_BINLOG_FILE_PREFIX_STR, max_record_size, next_version,    \
-            buffer_size, ring_size, SF_BINLOG_DEFAULT_ROTATE_SIZE, true)
+            SF_BINLOG_FILE_PREFIX, next_version, buffer_size, \
+            ring_size, SF_BINLOG_DEFAULT_ROTATE_SIZE, true)

 #define sf_binlog_writer_init_thread(thread, name, \
-        writer, write_interval_ms, max_delay, max_record_size)    \
+        writer, max_delay, max_record_size) \
    sf_binlog_writer_init_thread_ex(thread, name, writer, \
-            SF_BINLOG_THREAD_ORDER_MODE_FIXED, write_interval_ms, \
-            max_delay, max_record_size, true, false)
+            SF_BINLOG_THREAD_ORDER_MODE_FIXED, max_delay, \
+            max_record_size, true, false)

 static inline int sf_binlog_writer_init_ex(SFBinlogWriterContext *context,
        const char *data_path, const char *subdir_name,
        const char *file_prefix, const int buffer_size,
-        const int write_interval_ms, const int max_delay,
-        const int max_record_size, const bool call_fsync)
+        const int max_delay, const int max_record_size,
+        const bool call_fsync)
 {
    int result;
-    if ((result=sf_binlog_writer_init_normal_ex(&context->writer, data_path,
-                    subdir_name, file_prefix, max_record_size, buffer_size,
+    if ((result=sf_binlog_writer_init_normal_ex(&context->writer,
+                    data_path, subdir_name, file_prefix, buffer_size,
                    SF_BINLOG_DEFAULT_ROTATE_SIZE, call_fsync)) != 0)
    {
        return result;
    }

    return sf_binlog_writer_init_thread(&context->thread, subdir_name,
-            &context->writer, write_interval_ms, max_delay, max_record_size);
+            &context->writer, max_delay, max_record_size);
 }

 #define sf_binlog_writer_init(context, data_path, subdir_name, \
-        buffer_size, write_interval_ms, max_delay, max_record_size) \
+        buffer_size, max_delay, max_record_size) \
    sf_binlog_writer_init_ex(context, data_path, subdir_name,  \
-            SF_BINLOG_FILE_PREFIX_STR, buffer_size, write_interval_ms,  \
-            max_delay, max_record_size, true)
+            SF_BINLOG_FILE_PREFIX, buffer_size, max_delay,     \
+            max_record_size, true)

 void sf_binlog_writer_finish(SFBinlogWriterInfo *writer);

@ -235,14 +231,7 @@ static inline int sf_binlog_writer_get_thread_waiting_count(
    return waiting_count;
 }

-int sf_binlog_writer_rotate_file_ex(SFBinlogWriterInfo *writer,
-        const bool skip_empty_file);
-
-static inline int sf_binlog_writer_rotate_file(SFBinlogWriterInfo *writer)
-{
-    const bool skip_empty_file = false;
-    return sf_binlog_writer_rotate_file_ex(writer, skip_empty_file);
-}
+int sf_binlog_writer_rotate_file(SFBinlogWriterInfo *writer);

 int sf_binlog_writer_flush_file(SFBinlogWriterInfo *writer);

@ -254,9 +243,6 @@ int sf_binlog_writer_notify_exit(SFBinlogWriterInfo *writer);
 #define sf_binlog_writer_set_flags(writer, flags) \
    sf_file_writer_set_flags(&(writer)->fw, flags)

-#define sf_binlog_writer_set_write_done_callback(writer, callback, args) \
-    sf_file_writer_set_write_done_callback(&(writer)->fw, callback, args)
-
 #define sf_binlog_writer_get_last_version_ex(writer, log_level) \
    sf_file_writer_get_last_version_ex(&(writer)->fw, log_level)

@ -286,9 +272,7 @@ static inline SFBinlogWriterBuffer *sf_binlog_writer_alloc_buffer(
 {
    SFBinlogWriterBuffer *buffer;

-    if ((buffer=(SFBinlogWriterBuffer *)fast_mblock_alloc_object(
-                    &thread->mblock)) != NULL)
-    {
+    if ((buffer=fast_mblock_alloc_object(&thread->mblock)) != NULL) {
        buffer->type = SF_BINLOG_BUFFER_TYPE_WRITE_TO_FILE;
    }
    return buffer;
--- a/src/sf_buffered_writer.h
+++ b/src/sf_buffered_writer.h
@ -30,11 +30,8 @@ typedef struct {
 #define sf_buffered_writer_init(writer, filename) \
    sf_buffered_writer_init_ex(writer, filename, 1024 * 1024)

-#define SF_BUFFERED_WRITER_LENGTH(bw)  \
-    SF_BINLOG_BUFFER_PRODUCER_DATA_LENGTH((bw).buffer)
-
-#define SF_BUFFERED_WRITER_REMAIN(bw)  \
-    SF_BINLOG_BUFFER_PRODUCER_BUFF_REMAIN((bw).buffer)
+#define SF_BUFFERED_WRITER_LENGTH(bw) ((bw).buffer.current - (bw).buffer.buff)
+#define SF_BUFFERED_WRITER_REMAIN(bw) ((bw).buffer.end - (bw).buffer.current)

 #ifdef __cplusplus
 extern "C" {
@ -59,6 +56,7 @@ extern "C" {
        if ((result=sf_binlog_buffer_init(&writer->buffer, buffer_size)) != 0) {
            return result;
        }
+        writer->buffer.end = writer->buffer.buff + writer->buffer.size;
        return 0;
    }

@ -67,7 +65,7 @@ extern "C" {
        int result;
        int length;

-        length = writer->buffer.data_end - writer->buffer.buff;
+        length = writer->buffer.current - writer->buffer.buff;
        if (fc_safe_write(writer->fd, writer->buffer.buff, length) != length) {
            result = errno != 0 ? errno : EIO;
            logError("file: "__FILE__", line: %d, "
@ -76,27 +74,17 @@ extern "C" {
            return result;
        }

-        writer->buffer.data_end = writer->buffer.buff;
+        writer->buffer.current = writer->buffer.buff;
        return 0;
    }

-    static inline int sf_buffered_writer_destroy(SFBufferedWriter *writer)
+    static inline void sf_buffered_writer_destroy(SFBufferedWriter *writer)
    {
-        int result;
-
        if (writer->fd >= 0) {
-            if (fsync(writer->fd) != 0) {
-                result = errno != 0 ? errno : EIO;
-                logError("file: "__FILE__", line: %d, "
-                        "fsync to file %s fail, errno: %d, error info: %s",
-                        __LINE__, writer->filename, result, STRERROR(result));
-                return result;
-            }
            close(writer->fd);
            writer->fd = -1;
        }
        sf_binlog_buffer_destroy(&writer->buffer);
-        return 0;
    }

 #ifdef __cplusplus
--- a/src/sf_cluster_cfg.c
+++ b/src/sf_cluster_cfg.c
@ -23,7 +23,7 @@ static int calc_cluster_config_sign(SFClusterConfig *cluster)
    FastBuffer buffer;
    int result;

-    if ((result=fast_buffer_init1(&buffer, 1024)) != 0) {
+    if ((result=fast_buffer_init_ex(&buffer, 1024)) != 0) {
        return result;
    }
    fc_server_to_config_string(&cluster->server_cfg, &buffer);
--- a/src/sf_connection_manager.c
+++ b/src/sf_connection_manager.c
@ -35,14 +35,14 @@ static int get_group_servers(SFConnectionManager *cm,
        SFCMConnGroupEntry *group);

 static ConnectionInfo *get_spec_connection(SFConnectionManager *cm,
-        const ConnectionInfo *target, const bool shared, int *err_no)
+        const ConnectionInfo *target, int *err_no)
 {
    return conn_pool_get_connection_ex(&cm->cpool,
-            target, cm->module_name, shared, err_no);
+            target, cm->module_name, err_no);
 }

 static ConnectionInfo *make_connection(SFConnectionManager *cm,
-        FCAddressPtrArray *addr_array, const bool shared, int *err_no)
+        FCAddressPtrArray *addr_array, int *err_no)
 {
    FCAddressInfo **current;
    FCAddressInfo **addr;
@ -56,7 +56,7 @@ static ConnectionInfo *make_connection(SFConnectionManager *cm,

    current = addr_array->addrs + addr_array->index;
    if ((conn=get_spec_connection(cm, &(*current)->conn,
-                    shared, err_no)) != NULL)
+                    err_no)) != NULL)
    {
        return conn;
    }
@ -72,7 +72,7 @@ static ConnectionInfo *make_connection(SFConnectionManager *cm,
        }

        if ((conn=get_spec_connection(cm, &(*addr)->conn,
-                        shared, err_no)) != NULL)
+                        err_no)) != NULL)
        {
            addr_array->index = addr - addr_array->addrs;
            return conn;
@ -83,13 +83,13 @@ static ConnectionInfo *make_connection(SFConnectionManager *cm,
 }

 static ConnectionInfo *get_server_connection(SFConnectionManager *cm,
-        FCServerInfo *server, const bool shared, int *err_no)
+        FCServerInfo *server, int *err_no)
 {
    FCAddressPtrArray *addr_array;
    ConnectionInfo *conn;

    addr_array = &server->group_addrs[cm->server_group_index].address_array;
-    if ((conn=make_connection(cm, addr_array, shared, err_no)) == NULL) {
+    if ((conn=make_connection(cm, addr_array, err_no)) == NULL) {
        logError("file: "__FILE__", line: %d, "
                "%s server id: %d, address count: %d, get_server_connection fail",
                __LINE__, cm->module_name, server->id, addr_array->count);
@ -98,7 +98,7 @@ static ConnectionInfo *get_server_connection(SFConnectionManager *cm,
 }

 static ConnectionInfo *get_connection(SFConnectionManager *cm,
-        const int group_index, const bool shared, int *err_no)
+        const int group_index, int *err_no)
 {
    SFCMServerArray *server_array;
    ConnectionInfo *conn;
@ -110,7 +110,7 @@ static ConnectionInfo *get_connection(SFConnectionManager *cm,
    server_hash_code = rand();
    server_index = server_hash_code % server_array->count;
    if ((conn=make_connection(cm, server_array->servers[server_index].
-                    addr_array, shared, err_no)) != NULL)
+                    addr_array, err_no)) != NULL)
    {
        return conn;
    }
@ -122,7 +122,7 @@ static ConnectionInfo *get_connection(SFConnectionManager *cm,
            }

            if ((conn=make_connection(cm, server_array->servers[i].
-                            addr_array, shared, err_no)) != NULL)
+                            addr_array, err_no)) != NULL)
            {
                return conn;
            }
@ -176,7 +176,7 @@ static inline bool alive_array_cas(SFConnectionManager *cm,
        push_to_detect_queue(cm, group, new_alives);
        fast_mblock_delay_free_object(&cm->sptr_array_allocator, old_alives,
                (cm->common_cfg->connect_timeout + cm->common_cfg->
-                 network_timeout) * group->all.count * 4);
+                 network_timeout) * group->all.count);
        return true;
    } else {
        fast_mblock_free_object(&cm->sptr_array_allocator, new_alives);
@ -225,7 +225,7 @@ static int remove_from_alives(SFConnectionManager *cm,
 }

 static inline ConnectionInfo *make_master_connection(SFConnectionManager *cm,
-        SFCMConnGroupEntry *group, const bool shared, int *err_no)
+        SFCMConnGroupEntry *group, int *err_no)
 {
    SFCMServerEntry *master;
    ConnectionInfo *conn;
@ -234,7 +234,7 @@ static inline ConnectionInfo *make_master_connection(SFConnectionManager *cm,
    master = (SFCMServerEntry *)FC_ATOMIC_GET(group->master);
    if (master != NULL) {
        if ((conn=make_connection(cm, master->addr_array,
-                        shared, err_no)) != NULL)
+                        err_no)) != NULL)
        {
            alives = (SFCMServerPtrArray *)FC_ATOMIC_GET(group->alives);
            set_connection_params(conn, master, alives);
@ -254,12 +254,12 @@ static inline ConnectionInfo *make_master_connection(SFConnectionManager *cm,

 static inline ConnectionInfo *make_readable_connection(SFConnectionManager *cm,
        SFCMConnGroupEntry *group, SFCMServerPtrArray *alives,
-        const int index, const bool shared, int *err_no)
+        const int index, int *err_no)
 {
    ConnectionInfo *conn;

    if ((conn=make_connection(cm, alives->servers[index]->
-                    addr_array, shared, err_no)) == NULL)
+                    addr_array, err_no)) == NULL)
    {
        remove_from_alives(cm, group, alives, alives->servers[index]);
    } else {
@ -270,7 +270,7 @@ static inline ConnectionInfo *make_readable_connection(SFConnectionManager *cm,
 }

 static ConnectionInfo *get_master_connection(SFConnectionManager *cm,
-        const int group_index, const bool shared, int *err_no)
+        const int group_index, int *err_no)
 {
    SFCMConnGroupEntry *group;
    ConnectionInfo *conn;
@ -283,7 +283,7 @@ static ConnectionInfo *get_master_connection(SFConnectionManager *cm,
            &cm->common_cfg->net_retry_cfg.connect);
    retry_count = 0;
    while (1) {
-        if ((conn=make_master_connection(cm, group, shared, err_no)) != NULL) {
+        if ((conn=make_master_connection(cm, group, err_no)) != NULL) {
            return conn;
        }

@ -313,7 +313,7 @@ static ConnectionInfo *get_master_connection(SFConnectionManager *cm,
 }

 static ConnectionInfo *get_readable_connection(SFConnectionManager *cm,
-        const int group_index, const bool shared, int *err_no)
+        const int group_index, int *err_no)
 {
    SFCMConnGroupEntry *group;
    SFCMServerPtrArray *alives;
@ -326,7 +326,7 @@ static ConnectionInfo *get_readable_connection(SFConnectionManager *cm,
    if ((cm->common_cfg->read_rule == sf_data_read_rule_master_only) ||
            (group->all.count == 1))
    {
-        return get_master_connection(cm, group_index, shared, err_no);
+        return get_master_connection(cm, group_index, err_no);
    }

    sf_init_net_retry_interval_context(&net_retry_ctx,
@ -338,14 +338,14 @@ static ConnectionInfo *get_readable_connection(SFConnectionManager *cm,
        if (alives->count > 0) {
            index = rand() % alives->count;
            if ((conn=make_readable_connection(cm, group, alives,
-                            index, shared, err_no)) != NULL)
+                            index, err_no)) != NULL)
            {
                return conn;
            }
        }

        if (cm->common_cfg->read_rule == sf_data_read_rule_slave_first) {
-            if ((conn=make_master_connection(cm, group, shared, err_no)) != NULL) {
+            if ((conn=make_master_connection(cm, group, err_no)) != NULL) {
                return conn;
            }
        }
@ -400,12 +400,11 @@ static void close_connection(SFConnectionManager *cm, ConnectionInfo *conn)
 }

 static ConnectionInfo *get_leader_connection(SFConnectionManager *cm,
-        FCServerInfo *server, const bool shared, int *err_no)
+        FCServerInfo *server, int *err_no)
 {
    ConnectionInfo *conn;
    SFClientServerEntry leader;
    SFNetRetryIntervalContext net_retry_ctx;
-    char formatted_ip[FORMATTED_IP_SIZE];
    int i;
    int connect_fails;

@ -416,7 +415,7 @@ static ConnectionInfo *get_leader_connection(SFConnectionManager *cm,
    while (1) {
        do {
            if ((conn=get_server_connection(cm, server,
-                            shared, err_no)) == NULL)
+                            err_no)) == NULL)
            {
                connect_fails++;
                break;
@ -433,9 +432,8 @@ static ConnectionInfo *get_leader_connection(SFConnectionManager *cm,
                return conn;
            }
            release_connection(cm, conn);
-
            if ((conn=get_spec_connection(cm, &leader.conn,
-                            shared, err_no)) == NULL)
+                            err_no)) == NULL)
            {
                if (cm->server_cfg != NULL) {
                    FCServerInfo *ls;
@ -446,7 +444,7 @@ static ConnectionInfo *get_leader_connection(SFConnectionManager *cm,
                                address_array.count > 1)
                        {
                            if ((conn=get_server_connection(cm, ls,
-                                            shared, err_no)) != NULL)
+                                            err_no)) != NULL)
                            {
                                return conn;
                            }
@ -469,11 +467,10 @@ static ConnectionInfo *get_leader_connection(SFConnectionManager *cm,
                connect.times, ++i, *err_no);
    }

-    format_ip_address(server->group_addrs[cm->server_group_index].
-            address_array.addrs[0]->conn.ip_addr, formatted_ip);
    logWarning("file: "__FILE__", line: %d, "
            "%s get_leader_connection fail, server id: %d, %s:%u, errno: %d",
-            __LINE__, cm->module_name, server->id, formatted_ip,
+            __LINE__, cm->module_name, server->id, server->group_addrs
+            [cm->server_group_index].  address_array.addrs[0]->conn.ip_addr,
            server->group_addrs[cm->server_group_index].address_array.
            addrs[0]->conn.port, *err_no);
    return NULL;
@ -530,19 +527,12 @@ int sf_connection_manager_init_ex(SFConnectionManager *cm,
    } extra_params;
    FCServerGroupInfo *server_group;

-    int htable_capacity;
+    int htable_init_capacity;
    int result;

-    if (server_count <= 4) {
-        htable_capacity = 16;
-    } else if (server_count <= 16) {
-        htable_capacity = 64;
-    } else if (server_count <= 32) {
-        htable_capacity = 128;
-    } else if (server_count < 64) {
-        htable_capacity = 256;
-    } else {
-        htable_capacity = 4 * server_count;
+    htable_init_capacity = 4 * server_count;
+    if (htable_init_capacity < 256) {
+        htable_init_capacity = 256;
    }

    if ((server_group=fc_server_get_group_by_index(server_cfg,
@ -562,7 +552,7 @@ int sf_connection_manager_init_ex(SFConnectionManager *cm,
        extra_params.ptr = &extra_params.holder;
    }
    if ((result=conn_pool_init_ex1(&cm->cpool, common_cfg->connect_timeout,
-                    max_count_per_entry, max_idle_time, htable_capacity,
+                    max_count_per_entry, max_idle_time, htable_init_capacity,
                    connect_done_callback, args,
                    sf_cm_validate_connection_callback, cm,
                    sizeof(SFConnectionParameters),
@ -778,7 +768,6 @@ static int do_get_group_servers(SFConnectionManager *cm,
 static int get_group_servers_by_active(SFConnectionManager *cm,
        SFCMConnGroupEntry *group)
 {
-    const bool shared = true;
    SFCMServerPtrArray *alives;
    SFCMServerEntry **server;
    SFCMServerEntry **end;
@ -794,7 +783,7 @@ static int get_group_servers_by_active(SFConnectionManager *cm,
    end = alives->servers + alives->count;
    for (server=alives->servers; server<end; server++) {
        if ((conn=make_connection(cm, (*server)->addr_array,
-                        shared, &result)) == NULL)
+                        &result)) == NULL)
        {
            continue;
        }
@ -812,7 +801,6 @@ static int get_group_servers_by_active(SFConnectionManager *cm,
 static int get_group_servers_by_all(SFConnectionManager *cm,
        SFCMConnGroupEntry *group)
 {
-    const bool shared = true;
    SFCMServerEntry *server;
    SFCMServerEntry *end;
    ConnectionInfo *conn;
@ -830,7 +818,7 @@ static int get_group_servers_by_all(SFConnectionManager *cm,
        }

        if ((conn=make_connection(cm, server->addr_array,
-                        shared, &result)) == NULL)
+                        &result)) == NULL)
        {
            continue;
        }
--- a/src/sf_connection_manager.h
+++ b/src/sf_connection_manager.h
@ -26,17 +26,16 @@
 struct sf_connection_manager;

 typedef ConnectionInfo *(*sf_get_connection_func)(
-        struct sf_connection_manager *cm, const int group_index,
-        const bool shared, int *err_no);
+        struct sf_connection_manager *cm,
+        const int group_index, int *err_no);

 typedef ConnectionInfo *(*sf_get_server_connection_func)(
        struct sf_connection_manager *cm,
-        FCServerInfo *server, const bool shared, int *err_no);
+        FCServerInfo *server, int *err_no);

 typedef ConnectionInfo *(*sf_get_spec_connection_func)(
        struct sf_connection_manager *cm,
-        const ConnectionInfo *target,
-        const bool shared, int *err_no);
+        const ConnectionInfo *target, int *err_no);

 typedef void (*sf_release_connection_func)(
        struct sf_connection_manager *cm, ConnectionInfo *conn);
--- a/src/sf_define.h
+++ b/src/sf_define.h
@ -20,8 +20,8 @@

 #include "fastcommon/sockopt.h"

-#define SF_DEFAULT_CONNECT_TIMEOUT   10
-#define SF_DEFAULT_NETWORK_TIMEOUT   60
+#define SF_DEFAULT_CONNECT_TIMEOUT    2
+#define SF_DEFAULT_NETWORK_TIMEOUT   10

 #define SF_DEF_THREAD_STACK_SIZE  (256 * 1024)
 #define SF_MIN_THREAD_STACK_SIZE  (64 * 1024)
@ -96,8 +96,6 @@
 #define SF_BINLOG_SOURCE_USER        'U'  //by user call
 #define SF_BINLOG_SOURCE_REPLAY      'R'  //by binlog replay

-#define SF_LOG_SCHEDULE_ENTRIES_COUNT 3
-
 #ifdef __cplusplus
 extern "C" {
 #endif
--- a/src/sf_file_writer.c
+++ b/src/sf_file_writer.c
@ -34,108 +34,49 @@
 #include "sf_func.h"
 #include "sf_file_writer.h"

-#define BINLOG_INDEX_ITEM_START_INDEX_STR       "start_index"
-#define BINLOG_INDEX_ITEM_START_INDEX_LEN      \
-    (sizeof(BINLOG_INDEX_ITEM_START_INDEX_STR) - 1)
+#define BINLOG_INDEX_ITEM_START_INDEX       "start_index"
+#define BINLOG_INDEX_ITEM_CURRENT_WRITE     "current_write"
+#define BINLOG_INDEX_ITEM_CURRENT_COMPRESS  "current_compress"

-#define BINLOG_INDEX_ITEM_CURRENT_WRITE_STR     "current_write"
-#define BINLOG_INDEX_ITEM_CURRENT_WRITE_LEN      \
-    (sizeof(BINLOG_INDEX_ITEM_CURRENT_WRITE_STR) - 1)
+#define GET_BINLOG_FILENAME(writer) \
+    sprintf(writer->file.name, "%s/%s/%s"SF_BINLOG_FILE_EXT_FMT, \
+            writer->cfg.data_path, writer->cfg.subdir_name, \
+            writer->cfg.file_prefix, writer->binlog.last_index)

-#define BINLOG_INDEX_ITEM_CURRENT_COMPRESS_STR  "current_compress"
-#define BINLOG_INDEX_ITEM_CURRENT_COMPRESS_LEN      \
-    (sizeof(BINLOG_INDEX_ITEM_CURRENT_COMPRESS_STR) - 1)
+#define GET_BINLOG_INDEX_FILENAME_EX(data_path,    \
+        subdir_name, file_prefix, filename, size)  \
+    snprintf(filename, size, "%s/%s/%s_index.dat", \
+            data_path, subdir_name, file_prefix)

-static inline void sf_file_writer_get_binlog_filename(SFFileWriterInfo *writer)
-{
-    sf_file_writer_get_filename_ex(
-            writer->cfg.data_path, writer->cfg.subdir_name,
-            writer->cfg.file_prefix, writer->binlog.last_index,
-            writer->file.name.str, writer->file.name.size);
-}
-
-static inline void sf_file_writer_get_index_filename_ex(
-        const char *data_path, const char *subdir_name,
-        const char *file_prefix, const int file_prefix_len,
-        char *filename, const int size)
-{
-#define INDEX_FILENAME_AFFIX_STR "_index.dat"
-#define INDEX_FILENAME_AFFIX_LEN (sizeof(INDEX_FILENAME_AFFIX_STR) - 1)
-
-    char *p;
-    int data_path_len;
-    int subdir_name_len;
-
-    data_path_len = strlen(data_path);
-    subdir_name_len = strlen(subdir_name);
-    if (data_path_len + 1 + subdir_name_len + 1 + file_prefix_len +
-            INDEX_FILENAME_AFFIX_LEN >= size)
-    {
-        *filename = '\0';
-        return;
-    }
-
-    memcpy(filename, data_path, data_path_len);
-    p = filename + data_path_len;
-    *p++ = '/';
-
-    memcpy(p, subdir_name, subdir_name_len);
-    p += subdir_name_len;
-    *p++ = '/';
-
-    memcpy(p, file_prefix, file_prefix_len);
-    p += file_prefix_len;
-
-    memcpy(p, INDEX_FILENAME_AFFIX_STR, INDEX_FILENAME_AFFIX_LEN);
-    p += INDEX_FILENAME_AFFIX_LEN;
-    *p = '\0';
-}
+#define GET_BINLOG_INDEX_FILENAME(writer, filename, size) \
+    GET_BINLOG_INDEX_FILENAME_EX(writer->cfg.data_path,   \
+            writer->cfg.subdir_name, writer->cfg.file_prefix, filename, size)

 const char *sf_file_writer_get_index_filename(const char *data_path,
        const char *subdir_name, char *filename, const int size)
 {
-    sf_file_writer_get_index_filename_ex(data_path, subdir_name,
-            SF_BINLOG_FILE_PREFIX_STR, SF_BINLOG_FILE_PREFIX_LEN,
-            filename, size);
+    GET_BINLOG_INDEX_FILENAME_EX(data_path, subdir_name,
+            SF_BINLOG_FILE_PREFIX, filename, size);
    return filename;
 }

-int sf_file_writer_write_to_binlog_index_file_ex(const char *data_path,
-        const char *subdir_name, const char *file_prefix,
-        const int start_index, const int last_index,
-        const int compress_index)
+static int write_to_binlog_index_file(SFFileWriterInfo *writer)
 {
    char filename[PATH_MAX];
    char buff[256];
-    char *p;
    int result;
    int len;

-    sf_file_writer_get_index_filename_ex(data_path, subdir_name, file_prefix,
-            strlen(file_prefix), filename, sizeof(filename));
-    p = buff;
-    memcpy(p, BINLOG_INDEX_ITEM_START_INDEX_STR,
-            BINLOG_INDEX_ITEM_START_INDEX_LEN);
-    p += BINLOG_INDEX_ITEM_START_INDEX_LEN;
-    *p++ = '=';
-    p += fc_itoa(start_index, p);
-    *p++ = '\n';
-
-    memcpy(p, BINLOG_INDEX_ITEM_CURRENT_WRITE_STR,
-            BINLOG_INDEX_ITEM_CURRENT_WRITE_LEN);
-    p += BINLOG_INDEX_ITEM_CURRENT_WRITE_LEN;
-    *p++ = '=';
-    p += fc_itoa(last_index, p);
-    *p++ = '\n';
-
-    memcpy(p, BINLOG_INDEX_ITEM_CURRENT_COMPRESS_STR,
-            BINLOG_INDEX_ITEM_CURRENT_COMPRESS_LEN);
-    p += BINLOG_INDEX_ITEM_CURRENT_COMPRESS_LEN;
-    *p++ = '=';
-    p += fc_itoa(compress_index, p);
-    *p++ = '\n';
-
-    len = p - buff;
+    GET_BINLOG_INDEX_FILENAME(writer, filename, sizeof(filename));
+    len = sprintf(buff, "%s=%d\n"
+            "%s=%d\n"
+            "%s=%d\n",
+            BINLOG_INDEX_ITEM_START_INDEX,
+            writer->binlog.start_index,
+            BINLOG_INDEX_ITEM_CURRENT_WRITE,
+            writer->binlog.last_index,
+            BINLOG_INDEX_ITEM_CURRENT_COMPRESS,
+            writer->binlog.compress_index);
    if ((result=safeWriteToFile(filename, buff, len)) != 0) {
        logError("file: "__FILE__", line: %d, "
                "write to file \"%s\" fail, errno: %d, error info: %s",
@ -145,14 +86,6 @@ int sf_file_writer_write_to_binlog_index_file_ex(const char *data_path,
    return result;
 }

-static inline int write_to_binlog_index_file(SFFileWriterInfo *writer)
-{
-    return sf_file_writer_write_to_binlog_index_file_ex(
-            writer->cfg.data_path, writer->cfg.subdir_name,
-            writer->cfg.file_prefix, writer->binlog.start_index,
-            writer->binlog.last_index, writer->binlog.compress_index);
-}
-
 static int get_binlog_info_from_file(const char *data_path,
        const char *subdir_name, int *start_index,
        int *last_index, int *compress_index)
@ -161,8 +94,8 @@ static int get_binlog_info_from_file(const char *data_path,
    IniContext ini_context;
    int result;

-    sf_file_writer_get_index_filename_ex(data_path, subdir_name,
-            SF_BINLOG_FILE_PREFIX_STR, SF_BINLOG_FILE_PREFIX_LEN,
+    GET_BINLOG_INDEX_FILENAME_EX(data_path,
+            subdir_name, SF_BINLOG_FILE_PREFIX,
            full_filename, sizeof(full_filename));
    if (access(full_filename, F_OK) != 0) {
        return errno != 0 ? errno : EPERM;
@ -176,13 +109,13 @@ static int get_binlog_info_from_file(const char *data_path,
    }

    *start_index = iniGetIntValue(NULL,
-            BINLOG_INDEX_ITEM_START_INDEX_STR,
+            BINLOG_INDEX_ITEM_START_INDEX,
            &ini_context, 0);
    *last_index = iniGetIntValue(NULL,
-            BINLOG_INDEX_ITEM_CURRENT_WRITE_STR,
+            BINLOG_INDEX_ITEM_CURRENT_WRITE,
            &ini_context, 0);
    *compress_index = iniGetIntValue(NULL,
-            BINLOG_INDEX_ITEM_CURRENT_COMPRESS_STR,
+            BINLOG_INDEX_ITEM_CURRENT_COMPRESS,
            &ini_context, 0);

    iniFreeContext(&ini_context);
@ -232,14 +165,14 @@ static int open_writable_binlog(SFFileWriterInfo *writer)
        close(writer->file.fd);
    }

-    sf_file_writer_get_binlog_filename(writer);
-    writer->file.fd = open(writer->file.name.str, O_WRONLY |
+    GET_BINLOG_FILENAME(writer);
+    writer->file.fd = open(writer->file.name, O_WRONLY |
            O_CREAT | O_APPEND | O_CLOEXEC, 0644);
    if (writer->file.fd < 0) {
        logError("file: "__FILE__", line: %d, "
                "open file \"%s\" fail, "
                "errno: %d, error info: %s",
-                __LINE__, writer->file.name.str,
+                __LINE__, writer->file.name,
                errno, STRERROR(errno));
        return errno != 0 ? errno : EACCES;
    }
@ -249,7 +182,7 @@ static int open_writable_binlog(SFFileWriterInfo *writer)
        logError("file: "__FILE__", line: %d, "
                "lseek file \"%s\" fail, "
                "errno: %d, error info: %s",
-                __LINE__, writer->file.name.str,
+                __LINE__, writer->file.name,
                errno, STRERROR(errno));
        return errno != 0 ? errno : EIO;
    }
@ -259,24 +192,23 @@ static int open_writable_binlog(SFFileWriterInfo *writer)

 static int open_next_binlog(SFFileWriterInfo *writer)
 {
-    sf_file_writer_get_binlog_filename(writer);
-    if (access(writer->file.name.str, F_OK) == 0) {
+    GET_BINLOG_FILENAME(writer);
+    if (access(writer->file.name, F_OK) == 0) {
        char bak_filename[PATH_MAX];
        char date_str[32];

-        formatDatetime(g_current_time, "%Y%m%d%H%M%S",
-                date_str, sizeof(date_str));
-        fc_combine_two_strings(writer->file.name.str,
-                date_str, '.', bak_filename);
-        if (rename(writer->file.name.str, bak_filename) == 0) {
+        snprintf(bak_filename, sizeof(bak_filename), "%s.%s",
+                writer->file.name, formatDatetime(g_current_time,
+                    "%Y%m%d%H%M%S", date_str, sizeof(date_str)));
+        if (rename(writer->file.name, bak_filename) == 0) {
            logWarning("file: "__FILE__", line: %d, "
                    "binlog file %s exist, rename to %s",
-                    __LINE__, writer->file.name.str, bak_filename);
+                    __LINE__, writer->file.name, bak_filename);
        } else {
            logError("file: "__FILE__", line: %d, "
                    "rename binlog %s to backup %s fail, "
                    "errno: %d, error info: %s",
-                    __LINE__, writer->file.name.str, bak_filename,
+                    __LINE__, writer->file.name, bak_filename,
                    errno, STRERROR(errno));
            return errno != 0 ? errno : EPERM;
        }
@ -295,7 +227,7 @@ static int do_write_to_file(SFFileWriterInfo *writer,
        logError("file: "__FILE__", line: %d, "
                "write to binlog file \"%s\" fail, "
                "errno: %d, error info: %s",
-                __LINE__, writer->file.name.str,
+                __LINE__, writer->file.name,
                result, STRERROR(result));
        return result;
    }
@ -304,23 +236,19 @@ static int do_write_to_file(SFFileWriterInfo *writer,
        if (fsync(writer->file.fd) != 0) {
            result = errno != 0 ? errno : EIO;
            logError("file: "__FILE__", line: %d, "
-                    "fsync to binlog file \"%s\" fail, errno: %d, "
-                    "error info: %s", __LINE__, writer->file.name.str,
+                    "fsync to binlog file \"%s\" fail, "
+                    "errno: %d, error info: %s",
+                    __LINE__, writer->file.name,
                    result, STRERROR(result));
            return result;
        }
    }

    writer->file.size += len;
-    if (writer->write_done_callback.func != NULL) {
-        writer->write_done_callback.func(writer,
-                writer->write_done_callback.args);
-    }
-
    return 0;
 }

-int sf_file_writer_direct_write(SFFileWriterInfo *writer,
+static int check_write_to_file(SFFileWriterInfo *writer,
        char *buff, const int len)
 {
    int result;
@ -339,7 +267,7 @@ int sf_file_writer_direct_write(SFFileWriterInfo *writer,
    if (result != 0) {
        logError("file: "__FILE__", line: %d, "
                "open binlog file \"%s\" fail",
-                __LINE__, writer->file.name.str);
+                __LINE__, writer->file.name);
        return result;
    }

@ -351,12 +279,12 @@ int sf_file_writer_flush(SFFileWriterInfo *writer)
    int result;
    int len;

-    len = SF_BINLOG_BUFFER_PRODUCER_DATA_LENGTH(writer->binlog_buffer);
+    len = SF_BINLOG_BUFFER_LENGTH(writer->binlog_buffer);
    if (len == 0) {
        return 0;
    }

-    if ((result=sf_file_writer_direct_write(writer, writer->
+    if ((result=check_write_to_file(writer, writer->
                    binlog_buffer.buff, len)) == 0)
    {
        if (writer->flags & SF_FILE_WRITER_FLAGS_WANT_DONE_VERSION) {
@ -364,30 +292,10 @@ int sf_file_writer_flush(SFFileWriterInfo *writer)
        }
    }

-    writer->binlog_buffer.data_end = writer->binlog_buffer.buff;
+    writer->binlog_buffer.end = writer->binlog_buffer.buff;
    return result;
 }

-int sf_file_writer_fsync(SFFileWriterInfo *writer)
-{
-    int result;
-
-    if ((result=sf_file_writer_flush(writer)) != 0) {
-        return result;
-    }
-
-    if (fsync(writer->file.fd) == 0) {
-        return 0;
-    } else {
-        result = errno != 0 ? errno : EIO;
-        logError("file: "__FILE__", line: %d, "
-                "fsync to binlog file \"%s\" fail, errno: %d, "
-                "error info: %s", __LINE__, writer->file.name.str,
-                result, STRERROR(result));
-        return result;
-    }
-}
-
 int sf_file_writer_get_indexes(SFFileWriterInfo *writer,
        int *start_index, int *last_index)
 {
@ -416,14 +324,14 @@ int sf_file_writer_deal_versioned_buffer(SFFileWriterInfo *writer,
    int result;

    if (buffer->length >= writer->binlog_buffer.size / 4) {
-        if (SF_BINLOG_BUFFER_PRODUCER_DATA_LENGTH(writer->binlog_buffer) > 0) {
+        if (SF_BINLOG_BUFFER_LENGTH(writer->binlog_buffer) > 0) {
            if ((result=sf_file_writer_flush(writer)) != 0) {
                return result;
            }
        }

-        if ((result=sf_file_writer_direct_write(writer, buffer->
-                        buff, buffer->length)) == 0)
+        if ((result=check_write_to_file(writer, buffer->buff,
+                        buffer->length)) == 0)
        {
            if (writer->flags & SF_FILE_WRITER_FLAGS_WANT_DONE_VERSION) {
                writer->last_versions.pending = version;
@ -434,13 +342,13 @@ int sf_file_writer_deal_versioned_buffer(SFFileWriterInfo *writer,
    }

    if (writer->cfg.file_rotate_size > 0 && writer->file.size +
-            SF_BINLOG_BUFFER_PRODUCER_DATA_LENGTH(writer->binlog_buffer) +
+            SF_BINLOG_BUFFER_LENGTH(writer->binlog_buffer) +
            buffer->length > writer->cfg.file_rotate_size)
    {
        if ((result=sf_file_writer_flush(writer)) != 0) {
            return result;
        }
-    } else if (SF_BINLOG_BUFFER_PRODUCER_BUFF_REMAIN(
+    } else if (writer->binlog_buffer.size - SF_BINLOG_BUFFER_LENGTH(
                writer->binlog_buffer) < buffer->length)
    {
        if ((result=sf_file_writer_flush(writer)) != 0) {
@ -451,40 +359,16 @@ int sf_file_writer_deal_versioned_buffer(SFFileWriterInfo *writer,
    if (writer->flags & SF_FILE_WRITER_FLAGS_WANT_DONE_VERSION) {
        writer->last_versions.pending = version;
    }
-    memcpy(writer->binlog_buffer.data_end, buffer->buff, buffer->length);
-    writer->binlog_buffer.data_end += buffer->length;
+    memcpy(writer->binlog_buffer.end, buffer->buff, buffer->length);
+    writer->binlog_buffer.end += buffer->length;

    return 0;
 }

-int sf_file_writer_save_buffer_ex(SFFileWriterInfo *writer,
-        const int length, const bool flush)
-{
-    int result;
-
-    if (writer->cfg.file_rotate_size > 0 && writer->file.size +
-            SF_BINLOG_BUFFER_PRODUCER_DATA_LENGTH(writer->binlog_buffer) +
-            length > writer->cfg.file_rotate_size)
-    {
-        if ((result=sf_file_writer_flush(writer)) != 0) {
-            return result;
-        }
-    }
-
-    writer->binlog_buffer.data_end += length;
-    if (flush || SF_BINLOG_BUFFER_PRODUCER_BUFF_REMAIN(writer->
-                binlog_buffer) < writer->cfg.max_record_size)
-    {
-        return sf_file_writer_flush(writer);
-    } else {
-        return 0;
-    }
-}
-
 int sf_file_writer_init(SFFileWriterInfo *writer, const char *data_path,
        const char *subdir_name, const char *file_prefix,
-        const int max_record_size, const int buffer_size,
-        const int64_t file_rotate_size, const bool call_fsync)
+        const int buffer_size, const int64_t file_rotate_size,
+        const bool call_fsync)
 {
    int result;
    int path_len;
@ -495,18 +379,17 @@ int sf_file_writer_init(SFFileWriterInfo *writer, const char *data_path,
    writer->last_versions.pending = 0;
    writer->last_versions.done = 0;
    writer->flags = 0;
-    sf_file_writer_set_write_done_callback(writer, NULL, NULL);
    if ((result=sf_binlog_buffer_init(&writer->
                    binlog_buffer, buffer_size)) != 0)
    {
        return result;
    }

-    writer->cfg.max_record_size = max_record_size;
    writer->cfg.call_fsync = call_fsync;
    writer->cfg.file_rotate_size = file_rotate_size;
    writer->cfg.data_path = data_path;
-    path_len = fc_combine_full_filepath(data_path, subdir_name, filepath);
+    path_len = snprintf(filepath, sizeof(filepath),
+            "%s/%s", data_path, subdir_name);
    if ((result=fc_check_mkdir_ex(filepath, 0775, &create)) != 0) {
        return result;
    }
@ -515,11 +398,14 @@ int sf_file_writer_init(SFFileWriterInfo *writer, const char *data_path,
    }

    writer->file.fd = -1;
-    fc_safe_strcpy(writer->cfg.subdir_name, subdir_name);
-    fc_safe_strcpy(writer->cfg.file_prefix, file_prefix);
-    writer->file.name.size = path_len + 32;
-    writer->file.name.str = (char *)fc_malloc(writer->file.name.size);
-    if (writer->file.name.str == NULL) {
+    snprintf(writer->cfg.subdir_name,
+            sizeof(writer->cfg.subdir_name),
+            "%s", subdir_name);
+    snprintf(writer->cfg.file_prefix,
+            sizeof(writer->cfg.file_prefix),
+            "%s", file_prefix);
+    writer->file.name = (char *)fc_malloc(path_len + 32);
+    if (writer->file.name == NULL) {
        return ENOMEM;
    }

@ -540,9 +426,9 @@ void sf_file_writer_destroy(SFFileWriterInfo *writer)
        close(writer->file.fd);
        writer->file.fd = -1;
    }
-    if (writer->file.name.str != NULL) {
-        free(writer->file.name.str);
-        writer->file.name.str = NULL;
+    if (writer->file.name != NULL) {
+        free(writer->file.name);
+        writer->file.name = NULL;
    }
    sf_binlog_buffer_destroy(&writer->binlog_buffer);
 }
@ -686,22 +572,3 @@ int sf_file_writer_get_last_lines(const char *data_path,

    return 0;
 }
-
-int sf_file_writer_get_last_line(const char *data_path,
-        const char *subdir_name, char *buff,
-        const int buff_size, int *length)
-{
-    int result;
-    int last_index;
-    int count = 1;
-
-    if ((result=sf_file_writer_get_binlog_last_index(data_path,
-                    subdir_name, &last_index)) != 0)
-    {
-        *length = 0;
-        return result;
-    }
-
-    return sf_file_writer_get_last_lines(data_path, subdir_name,
-            last_index, buff, buff_size, &count, length);
-}
--- a/src/sf_file_writer.h
+++ b/src/sf_file_writer.h
@ -24,24 +24,20 @@
 #define SF_FILE_WRITER_FLAGS_WANT_DONE_VERSION  1

 #define SF_BINLOG_SUBDIR_NAME_SIZE     128
-#define SF_BINLOG_FILE_PREFIX_STR_SIZE 64
+#define SF_BINLOG_FILE_PREFIX_SIZE      64
 #define SF_BINLOG_DEFAULT_ROTATE_SIZE  (1024 * 1024 * 1024)
 #define SF_BINLOG_NEVER_ROTATE_FILE    0
-#define SF_BINLOG_FILE_PREFIX_STR      "binlog"
-#define SF_BINLOG_FILE_PREFIX_LEN      (sizeof(SF_BINLOG_FILE_PREFIX_STR) - 1)
-#define SF_BINLOG_FILE_EXT_LEN 6
-#define SF_BINLOG_FILE_EXT_FMT ".%0"FC_MACRO_TOSTRING(SF_BINLOG_FILE_EXT_LEN)"d"
+#define SF_BINLOG_FILE_PREFIX          "binlog"
+#define SF_BINLOG_FILE_EXT_FMT         ".%06d"

-struct sf_file_writer_info;
-
-typedef void (*sf_file_write_done_callback)(
-        struct sf_file_writer_info *writer, void *args);
+#define SF_BINLOG_BUFFER_LENGTH(buffer) ((buffer).end - (buffer).buff)
+#define SF_BINLOG_BUFFER_REMAIN(buffer) ((buffer).end - (buffer).current)

 typedef struct sf_file_writer_info {
    struct {
        const char *data_path;
        char subdir_name[SF_BINLOG_SUBDIR_NAME_SIZE];
-        char file_prefix[SF_BINLOG_FILE_PREFIX_STR_SIZE];
+        char file_prefix[SF_BINLOG_FILE_PREFIX_SIZE];
        int64_t file_rotate_size;
        int max_record_size;
        bool call_fsync;
@ -55,11 +51,8 @@ typedef struct sf_file_writer_info {

    struct {
        int fd;
-        int64_t size;  //file size
-        struct {
-            char *str;
-            int size;
-        } name;
+        int64_t size;
+        char *name;
    } file;

    int64_t total_count;
@ -70,12 +63,6 @@ typedef struct sf_file_writer_info {
        int64_t pending;
        volatile int64_t done;
    } last_versions;
-
-    struct {
-        sf_file_write_done_callback func;
-        void *args;
-    } write_done_callback;
-
 } SFFileWriterInfo;

 #ifdef __cplusplus
@ -84,14 +71,11 @@ extern "C" {

 int sf_file_writer_init(SFFileWriterInfo *writer, const char *data_path,
        const char *subdir_name, const char *file_prefix,
-        const int max_record_size, const int buffer_size,
-        const int64_t file_rotate_size, const bool call_fsync);
+        const int buffer_size, const int64_t file_rotate_size,
+        const bool call_fsync);

 void sf_file_writer_destroy(SFFileWriterInfo *writer);

-int sf_file_writer_direct_write(SFFileWriterInfo *writer,
-        char *buff, const int len);
-
 int sf_file_writer_deal_versioned_buffer(SFFileWriterInfo *writer,
        BufferInfo *buffer, const int64_t version);

@ -100,51 +84,12 @@ int sf_file_writer_deal_versioned_buffer(SFFileWriterInfo *writer,

 int sf_file_writer_flush(SFFileWriterInfo *writer);

-int sf_file_writer_fsync(SFFileWriterInfo *writer);
-
-#define SF_FILE_WRITER_DATA_END_BUFF(writer) (writer)->binlog_buffer.data_end
-#define SF_FILE_WRITER_CURRENT_DATA_VERSION(writer) \
-    (writer)->last_versions.pending
-#define SF_FILE_WRITER_NEXT_DATA_VERSION(writer) \
-    ++((writer)->last_versions.pending)
-
-int sf_file_writer_save_buffer_ex(SFFileWriterInfo *writer,
-        const int length, const bool flush);
-
-static inline int sf_file_writer_save_buffer(
-        SFFileWriterInfo *writer, const int length)
-{
-    const bool flush = false;
-    return sf_file_writer_save_buffer_ex(writer, length, flush);
-}
-
-static inline int sf_file_writer_flush_buffer(
-        SFFileWriterInfo *writer, const int length)
-{
-    const bool flush = true;
-    return sf_file_writer_save_buffer_ex(writer, length, flush);
-}
-
 static inline void sf_file_writer_set_flags(
        SFFileWriterInfo *writer, const short flags)
 {
    writer->flags = flags;
 }

-static inline void sf_file_writer_set_call_fsync(
-        SFFileWriterInfo *writer, const bool call_fsync)
-{
-    writer->cfg.call_fsync = call_fsync;
-}
-
-static inline void sf_file_writer_set_write_done_callback (
-        SFFileWriterInfo *writer, sf_file_write_done_callback callback,
-        void *args)
-{
-    writer->write_done_callback.func = callback;
-    writer->write_done_callback.args = args;
-}
-
 static inline int64_t sf_file_writer_get_last_version_ex(
        SFFileWriterInfo *writer, const int log_level)
 {
@ -227,8 +172,7 @@ static inline const char *sf_file_writer_get_filepath(
        const char *data_path, const char *subdir_name,
        char *filepath, const int size)
 {
-    fc_get_full_filepath_ex(data_path, strlen(data_path),
-            subdir_name, strlen(subdir_name), filepath, size);
+    snprintf(filepath, size, "%s/%s", data_path, subdir_name);
    return filepath;
 }

@ -236,42 +180,16 @@ static inline const char *sf_file_writer_get_filename_ex(
        const char *data_path, const char *subdir_name,
        const char *file_prefix, const int binlog_index,
        char *filename, const int size)
-{
-    char *p;
-    int data_path_len;
-    int subdir_name_len;
-    int file_prefix_len;
-
-    data_path_len = strlen(data_path);
-    subdir_name_len = strlen(subdir_name);
-    file_prefix_len = strlen(file_prefix);
-    if (data_path_len + subdir_name_len + file_prefix_len +
-            4 + SF_BINLOG_FILE_EXT_LEN >= size)
 {
    snprintf(filename, size, "%s/%s/%s"SF_BINLOG_FILE_EXT_FMT,
            data_path, subdir_name, file_prefix, binlog_index);
    return filename;
 }

-    p = filename;
-    memcpy(p, data_path, data_path_len);
-    p += data_path_len;
-    *p++ = '/';
-    memcpy(p, subdir_name, subdir_name_len);
-    p += subdir_name_len;
-    *p++ = '/';
-    memcpy(p, file_prefix, file_prefix_len);
-    p += file_prefix_len;
-    *p++ = '.';
-    fc_ltostr_ex(binlog_index, p, SF_BINLOG_FILE_EXT_LEN);
-
-    return filename;
-}
-
 #define sf_file_writer_get_filename(data_path, subdir_name, \
        binlog_index, filename, size) \
    sf_file_writer_get_filename_ex(data_path, subdir_name, \
-        SF_BINLOG_FILE_PREFIX_STR, binlog_index, filename, size)
+        SF_BINLOG_FILE_PREFIX, binlog_index, filename, size)

 const char *sf_file_writer_get_index_filename(const char *data_path,
        const char *subdir_name, char *filename, const int size);
@ -282,40 +200,10 @@ int sf_file_writer_set_binlog_start_index(SFFileWriterInfo *writer,
 int sf_file_writer_set_binlog_write_index(SFFileWriterInfo *writer,
        const int last_index);

-static inline int sf_file_writer_rotate_file(SFFileWriterInfo *writer)
-{
-    int last_index;
-    last_index = sf_file_writer_get_current_write_index(writer);
-    return sf_file_writer_set_binlog_write_index(writer, last_index + 1);
-}
-
 int sf_file_writer_get_last_lines(const char *data_path,
        const char *subdir_name, const int current_write_index,
        char *buff, const int buff_size, int *count, int *length);

-static inline int sf_file_writer_get_last_line_ex(const char *data_path,
-        const char *subdir_name, const int current_write_index,
-        char *buff, const int buff_size, int *length)
-{
-    int count = 1;
-    return sf_file_writer_get_last_lines(data_path, subdir_name,
-            current_write_index, buff, buff_size, &count, length);
-}
-
-int sf_file_writer_get_last_line(const char *data_path,
-        const char *subdir_name, char *buff,
-        const int buff_size, int *length);
-
-int sf_file_writer_write_to_binlog_index_file_ex(const char *data_path,
-        const char *subdir_name, const char *file_prefix,
-        const int start_index, const int last_index,
-        const int compress_index);
-
-#define sf_file_writer_write_to_binlog_index_file(data_path,  \
-        subdir_name, start_index, last_index) \
-    sf_file_writer_write_to_binlog_index_file_ex(data_path, subdir_name, \
-            SF_BINLOG_FILE_PREFIX_STR, start_index, last_index, 0)
-
 #ifdef __cplusplus
 }
 #endif
--- a/src/sf_func.c
+++ b/src/sf_func.c
@ -38,7 +38,7 @@ int sf_connect_to_server(const char *ip_addr, const int port, int *sock)
    if(*sock < 0) {
        return errno != 0 ? errno : ENOMEM;
    }
-    tcpsetserveropt(*sock, g_sf_global_vars.net_buffer_cfg.network_timeout);
+    tcpsetserveropt(*sock, g_sf_global_vars.network_timeout);

    if ((result=tcpsetnonblockopt(*sock)) != 0) {
        close(*sock);
@ -47,8 +47,8 @@ int sf_connect_to_server(const char *ip_addr, const int port, int *sock)
    }
    FC_SET_CLOEXEC(*sock);

-    if ((result=connectserverbyip_nb(*sock, ip_addr, port, g_sf_global_vars.
-                    net_buffer_cfg.connect_timeout)) != 0)
+    if ((result=connectserverbyip_nb(*sock, ip_addr, port,
+                    g_sf_global_vars.connect_timeout)) != 0)
    {
        close(*sock);
        *sock = -1;
--- a/src/sf_func.h
+++ b/src/sf_func.h
@ -56,8 +56,7 @@ static inline int sf_binlog_buffer_init(SFBinlogBuffer *buffer, const int size)
        return ENOMEM;
    }

-    buffer->current = buffer->data_end = buffer->buff;
-    buffer->buff_end = buffer->buff + size;
+    buffer->current = buffer->end = buffer->buff;
    buffer->size = size;
    return 0;
 }
@ -66,8 +65,7 @@ static inline void sf_binlog_buffer_destroy(SFBinlogBuffer *buffer)
 {
    if (buffer->buff != NULL) {
        free(buffer->buff);
-        buffer->current = buffer->buff = NULL;
-        buffer->data_end = buffer->buff_end = NULL;
+        buffer->current = buffer->end = buffer->buff = NULL;
        buffer->size = 0;
    }
 }
--- a/src/sf_global.c
+++ b/src/sf_global.c
@ -37,106 +37,102 @@
 #include "sf_global.h"

 SFGlobalVariables g_sf_global_vars = {
+    SF_DEFAULT_CONNECT_TIMEOUT, SF_DEFAULT_NETWORK_TIMEOUT,
    {{'/', 't', 'm', 'p', '\0'}, false},
-    true, true, false, { SF_DEFAULT_CONNECT_TIMEOUT,
-        SF_DEFAULT_NETWORK_TIMEOUT, DEFAULT_MAX_CONNECTONS,
+    true, true, false, DEFAULT_MAX_CONNECTONS,
    SF_DEF_MAX_PACKAGE_SIZE, SF_DEF_MIN_BUFF_SIZE,
-    SF_DEF_MAX_BUFF_SIZE}, 0, SF_DEF_THREAD_STACK_SIZE, 0,
+    SF_DEF_MAX_BUFF_SIZE, 0, SF_DEF_THREAD_STACK_SIZE, 0,
    {false, 0, 0, {'\0'}, {'\0'}},
    {SF_DEF_SYNC_LOG_BUFF_INTERVAL, false},
    {0, 0}, NULL, {NULL, 0}
 };

-SFContext g_sf_context = {{'\0'}, NULL, 0, false, false, false,
-    sf_address_family_auto, {{AF_UNSPEC, {{true, fc_comm_type_sock},
-        {false, fc_comm_type_rdma}}},
+SFContext g_sf_context = {{'\0'}, NULL, 0, sf_address_family_auto,
+    {{AF_UNSPEC, {{true, fc_comm_type_sock}, {false, fc_comm_type_rdma}}},
        {AF_UNSPEC, {{true, fc_comm_type_sock}, {false, fc_comm_type_rdma}}}},
-    {DEFAULT_MAX_CONNECTONS, SF_DEF_MAX_PACKAGE_SIZE, SF_DEF_MIN_BUFF_SIZE,
-    SF_DEF_MAX_BUFF_SIZE}, 1, DEFAULT_WORK_THREADS, 0, true, true,
-    {false, 0, 0}, {sf_task_finish_clean_up}
+    1, DEFAULT_WORK_THREADS, 0, true, true, true, {false, 0, 0},
+    {sf_task_finish_clean_up}
 };

 static int load_network_parameters(IniFullContext *ini_ctx,
-        const char *max_pkg_size_item_nm, const int max_pkg_size_min_value,
-        const int fixed_buff_size, const int task_buffer_extra_size,
-        SFNetBufferConfig *net_buffer_cfg)
+        const char *max_pkg_size_item_nm, const int fixed_buff_size,
+        const int task_buffer_extra_size)
 {
+    int result;
    int padding_buff_size;
    char *pMinBuffSize;
    char *pMaxBuffSize;

-    net_buffer_cfg->connect_timeout = iniGetIntValueEx(ini_ctx->
+    g_sf_global_vars.connect_timeout = iniGetIntValueEx(ini_ctx->
            section_name, "connect_timeout", ini_ctx->context,
            SF_DEFAULT_CONNECT_TIMEOUT, true);
-    if (net_buffer_cfg->connect_timeout <= 0) {
-        net_buffer_cfg->connect_timeout = SF_DEFAULT_CONNECT_TIMEOUT;
+    if (g_sf_global_vars.connect_timeout <= 0) {
+        g_sf_global_vars.connect_timeout = SF_DEFAULT_CONNECT_TIMEOUT;
    }

-    net_buffer_cfg->network_timeout = iniGetIntValueEx(ini_ctx->
+    g_sf_global_vars.network_timeout = iniGetIntValueEx(ini_ctx->
            section_name, "network_timeout", ini_ctx->context,
            SF_DEFAULT_NETWORK_TIMEOUT, true);
-    if (net_buffer_cfg->network_timeout <= 0) {
-        net_buffer_cfg->network_timeout = SF_DEFAULT_NETWORK_TIMEOUT;
+    if (g_sf_global_vars.network_timeout <= 0) {
+        g_sf_global_vars.network_timeout = SF_DEFAULT_NETWORK_TIMEOUT;
    }

-    net_buffer_cfg->max_connections = iniGetIntValueEx(ini_ctx->section_name,
+    g_sf_global_vars.max_connections = iniGetIntValueEx(ini_ctx->section_name,
            "max_connections", ini_ctx->context, DEFAULT_MAX_CONNECTONS, true);
-    if (net_buffer_cfg->max_connections <= 0) {
-        net_buffer_cfg->max_connections = DEFAULT_MAX_CONNECTONS;
+    if (g_sf_global_vars.max_connections <= 0) {
+        g_sf_global_vars.max_connections = DEFAULT_MAX_CONNECTONS;
+    }
+
+    if ((result=set_rlimit(RLIMIT_NOFILE, g_sf_global_vars.
+                    max_connections)) != 0)
+    {
+        return result;
    }

    if (fixed_buff_size > 0) {
-        padding_buff_size = FC_MAX(fixed_buff_size, max_pkg_size_min_value) +
-            task_buffer_extra_size;
-        net_buffer_cfg->min_buff_size = padding_buff_size;
-        net_buffer_cfg->max_buff_size = padding_buff_size;
-        net_buffer_cfg->max_pkg_size = padding_buff_size;
+        padding_buff_size = fixed_buff_size + task_buffer_extra_size;
+        g_sf_global_vars.min_buff_size = padding_buff_size;
+        g_sf_global_vars.max_buff_size = padding_buff_size;
+        g_sf_global_vars.max_pkg_size = padding_buff_size;
        return 0;
    }

-    net_buffer_cfg->max_pkg_size = iniGetByteCorrectValueEx(ini_ctx,
+    g_sf_global_vars.max_pkg_size = iniGetByteCorrectValueEx(ini_ctx,
            max_pkg_size_item_nm, SF_DEF_MAX_PACKAGE_SIZE, 1, 8192,
            SF_MAX_NETWORK_BUFF_SIZE, true);
-    if (net_buffer_cfg->max_pkg_size < max_pkg_size_min_value) {
-        net_buffer_cfg->max_pkg_size = max_pkg_size_min_value;
-    }
-    if (task_buffer_extra_size > 0) {
-        net_buffer_cfg->max_pkg_size += task_buffer_extra_size;
-    }
-
    pMinBuffSize = iniGetStrValueEx(ini_ctx->section_name,
            "min_buff_size", ini_ctx->context, true);
    pMaxBuffSize = iniGetStrValueEx(ini_ctx->section_name,
            "max_buff_size", ini_ctx->context, true);
    if (pMinBuffSize == NULL || pMaxBuffSize == NULL) {
-        net_buffer_cfg->min_buff_size = net_buffer_cfg->max_pkg_size;
-        net_buffer_cfg->max_buff_size = net_buffer_cfg->max_pkg_size;
+        g_sf_global_vars.min_buff_size = g_sf_global_vars.max_pkg_size;
+        g_sf_global_vars.max_buff_size = g_sf_global_vars.max_pkg_size;
    } else {
-        net_buffer_cfg->min_buff_size = iniGetByteCorrectValueEx(ini_ctx,
+        g_sf_global_vars.min_buff_size = iniGetByteCorrectValueEx(ini_ctx,
            "min_buff_size", SF_DEF_MIN_BUFF_SIZE, 1, 4096,
            SF_MAX_NETWORK_BUFF_SIZE, true);
-        net_buffer_cfg->max_buff_size = iniGetByteCorrectValueEx(ini_ctx,
+        g_sf_global_vars.max_buff_size = iniGetByteCorrectValueEx(ini_ctx,
            "max_buff_size", SF_DEF_MAX_BUFF_SIZE, 1, 8192,
            SF_MAX_NETWORK_BUFF_SIZE, true);

-        if (task_buffer_extra_size > 0) {
-            net_buffer_cfg->min_buff_size += task_buffer_extra_size;
-            net_buffer_cfg->max_buff_size += task_buffer_extra_size;
+        if (g_sf_global_vars.max_buff_size < g_sf_global_vars.max_pkg_size) {
+            g_sf_global_vars.max_buff_size = g_sf_global_vars.max_pkg_size;
        }
-        if (net_buffer_cfg->max_buff_size < net_buffer_cfg->max_pkg_size) {
-            net_buffer_cfg->max_buff_size = net_buffer_cfg->max_pkg_size;
-        } else if (net_buffer_cfg->max_pkg_size <
-                net_buffer_cfg->max_buff_size)
-        {
-            net_buffer_cfg->max_pkg_size = net_buffer_cfg->max_buff_size;
-        }
-        if (net_buffer_cfg->max_buff_size < net_buffer_cfg->min_buff_size) {
+        if (g_sf_global_vars.max_buff_size < g_sf_global_vars.min_buff_size) {
            logWarning("file: "__FILE__", line: %d, "
                    "max_buff_size: %d < min_buff_size: %d, "
                    "set max_buff_size to min_buff_size", __LINE__,
-                    net_buffer_cfg->max_buff_size,
-                    net_buffer_cfg->min_buff_size);
-            net_buffer_cfg->max_buff_size = net_buffer_cfg->min_buff_size;
+                    g_sf_global_vars.max_buff_size,
+                    g_sf_global_vars.min_buff_size);
+            g_sf_global_vars.max_buff_size = g_sf_global_vars.min_buff_size;
+        }
+    }
+
+    if (task_buffer_extra_size > 0) {
+        g_sf_global_vars.min_buff_size += task_buffer_extra_size;
+        g_sf_global_vars.max_buff_size += task_buffer_extra_size;
+        if (g_sf_global_vars.max_pkg_size < g_sf_global_vars.max_buff_size) {
+            g_sf_global_vars.max_pkg_size = g_sf_global_vars.max_buff_size;
        }
    }

@ -221,7 +217,9 @@ int sf_load_slow_log_config_ex(IniFullContext *ini_ctx, LogContext *log_ctx,
    if (filename_prefix == NULL || *filename_prefix == '\0') {
        strcpy(slow_log_cfg->filename_prefix, "slow");
    } else {
-        fc_safe_strcpy(slow_log_cfg->filename_prefix, filename_prefix);
+        snprintf(slow_log_cfg->filename_prefix,
+                sizeof(slow_log_cfg->filename_prefix),
+                "%s", filename_prefix);
    }

    return 0;
@ -249,7 +247,6 @@ int sf_get_base_path_from_conf_file(const char *config_filename)
        }
    }

-    SF_G_BASE_PATH_LEN = strlen(SF_G_BASE_PATH_STR);
    SF_G_BASE_PATH_INITED = true;
    return 0;
 }
@ -271,7 +268,6 @@ int sf_load_global_base_path(IniFullContext *ini_ctx)
    }

    chopPath(SF_G_BASE_PATH_STR);
-    SF_G_BASE_PATH_LEN = strlen(SF_G_BASE_PATH_STR);
    if (!fileExists(SF_G_BASE_PATH_STR)) {
        if ((result=fc_check_mkdir_ex(SF_G_BASE_PATH_STR, 0775,
                        &SF_G_BASE_PATH_CREATED)) != 0)
@ -294,7 +290,6 @@ int sf_load_global_config_ex(const char *log_filename_prefix,
        const char *max_pkg_size_item_nm, const int fixed_buff_size,
        const int task_buffer_extra_size, const bool need_set_run_by)
 {
-    const int max_pkg_size_min_value = 0;
    int result;
    const char *old_section_name;
    char *pRunByGroup;
@ -310,15 +305,7 @@ int sf_load_global_config_ex(const char *log_filename_prefix,
    tcp_set_quick_ack(g_sf_global_vars.tcp_quick_ack);
    if (load_network_params) {
        if ((result=load_network_parameters(ini_ctx, max_pkg_size_item_nm,
-                        max_pkg_size_min_value, fixed_buff_size,
-                        task_buffer_extra_size, &g_sf_global_vars.
-                        net_buffer_cfg)) != 0)
-        {
-            return result;
-        }
-
-        if ((result=set_rlimit(RLIMIT_NOFILE, g_sf_global_vars.
-                        net_buffer_cfg.max_connections)) != 0)
+                        fixed_buff_size, task_buffer_extra_size)) != 0)
        {
            return result;
        }
@ -330,7 +317,9 @@ int sf_load_global_config_ex(const char *log_filename_prefix,
        *g_sf_global_vars.run_by.group = '\0';
    }
    else {
-        fc_safe_strcpy(g_sf_global_vars.run_by.group, pRunByGroup);
+        snprintf(g_sf_global_vars.run_by.group,
+                sizeof(g_sf_global_vars.run_by.group),
+                "%s", pRunByGroup);
    }
    if (*(g_sf_global_vars.run_by.group) == '\0') {
        g_sf_global_vars.run_by.gid = getegid();
@ -355,7 +344,9 @@ int sf_load_global_config_ex(const char *log_filename_prefix,
        *g_sf_global_vars.run_by.user = '\0';
    }
    else {
-        fc_safe_strcpy(g_sf_global_vars.run_by.user, pRunByUser);
+        snprintf(g_sf_global_vars.run_by.user,
+                sizeof(g_sf_global_vars.run_by.user),
+                "%s", pRunByUser);
    }
    if (*(g_sf_global_vars.run_by.user) == '\0') {
        g_sf_global_vars.run_by.uid = geteuid();
@ -425,8 +416,7 @@ int sf_load_config_ex(const char *log_filename_prefix,
    {
        return result;
    }
-    return sf_load_context_from_config_ex(&g_sf_context, config,
-            fixed_buff_size, task_buffer_extra_size);
+    return sf_load_context_from_config_ex(&g_sf_context, config);
 }

 #define API_PREFIX_NAME  "fast_rdma_"
@ -444,7 +434,7 @@ int sf_load_config_ex(const char *log_filename_prefix,

 #define LOAD_API(handler, fname)  LOAD_API_EX(handler, server_, fname)

-static int load_rdma_apis(SFContext *sf_context, SFNetworkHandler *handler)
+static int load_rdma_apis(SFNetworkHandler *handler)
 {
    const char *library = "libfastrdma.so";
    void *dlhandle;
@ -459,11 +449,7 @@ static int load_rdma_apis(SFContext *sf_context, SFNetworkHandler *handler)

    LOAD_API(handler, get_connection_size);
    LOAD_API(handler, init_connection);
-    if (sf_context->is_client) {
-        LOAD_API_EX(handler, client_, alloc_pd);
-    } else {
    LOAD_API(handler, alloc_pd);
-    }
    LOAD_API_EX(handler, , create_server);
    LOAD_API_EX(handler, , close_server);
    LOAD_API(handler, accept_connection);
@ -477,8 +463,8 @@ static int load_rdma_apis(SFContext *sf_context, SFNetworkHandler *handler)
    return 0;
 }

-static int init_network_handler(SFContext *sf_context,
-        SFNetworkHandler *handler, SFAddressFamilyHandler *fh)
+static int init_network_handler(SFNetworkHandler *handler,
+        SFAddressFamilyHandler *fh)
 {
    handler->fh = fh;
    handler->inner.handler = handler;
@ -503,7 +489,7 @@ static int init_network_handler(SFContext *sf_context,
    } else {
        handler->inner.id = NULL;
        handler->outer.id = NULL;
-        return load_rdma_apis(sf_context, handler);
+        return load_rdma_apis(handler);
    }
 }

@ -522,7 +508,7 @@ static void set_bind_address(const char *bind_addr, char *ipv4_bind_addr,
        return;
    }

-    fc_safe_strcpy(new_bind_addr, bind_addr);
+    snprintf(new_bind_addr, sizeof(new_bind_addr), "%s", bind_addr);
    count = splitEx(new_bind_addr, ',', cols, 2);
    for (i=0; i<count; i++) {
        ip_addr = cols[i];
@ -532,13 +518,9 @@ static void set_bind_address(const char *bind_addr, char *ipv4_bind_addr,
                ++ip_addr;
                len -= 2;
            }
-            if (len >= addr_size) {
-                len = addr_size - 1;
-            }
-            memcpy(ipv6_bind_addr, ip_addr, len);
-            *(ipv6_bind_addr + len) = '\0';
+            snprintf(ipv6_bind_addr, addr_size, "%.*s", len, ip_addr);
        } else {
-            fc_strlcpy(ipv4_bind_addr, ip_addr, addr_size);
+            snprintf(ipv4_bind_addr, addr_size, "%s", ip_addr);
        }
    }
 }
@ -657,8 +639,7 @@ static int load_address_family(SFContext *sf_context,
 }

 int sf_load_context_from_config_ex(SFContext *sf_context,
-        SFContextIniConfig *config, const int fixed_buff_size,
-        const int task_buffer_extra_size)
+        SFContextIniConfig *config)
 {
    SFAddressFamilyHandler *fh;
    SFNetworkHandler *sock_handler;
@ -670,10 +651,6 @@ int sf_load_context_from_config_ex(SFContext *sf_context,
    int inner_port;
    int outer_port;
    int port;
-#if IOEVENT_USE_URING
-    bool global_use_send_zc;
-    bool use_send_zc;
-#endif
    int i;
    int result;

@ -710,17 +687,6 @@ int sf_load_context_from_config_ex(SFContext *sf_context,
        outer_port = config->default_outer_port;
    }

-#if IOEVENT_USE_URING
-    global_use_send_zc = iniGetBoolValue(NULL, "use_send_zc",
-            config->ini_ctx.context, true);
-    if (config->ini_ctx.section_name == NULL) {
-        use_send_zc = global_use_send_zc;
-    } else {
-        use_send_zc = iniGetBoolValue(config->ini_ctx.section_name,
-                "use_send_zc", config->ini_ctx.context, global_use_send_zc);
-    }
-#endif
-
    for (i=0; i<SF_ADDRESS_FAMILY_COUNT; i++) {
        fh = sf_context->handlers + i;
        fh->ctx = sf_context;
@ -744,7 +710,7 @@ int sf_load_context_from_config_ex(SFContext *sf_context,
            if (!handler->enabled) {
                continue;
            }
-            if ((result=init_network_handler(sf_context, handler, fh)) != 0) {
+            if ((result=init_network_handler(handler, fh)) != 0) {
                return result;
            }
        }
@ -763,14 +729,8 @@ int sf_load_context_from_config_ex(SFContext *sf_context,
        rdma_handler->inner.enabled = sock_handler->inner.enabled;
        rdma_handler->outer.port = sock_handler->outer.port;
        rdma_handler->outer.enabled = sock_handler->outer.enabled;
-    }

-#if IOEVENT_USE_URING
-    sf_context->use_io_uring = (config->comm_type == fc_comm_type_sock);
-    sf_context->use_send_zc = sf_context->use_io_uring ? use_send_zc : false;
-#else
-    sf_context->use_io_uring = false;
-#endif
+    }

    sf_context->accept_threads = iniGetIntValue(
            config->ini_ctx.section_name,
@ -804,14 +764,6 @@ int sf_load_context_from_config_ex(SFContext *sf_context,
        return result;
    }

-    if ((result=load_network_parameters(&config->ini_ctx, config->
-                    max_pkg_size_item_name, config->max_pkg_size_min_value,
-                    fixed_buff_size, task_buffer_extra_size,
-                    &sf_context->net_buffer_cfg)) != 0)
-    {
-        return result;
-    }
-
    return 0;
 }

@ -887,7 +839,8 @@ static void combine_bind_addr(char *bind_addr, const char *ip_addr)
        p = bind_addr + strlen(bind_addr);
        *p++ = ',';
    }
-    strcpy(p, ip_addr);
+
+    sprintf(p, "%s", ip_addr);
 }

 static const char *get_address_family_caption(
@ -956,12 +909,6 @@ void sf_context_config_to_string(const SFContext *sf_context,
            ", address_family=%s, accept_threads=%d, work_threads=%d",
            get_address_family_caption(sf_context->address_family),
            sf_context->accept_threads, sf_context->work_threads);
-
-#if IOEVENT_USE_URING
-    len += snprintf(output + len, size - len, ", use_io_uring=%d, "
-            "use_send_zc=%d", sf_context->use_io_uring,
-            sf_context->use_send_zc);
-#endif
 }

 void sf_log_config_to_string_ex(SFLogConfig *log_cfg, const char *caption,
@ -1013,11 +960,11 @@ void sf_global_config_to_string_ex(const char *max_pkg_size_item_nm,
    int max_buff_size;
    char pkg_buff[256];

-    max_pkg_size = g_sf_global_vars.net_buffer_cfg.max_pkg_size -
+    max_pkg_size = g_sf_global_vars.max_pkg_size -
        g_sf_global_vars.task_buffer_extra_size;
-    min_buff_size = g_sf_global_vars.net_buffer_cfg.min_buff_size -
+    min_buff_size = g_sf_global_vars.min_buff_size -
        g_sf_global_vars.task_buffer_extra_size;
-    max_buff_size = g_sf_global_vars.net_buffer_cfg.max_buff_size -
+    max_buff_size = g_sf_global_vars.max_buff_size -
        g_sf_global_vars.task_buffer_extra_size;

    if (min_buff_size == max_buff_size && max_pkg_size == max_buff_size) {
@ -1032,27 +979,18 @@ void sf_global_config_to_string_ex(const char *max_pkg_size_item_nm,

    len = snprintf(output, size,
            "base_path=%s, max_connections=%d, connect_timeout=%d, "
-            "network_timeout=%d, thread_stack_size=%d KB, %s, ",
-            SF_G_BASE_PATH_STR,
-            g_sf_global_vars.net_buffer_cfg.max_connections,
-            g_sf_global_vars.net_buffer_cfg.connect_timeout,
-            g_sf_global_vars.net_buffer_cfg.network_timeout,
-            g_sf_global_vars.thread_stack_size / 1024, pkg_buff);
-
-#if IOEVENT_USE_URING
-    len += snprintf(output + len, size - len, "use_io_uring=%d, "
-            "use_send_zc=%d, ", g_sf_context.use_io_uring,
-            g_sf_context.use_send_zc);
-#endif
-
-    len += snprintf(output + len, size - len,
-            "tcp_quick_ack=%d, "
-            "log_level=%s, "
-            "run_by_group=%s, run_by_user=%s, ",
-            g_sf_global_vars.tcp_quick_ack,
+            "network_timeout=%d, thread_stack_size=%d KB, "
+            "%s, tcp_quick_ack=%d, log_level=%s, "
+            "run_by_group=%s, run_by_user=%s, ", SF_G_BASE_PATH_STR,
+            g_sf_global_vars.max_connections,
+            g_sf_global_vars.connect_timeout,
+            g_sf_global_vars.network_timeout,
+            g_sf_global_vars.thread_stack_size / 1024,
+            pkg_buff, g_sf_global_vars.tcp_quick_ack,
            log_get_level_caption(),
            g_sf_global_vars.run_by.group,
-            g_sf_global_vars.run_by.user);
+            g_sf_global_vars.run_by.user
+            );

    sf_log_config_to_string(&g_sf_global_vars.error_log,
            "error-log", output + len, size - len);
@ -1064,16 +1002,11 @@ void sf_log_config_ex(const char *other_config)
    char sz_context_config[128];

    sf_global_config_to_string(sz_global_config, sizeof(sz_global_config));
+    sf_context_config_to_string(&g_sf_context,
+            sz_context_config, sizeof(sz_context_config));

-    if (!g_sf_context.is_client) {
-        sf_context_config_to_string(&g_sf_context, sz_context_config,
-                sizeof(sz_context_config));
-    } else {
-        *sz_context_config = '\0';
-    }
-
-    logInfo("%s%s%s%s%s", sz_global_config, (*sz_context_config != '\0') ?
-            ", " : "", sz_context_config,
+    logInfo("%s, %s%s%s",
+            sz_global_config, sz_context_config,
            (other_config != NULL && *other_config != '\0')  ? ", " : "",
            (other_config != NULL) ? other_config : ""
           );
@ -1083,8 +1016,6 @@ int sf_load_data_path_config_ex(IniFullContext *ini_ctx,
        const char *item_name, const char *default_value, string_t *path)
 {
    const char *data_path;
-    int data_path_len;
-    int path_size;

    data_path = iniGetStrValue(ini_ctx->section_name,
            item_name, ini_ctx->context);
@ -1100,23 +1031,20 @@ int sf_load_data_path_config_ex(IniFullContext *ini_ctx,
        return EINVAL;
    }

-    data_path_len = strlen(data_path);
    if (*data_path == '/') {
-        path->len = data_path_len;
+        path->len = strlen(data_path);
        path->str = fc_strdup1(data_path, path->len);
        if (path->str == NULL) {
            return ENOMEM;
        }
    } else {
-        path_size = SF_G_BASE_PATH_LEN + data_path_len + 2;
-        path->str = (char *)fc_malloc(path_size);
+        path->len = strlen(SF_G_BASE_PATH_STR) + strlen(data_path) + 1;
+        path->str = (char *)fc_malloc(path->len + 1);
        if (path->str == NULL) {
            return ENOMEM;
        }
-
-        path->len = fc_get_full_filepath_ex(SF_G_BASE_PATH_STR,
-                SF_G_BASE_PATH_LEN, data_path, data_path_len,
-                path->str, path_size);
+        path->len = sprintf(path->str, "%s/%s",
+                SF_G_BASE_PATH_STR, data_path);
    }
    chopPath(path->str);
    path->len = strlen(path->str);
--- a/src/sf_global.h
+++ b/src/sf_global.h
@ -30,9 +30,10 @@ typedef struct sf_connection_stat {
 } SFConnectionStat;

 typedef struct sf_global_variables {
+    int connect_timeout;
+    int network_timeout;
    struct {
        char str[MAX_PATH_SIZE];
-        int len;
        bool inited;
        bool created;
    } base_path;
@ -40,9 +41,10 @@ typedef struct sf_global_variables {
    volatile bool continue_flag;
    bool tcp_quick_ack;
    bool epoll_edge_trigger;
-
-    SFNetBufferConfig net_buffer_cfg;
-
+    int max_connections;
+    int max_pkg_size;
+    int min_buff_size;
+    int max_buff_size;
    int task_buffer_extra_size;
    int thread_stack_size;

@ -67,7 +69,6 @@ typedef struct sf_context_ini_config {
    int default_inner_port;
    int default_outer_port;
    int default_work_threads;
-    int max_pkg_size_min_value;
    FCCommunicationType comm_type;
    const char *max_pkg_size_item_name;
 } SFContextIniConfig;
@ -80,13 +81,12 @@ extern SFGlobalVariables         g_sf_global_vars;
 extern SFContext                 g_sf_context;

 #define SF_G_BASE_PATH_STR       g_sf_global_vars.base_path.str
-#define SF_G_BASE_PATH_LEN       g_sf_global_vars.base_path.len
 #define SF_G_BASE_PATH_INITED    g_sf_global_vars.base_path.inited
 #define SF_G_BASE_PATH_CREATED   g_sf_global_vars.base_path.created
 #define SF_G_CONTINUE_FLAG       g_sf_global_vars.continue_flag
-#define SF_G_CONNECT_TIMEOUT     g_sf_global_vars.net_buffer_cfg.connect_timeout
-#define SF_G_NETWORK_TIMEOUT     g_sf_global_vars.net_buffer_cfg.network_timeout
-#define SF_G_MAX_CONNECTIONS     g_sf_global_vars.net_buffer_cfg.max_connections
+#define SF_G_CONNECT_TIMEOUT     g_sf_global_vars.connect_timeout
+#define SF_G_NETWORK_TIMEOUT     g_sf_global_vars.network_timeout
+#define SF_G_MAX_CONNECTIONS     g_sf_global_vars.max_connections
 #define SF_G_THREAD_STACK_SIZE   g_sf_global_vars.thread_stack_size
 #define SF_G_UP_TIME             g_sf_global_vars.up_time

@ -177,7 +177,7 @@ extern SFContext                 g_sf_context;

 #define SF_SET_CONTEXT_INI_CONFIG_EX(config, the_comm_type, filename,   \
        pIniContext, section_name, def_inner_port, def_outer_port, \
-        def_work_threads, max_pkg_size_item_nm, max_pkg_size_min_val) \
+        def_work_threads, max_pkg_size_item_nm) \
    do { \
        FAST_INI_SET_FULL_CTX_EX(config.ini_ctx, filename, \
                section_name, pIniContext);   \
@ -186,7 +186,6 @@ extern SFContext                 g_sf_context;
        config.default_outer_port = def_outer_port; \
        config.default_work_threads = def_work_threads; \
        config.max_pkg_size_item_name = max_pkg_size_item_nm; \
-        config.max_pkg_size_min_value = max_pkg_size_min_val; \
    } while (0)

 #define SF_SET_CONTEXT_INI_CONFIG(config, the_comm_type,     \
@ -194,7 +193,7 @@ extern SFContext                 g_sf_context;
        def_outer_port, def_work_threads) \
     SF_SET_CONTEXT_INI_CONFIG_EX(config, the_comm_type, filename, \
             pIniContext, section_name, def_inner_port, def_outer_port, \
-             def_work_threads, "max_pkg_size", 0)
+             def_work_threads, "max_pkg_size")

 int sf_load_global_config_ex(const char *log_filename_prefix,
        IniFullContext *ini_ctx, const bool load_network_params,
@ -237,23 +236,20 @@ static inline int sf_load_config(const char *log_filename_prefix,
 }

 int sf_load_context_from_config_ex(SFContext *sf_context,
-        SFContextIniConfig *config, const int fixed_buff_size,
-        const int task_buffer_extra_size);
+        SFContextIniConfig *config);

 static inline int sf_load_context_from_config(SFContext *sf_context,
        const FCCommunicationType comm_type,
        const char *filename, IniContext *pIniContext,
        const char *section_name, const int default_inner_port,
-        const int default_outer_port, const int fixed_buff_size,
-        const int task_buffer_extra_size)
+        const int default_outer_port)
 {
    SFContextIniConfig config;

    SF_SET_CONTEXT_INI_CONFIG(config, comm_type, filename, pIniContext,
            section_name, default_inner_port, default_outer_port,
            DEFAULT_WORK_THREADS);
-    return sf_load_context_from_config_ex(sf_context, &config,
-            fixed_buff_size, task_buffer_extra_size);
+    return sf_load_context_from_config_ex(sf_context, &config);
 }

 int sf_alloc_rdma_pd(SFContext *sf_context,
@ -319,8 +315,8 @@ static inline void sf_set_global_base_path(const char *base_path)
    string_t path_string;

    FC_SET_STRING(path_string, (char *)base_path);
-    SF_G_BASE_PATH_LEN = normalize_path(NULL, &path_string,
-            SF_G_BASE_PATH_STR, sizeof(SF_G_BASE_PATH_STR));
+    normalize_path(NULL, &path_string, SF_G_BASE_PATH_STR,
+            sizeof(SF_G_BASE_PATH_STR));
    SF_G_BASE_PATH_INITED = true;
 }

--- a/src/sf_nio.c
+++ b/src/sf_nio.c
@ -41,9 +41,6 @@
 #include "sf_service.h"
 #include "sf_nio.h"

-static int sf_client_sock_write(int sock, const int event, void *arg);
-static int sf_client_sock_read(int sock, const int event, void *arg);
-
 void sf_set_parameters_ex(SFContext *sf_context, const int header_size,
        sf_set_body_length_callback set_body_length_func,
        sf_alloc_recv_buffer_callback alloc_recv_buffer_func,
@ -62,43 +59,19 @@ void sf_set_parameters_ex(SFContext *sf_context, const int header_size,
    sf_context->callbacks.release_buffer = release_buffer_callback;
 }

-#if IOEVENT_USE_URING
-#define CLEAR_OP_TYPE_AND_RELEASE_TASK(task) \
-    FC_URING_OP_TYPE(task) = IORING_OP_NOP;  \
-    sf_release_task(task)
-
-static int sf_uring_cancel_done(int sock, const int event, void *arg)
-{
-    struct fast_task_info *task;
-
-    task = (struct fast_task_info *)arg;
-    if (event != IOEVENT_TIMEOUT) {
-        CLEAR_OP_TYPE_AND_RELEASE_TASK(task);
-    }
-    return 0;
-}
-#endif
-
 void sf_task_detach_thread(struct fast_task_info *task)
 {
-#if IOEVENT_USE_URING
-    if (SF_CTX->use_io_uring) {
-        if (FC_URING_OP_TYPE(task) != IORING_OP_NOP) {
-            task->event.callback = (IOEventCallback)sf_uring_cancel_done;
-            uring_prep_cancel(task);
-        }
-    } else {
-#endif
    ioevent_detach(&task->thread_data->ev_puller, task->event.fd);
-#if IOEVENT_USE_URING
-    }
-#endif

    if (task->event.timer.expires > 0) {
        fast_timer_remove(&task->thread_data->timer,
                &task->event.timer);
        task->event.timer.expires = 0;
    }
+
+    if (SF_CTX->remove_from_ready_list) {
+        ioevent_remove(&task->thread_data->ev_puller, task);
+    }
 }

 void sf_task_switch_thread(struct fast_task_info *task,
@ -119,38 +92,28 @@ static inline void release_iovec_buffer(struct fast_task_info *task)
    }
 }

-void sf_socket_close_connection(struct fast_task_info *task)
-{
-#if IOEVENT_USE_URING
-    if (SF_CTX->use_io_uring) {
-        if (uring_prep_close_fd(task) != 0) {
-            close(task->event.fd);
-        }
-    } else {
-#endif
-        close(task->event.fd);
-#if IOEVENT_USE_URING
-    }
-#endif
-    task->event.fd = -1;
-}
-
 void sf_task_finish_clean_up(struct fast_task_info *task)
 {
+    /*
+    assert(task->event.fd >= 0);
+    if (task->event.fd < 0) {
+        logWarning("file: "__FILE__", line: %d, "
+                "task: %p already cleaned",
+                __LINE__, task);
+        return;
+    }
+    */
+
+    if (task->finish_callback != NULL) {
+        task->finish_callback(task);
+        task->finish_callback = NULL;
+    }
+
    release_iovec_buffer(task);
    sf_task_detach_thread(task);
-
-#if IOEVENT_USE_URING
-    if (!SF_CTX->use_io_uring) {
-#endif
    task->handler->close_connection(task);
-        __sync_fetch_and_sub(&g_sf_global_vars.
-                connection_stat.current_count, 1);
-
-#if IOEVENT_USE_URING
-    }
-#endif

+    __sync_fetch_and_sub(&g_sf_global_vars.connection_stat.current_count, 1);
    sf_release_task(task);
 }

@ -176,71 +139,14 @@ static inline int set_write_event(struct fast_task_info *task)
    return 0;
 }

-#if IOEVENT_USE_URING
-static inline int prepare_first_recv(struct fast_task_info *task)
-{
-    if (SF_CTX->callbacks.alloc_recv_buffer != NULL) {
-        return uring_prep_recv_data(task, task->recv.ptr->data,
-                SF_CTX->header_size);
-    } else {
-        return uring_prep_first_recv(task);
-    }
-}
-
-static inline int prepare_next_recv(struct fast_task_info *task)
-{
-    int recv_bytes;
-
-    if (task->recv.ptr->length == 0) { //recv header
-        recv_bytes = SF_CTX->header_size - task->recv.ptr->offset;
-        return uring_prep_recv_data(task, task->recv.ptr->data +
-                task->recv.ptr->offset, recv_bytes);
-    } else {
-        recv_bytes = task->recv.ptr->length - task->recv.ptr->offset;
-        if (task->recv_body == NULL) {
-            return uring_prep_recv_data(task, task->recv.ptr->data +
-                    task->recv.ptr->offset, recv_bytes);
-        } else {
-            return uring_prep_recv_data(task, task->recv_body +
-                    (task->recv.ptr->offset - SF_CTX->
-                     header_size), recv_bytes);
-        }
-    }
-}
-#endif
-
 static inline int set_read_event(struct fast_task_info *task)
 {
    int result;

-#if IOEVENT_USE_URING
-    if (SF_CTX->use_io_uring) {
-        if (FC_URING_OP_TYPE(task) != IORING_OP_NOP) {
-            if (FC_URING_OP_TYPE(task) == IORING_OP_RECV) {
-                logWarning("file: "__FILE__", line: %d, "
-                        "trigger recv again!", __LINE__);
-                return 0;
-            } else {
-                logWarning("file: "__FILE__", line: %d, "
-                        "another operation in progress, op_type: %d!",
-                        __LINE__, FC_URING_OP_TYPE(task));
-                return EBUSY;
-            }
-        }
-
-        if (task->event.callback != (IOEventCallback)sf_client_sock_read) {
-            task->event.callback = (IOEventCallback)sf_client_sock_read;
-        }
-        if ((result=prepare_first_recv(task)) != 0) {
-            ioevent_add_to_deleted_list(task);
-            return result;
-        }
-    } else {
-#endif
-
    if (task->event.callback == (IOEventCallback)sf_client_sock_read) {
        return 0;
    }
+
    task->event.callback = (IOEventCallback)sf_client_sock_read;
    if (ioevent_modify(&task->thread_data->ev_puller,
                task->event.fd, IOEVENT_READ, task) != 0)
@ -255,36 +161,24 @@ static inline int set_read_event(struct fast_task_info *task)
        return result;
    }

-#if IOEVENT_USE_URING
-    }
-#endif
-
    return 0;
 }

 int sf_set_read_event(struct fast_task_info *task)
 {
-#if IOEVENT_USE_URING
-    if (SF_CTX->use_io_uring) {
-        return 0;
-    }
-#endif
-
-    /* reset recv offset and length */
    task->recv.ptr->offset = 0;
    task->recv.ptr->length = 0;
-
    task->nio_stages.current = SF_NIO_STAGE_RECV;
    return set_read_event(task);
 }

-static inline int sf_ioevent_add(struct fast_task_info *task)
+static inline int sf_ioevent_add(struct fast_task_info *task,
+        IOEventCallback callback, const int timeout)
 {
    int result;

    result = ioevent_set(task, task->thread_data, task->event.fd,
-            IOEVENT_READ, (IOEventCallback)sf_client_sock_read,
-            SF_CTX->net_buffer_cfg.network_timeout);
+            IOEVENT_READ, callback, timeout);
    return result > 0 ? -1 * result : result;
 }

@ -302,7 +196,8 @@ static inline void inc_connection_current_count()
 static inline int sf_nio_init(struct fast_task_info *task)
 {
    inc_connection_current_count();
-    return sf_ioevent_add(task);
+    return sf_ioevent_add(task, (IOEventCallback)sf_client_sock_read,
+            task->network_timeout);
 }

 int sf_socket_async_connect_check(struct fast_task_info *task)
@ -317,39 +212,23 @@ int sf_socket_async_connect_check(struct fast_task_info *task)
    return result;
 }

-static int sf_client_connect_done(int sock, const int event, void *arg)
+static int sf_client_connect_done(int sock, short event, void *arg)
 {
    int result;
    struct fast_task_info *task;
-    char formatted_ip[FORMATTED_IP_SIZE];

    task = (struct fast_task_info *)arg;
    if (task->canceled) {
-#if IOEVENT_USE_URING
-        if (SF_CTX->use_io_uring && event != IOEVENT_TIMEOUT) {
-            CLEAR_OP_TYPE_AND_RELEASE_TASK(task);
-        }
-#endif
        return ENOTCONN;
    }

-    if (event == IOEVENT_TIMEOUT) {
+    if (event & IOEVENT_TIMEOUT) {
        result = ETIMEDOUT;
    } else {
-#if IOEVENT_USE_URING
-        if (SF_CTX->use_io_uring) {
-            CLEAR_OP_TYPE_AND_RELEASE_TASK(task);
-            result = (task->event.res < 0 ? -1 * task->event.res :
-                    task->event.res);
-        } else {
-#endif
        result = task->handler->async_connect_check(task);
        if (result == EINPROGRESS) {
            return 0;
        }
-#if IOEVENT_USE_URING
-        }
-#endif
    }

    if (SF_CTX->callbacks.connect_done != NULL) {
@ -358,10 +237,9 @@ static int sf_client_connect_done(int sock, const int event, void *arg)

    if (result != 0) {
        if (SF_CTX->connect_need_log) {
-            format_ip_address(task->server_ip, formatted_ip);
            logError("file: "__FILE__", line: %d, "
                    "connect to server %s:%u fail, errno: %d, "
-                    "error info: %s", __LINE__, formatted_ip,
+                    "error info: %s", __LINE__, task->server_ip,
                    task->port, result, STRERROR(result));
        }
        ioevent_add_to_deleted_list(task);
@ -369,10 +247,9 @@ static int sf_client_connect_done(int sock, const int event, void *arg)
    }

    if (SF_CTX->connect_need_log) {
-        format_ip_address(task->server_ip, formatted_ip);
        logInfo("file: "__FILE__", line: %d, "
                "connect to server %s:%u successfully",
-                __LINE__, formatted_ip, task->port);
+                __LINE__, task->server_ip, task->port);
    }
    return SF_CTX->callbacks.deal_task(task, SF_NIO_STAGE_HANDSHAKE);
 }
@ -380,15 +257,6 @@ static int sf_client_connect_done(int sock, const int event, void *arg)
 int sf_socket_async_connect_server(struct fast_task_info *task)
 {
    int result;
-
-#if IOEVENT_USE_URING
-    if (SF_CTX->use_io_uring) {
-        if ((result=uring_prep_connect(task)) != 0) {
-            return result;
-        }
-        return EINPROGRESS;
-    } else {
-#endif
    if ((task->event.fd=socketCreateEx2(AF_UNSPEC, task->server_ip,
                    O_NONBLOCK, NULL, &result)) < 0)
    {
@ -397,21 +265,16 @@ int sf_socket_async_connect_server(struct fast_task_info *task)

    return asyncconnectserverbyip(task->event.fd,
            task->server_ip, task->port);
-#if IOEVENT_USE_URING
-    }
-#endif
 }

 static int sf_async_connect_server(struct fast_task_info *task)
 {
    int result;
-    char formatted_ip[FORMATTED_IP_SIZE];

    if ((result=task->handler->async_connect_server(task)) == EINPROGRESS) {
        result = ioevent_set(task, task->thread_data, task->event.fd,
                IOEVENT_READ | IOEVENT_WRITE, (IOEventCallback)
-                sf_client_connect_done, SF_CTX->net_buffer_cfg.
-                connect_timeout);
+                sf_client_connect_done, task->connect_timeout);
        return result > 0 ? -1 * result : result;
    } else {
        if (SF_CTX->callbacks.connect_done != NULL) {
@ -419,24 +282,24 @@ static int sf_async_connect_server(struct fast_task_info *task)
        }

        if (result == 0) {
-            if ((result=sf_ioevent_add(task)) != 0) {
+            if ((result=sf_ioevent_add(task, (IOEventCallback)
+                            sf_client_sock_read, task->network_timeout)) != 0)
+            {
                return result;
            }

            if (SF_CTX->connect_need_log) {
-                format_ip_address(task->server_ip, formatted_ip);
                logInfo("file: "__FILE__", line: %d, "
                        "connect to server %s:%u successfully",
-                        __LINE__, formatted_ip, task->port);
+                        __LINE__, task->server_ip, task->port);
            }
            return SF_CTX->callbacks.deal_task(task, SF_NIO_STAGE_HANDSHAKE);
        } else {
            task->handler->close_connection(task);
            if (SF_CTX->connect_need_log) {
-                format_ip_address(task->server_ip, formatted_ip);
                logError("file: "__FILE__", line: %d, "
                        "connect to server %s:%u fail, errno: %d, "
-                        "error info: %s", __LINE__, formatted_ip,
+                        "error info: %s", __LINE__, task->server_ip,
                        task->port, result, STRERROR(result));
            }
            return result > 0 ? -1 * result : result;
@ -460,14 +323,12 @@ static int sf_nio_deal_task(struct fast_task_info *task, const int stage)
        case SF_NIO_STAGE_RECV:
            task->nio_stages.current = SF_NIO_STAGE_RECV;
            if ((result=set_read_event(task)) == 0) {
-                if (!SF_CTX->use_io_uring) {
                if (sf_client_sock_read(task->event.fd,
                            IOEVENT_READ, task) < 0)
                {
                    result = errno != 0 ? errno : EIO;
                }
            }
-            }
            break;
        case SF_NIO_STAGE_SEND:
            result = sf_send_add_event(task);
@ -476,7 +337,10 @@ static int sf_nio_deal_task(struct fast_task_info *task, const int stage)
            result = SF_CTX->callbacks.deal_task(task, SF_NIO_STAGE_CONTINUE);
            break;
        case SF_NIO_STAGE_FORWARDED:  //forward by other thread
-            if ((result=sf_ioevent_add(task)) == 0) {
+            if ((result=sf_ioevent_add(task, (IOEventCallback)
+                            sf_client_sock_read,
+                            task->network_timeout)) == 0)
+            {
                result = SF_CTX->callbacks.deal_task(task, SF_NIO_STAGE_SEND);
            }
            break;
@ -544,7 +408,6 @@ int sf_nio_notify(struct fast_task_info *task, const int stage)
        }
    }

-    sf_hold_task(task);  //since 1.2.11
    PTHREAD_MUTEX_LOCK(&task->thread_data->waiting_queue.lock);
    task->notify_next = NULL;
    if (task->thread_data->waiting_queue.tail == NULL) {
@ -564,7 +427,7 @@ int sf_nio_notify(struct fast_task_info *task, const int stage)
        {
            result = errno != 0 ? errno : EIO;
            logError("file: "__FILE__", line: %d, "
-                    "write to fd %d fail, errno: %d, error info: %s",
+                    "write eventfd %d fail, errno: %d, error info: %s",
                    __LINE__, FC_NOTIFY_WRITE_FD(task->thread_data),
                    result, STRERROR(result));
            return result;
@ -592,32 +455,26 @@ static inline void deal_notified_task(struct fast_task_info *task,
    }
 }

-void sf_recv_notify_read(int fd, const int event, void *arg)
+void sf_recv_notify_read(int sock, short event, void *arg)
 {
    int64_t n;
    int stage;
-    struct ioevent_notify_entry *notify_entry;
+    struct nio_thread_data *thread_data;
    struct fast_task_info *task;
    struct fast_task_info *current;

-    notify_entry = (struct ioevent_notify_entry *)arg;
-    if (read(fd, &n, sizeof(n)) < 0) {
-#if IOEVENT_USE_URING
-        if (errno == EAGAIN) {
-            return;
-        }
-#endif
-
+    thread_data = ((struct ioevent_notify_entry *)arg)->thread_data;
+    if (read(sock, &n, sizeof(n)) < 0) {
        logWarning("file: "__FILE__", line: %d, "
-                "read from fd %d fail, errno: %d, error info: %s",
-                __LINE__, fd, errno, STRERROR(errno));
+                "read from eventfd %d fail, errno: %d, error info: %s",
+                __LINE__, sock, errno, STRERROR(errno));
    }

-    PTHREAD_MUTEX_LOCK(&notify_entry->thread_data->waiting_queue.lock);
-    current = notify_entry->thread_data->waiting_queue.head;
-    notify_entry->thread_data->waiting_queue.head = NULL;
-    notify_entry->thread_data->waiting_queue.tail = NULL;
-    PTHREAD_MUTEX_UNLOCK(&notify_entry->thread_data->waiting_queue.lock);
+    PTHREAD_MUTEX_LOCK(&thread_data->waiting_queue.lock);
+    current = thread_data->waiting_queue.head;
+    thread_data->waiting_queue.head = NULL;
+    thread_data->waiting_queue.tail = NULL;
+    PTHREAD_MUTEX_UNLOCK(&thread_data->waiting_queue.lock);

    while (current != NULL) {
        task = current;
@ -634,7 +491,6 @@ void sf_recv_notify_read(int fd, const int event, void *arg)
            __sync_bool_compare_and_swap(&task->nio_stages.notify,
                    stage, SF_NIO_STAGE_NONE);
        }
-        sf_release_task(task);  //since 1.2.11
    }
 }

@ -644,31 +500,16 @@ int sf_send_add_event(struct fast_task_info *task)
    if (task->send.ptr->length > 0) {
        /* direct send */
        task->nio_stages.current = SF_NIO_STAGE_SEND;
-#if IOEVENT_USE_URING
-        if (SF_CTX->use_io_uring) {
-            if (task->event.callback != (IOEventCallback)sf_client_sock_write) {
-                task->event.callback = (IOEventCallback)sf_client_sock_write;
-            }
-            if (SF_CTX->use_send_zc) {
-                return uring_prep_first_send_zc(task);
-            } else {
-                return uring_prep_first_send(task);
-            }
-        } else {
-#endif
        if (sf_client_sock_write(task->event.fd, IOEVENT_WRITE, task) < 0) {
            return errno != 0 ? errno : EIO;
        }
-#if IOEVENT_USE_URING
-        }
-#endif
    }

    return 0;
 }

 static inline int check_task(struct fast_task_info *task,
-        const int event, const int expect_stage)
+        const short event, const int expect_stage)
 {
    if (task->canceled) {
        return ENOTCONN;
@ -688,18 +529,6 @@ static inline int check_task(struct fast_task_info *task,
        return 0;
    }

-#if IOEVENT_USE_URING
-    if (SF_CTX->use_io_uring) {
-        logWarning("file: "__FILE__", line: %d, "
-                "client ip: %s, event: %d, expect stage: %d, "
-                "but current stage: %d, close connection",
-                __LINE__, task->client_ip, event,
-                expect_stage, task->nio_stages.current);
-        ioevent_add_to_deleted_list(task);
-        return -1;
-    }
-#endif
-
    if (task->handler->comm_type == fc_comm_type_sock) {
        if (tcp_socket_connected(task->event.fd)) {
            return EAGAIN;
@ -716,28 +545,11 @@ static inline int check_task(struct fast_task_info *task,
    }
 }

-#if IOEVENT_USE_URING
-static inline int prepare_next_send(struct fast_task_info *task)
-{
-    if (SF_CTX->use_send_zc) {
-        return uring_prep_next_send_zc(task);
-    } else {
-        return uring_prep_next_send(task);
-    }
-}
-#endif
-
 ssize_t sf_socket_send_data(struct fast_task_info *task,
        SFCommAction *action, bool *send_done)
 {
    int bytes;
-    int result;

-#if IOEVENT_USE_URING
-    if (SF_CTX->use_io_uring) {
-        bytes = task->event.res;
-    } else {
-#endif
    if (task->iovec_array.iovs != NULL) {
        bytes = writev(task->event.fd, task->iovec_array.iovs,
                FC_MIN(task->iovec_array.count, IOV_MAX));
@ -746,39 +558,15 @@ ssize_t sf_socket_send_data(struct fast_task_info *task,
                task->send.ptr->offset, task->send.ptr->length -
                task->send.ptr->offset);
    }
-#if IOEVENT_USE_URING
-    }
-#endif
-
    if (bytes < 0) {
-#if IOEVENT_USE_URING
-        if (SF_CTX->use_io_uring) {
-            result = -bytes;
-        } else {
-#endif
-            result = errno;
-#if IOEVENT_USE_URING
-        }
-#endif
-        if (result == EAGAIN || result == EWOULDBLOCK) {
-#if IOEVENT_USE_URING
-            if (SF_CTX->use_io_uring) {
-                if (prepare_next_send(task) != 0) {
-                    return -1;
-                }
-            } else {
-#endif
+        if (errno == EAGAIN || errno == EWOULDBLOCK)
+        {
            if (set_write_event(task) != 0) {
                return -1;
            }
-#if IOEVENT_USE_URING
-            }
-#endif
-
            *action = sf_comm_action_break;
            return 0;
-        } else if (result == EINTR && !SF_CTX->use_io_uring) {
-            /* should try again */
+        } else if (errno == EINTR) {  //should retry
            logDebug("file: "__FILE__", line: %d, "
                    "client ip: %s, ignore interupt signal",
                    __LINE__, task->client_ip);
@ -789,40 +577,30 @@ ssize_t sf_socket_send_data(struct fast_task_info *task,
                    "client ip: %s, send fail, task offset: %d, length: %d, "
                    "errno: %d, error info: %s", __LINE__, task->client_ip,
                    task->send.ptr->offset, task->send.ptr->length,
-                    result, strerror(result));
+                    errno, strerror(errno));
            return -1;
        }
    } else if (bytes == 0) {
        logWarning("file: "__FILE__", line: %d, "
-                "client ip: %s, task length: %d, offset: %d, "
+                "client ip: %s, sock: %d, task length: %d, offset: %d, "
                "send failed, connection disconnected", __LINE__,
-                task->client_ip, task->send.ptr->length,
+                task->client_ip, task->event.fd, task->send.ptr->length,
                task->send.ptr->offset);
        return -1;
    }

    task->send.ptr->offset += bytes;
    if (task->send.ptr->offset >= task->send.ptr->length) {
-#if IOEVENT_USE_URING
-        if (SF_CTX->use_io_uring && FC_URING_IS_SEND_ZC(task) &&
-                task->thread_data->ev_puller.send_zc_done_notify)
-        {
-            *action = sf_comm_action_break;
-            *send_done = false;
-        } else {
-#endif
        if (task->send.ptr != task->recv.ptr) {  //double buffers
            task->send.ptr->offset = 0;
            task->send.ptr->length = 0;
        }
-
        *action = sf_comm_action_finish;
        *send_done = true;
-#if IOEVENT_USE_URING
-        }
-#endif
-
    } else {
+        *action = sf_comm_action_continue;
+        *send_done = false;
+
        /* set next writev iovec array */
        if (task->iovec_array.iovs != NULL) {
            struct iovec *iov;
@ -851,25 +629,6 @@ ssize_t sf_socket_send_data(struct fast_task_info *task,
            task->iovec_array.iovs = iov;
            task->iovec_array.count = end - iov;
        }
-
-#if IOEVENT_USE_URING
-        if (SF_CTX->use_io_uring) {
-            if (!(FC_URING_IS_SEND_ZC(task) && task->thread_data->
-                        ev_puller.send_zc_done_notify))
-            {
-                if (prepare_next_send(task) != 0) {
-                    return -1;
-                }
-            }
-            *action = sf_comm_action_break;
-        } else {
-#endif
-            *action = sf_comm_action_continue;
-#if IOEVENT_USE_URING
-        }
-#endif
-
-        *send_done = false;
    }

    return bytes;
@ -879,15 +638,9 @@ ssize_t sf_socket_recv_data(struct fast_task_info *task,
        const bool call_post_recv, SFCommAction *action)
 {
    int bytes;
-    int result;
    int recv_bytes;
    bool new_alloc;

-#if IOEVENT_USE_URING
-    if (SF_CTX->use_io_uring) {
-        bytes = task->event.res;
-    } else {
-#endif
    if (task->recv.ptr->length == 0) { //recv header
        recv_bytes = SF_CTX->header_size - task->recv.ptr->offset;
        bytes = read(task->event.fd, task->recv.ptr->data +
@ -903,32 +656,12 @@ ssize_t sf_socket_recv_data(struct fast_task_info *task,
                     header_size), recv_bytes);
        }
    }
-#if IOEVENT_USE_URING
-    }
-#endif

    if (bytes < 0) {
-#if IOEVENT_USE_URING
-        if (SF_CTX->use_io_uring) {
-            result = -bytes;
-        } else {
-#endif
-            result = errno;
-#if IOEVENT_USE_URING
-        }
-#endif
-        if (result == EAGAIN || result == EWOULDBLOCK) {
-#if IOEVENT_USE_URING
-            if (SF_CTX->use_io_uring) {
-                if (prepare_next_recv(task) != 0) {
-                    return -1;
-                }
-            }
-#endif
+        if (errno == EAGAIN || errno == EWOULDBLOCK) {
            *action = sf_comm_action_break;
            return 0;
-        } else if (result == EINTR && !SF_CTX->use_io_uring) {
-            /* should try again */
+        } else if (errno == EINTR) {  //should retry
            logDebug("file: "__FILE__", line: %d, "
                    "client ip: %s, ignore interupt signal",
                    __LINE__, task->client_ip);
@ -939,7 +672,7 @@ ssize_t sf_socket_recv_data(struct fast_task_info *task,
                    "client ip: %s, recv fail, "
                    "errno: %d, error info: %s",
                    __LINE__, task->client_ip,
-                    result, strerror(result));
+                    errno, strerror(errno));
            return -1;
        }
    } else if (bytes == 0) {
@ -971,18 +704,7 @@ ssize_t sf_socket_recv_data(struct fast_task_info *task,
    task->recv.ptr->offset += bytes;
    if (task->recv.ptr->length == 0) { //pkg header
        if (task->recv.ptr->offset < SF_CTX->header_size) {
-#if IOEVENT_USE_URING
-            if (SF_CTX->use_io_uring) {
-                if (prepare_next_recv(task) != 0) {
-                    return -1;
-                }
-                *action = sf_comm_action_break;
-            } else {
-#endif
            *action = sf_comm_action_continue;
-#if IOEVENT_USE_URING
-            }
-#endif
            return bytes;
        }

@ -1035,18 +757,7 @@ ssize_t sf_socket_recv_data(struct fast_task_info *task,
    if (task->recv.ptr->offset >= task->recv.ptr->length) { //recv done
        *action = sf_comm_action_finish;
    } else {
-#if IOEVENT_USE_URING
-        if (SF_CTX->use_io_uring) {
-            if (prepare_next_recv(task) != 0) {
-                return -1;
-            }
-            *action = sf_comm_action_break;
-        } else {
-#endif
        *action = sf_comm_action_continue;
-#if IOEVENT_USE_URING
-        }
-#endif
    }

    return bytes;
@ -1054,7 +765,6 @@ ssize_t sf_socket_recv_data(struct fast_task_info *task,

 static int calc_iops_and_trigger_polling(struct fast_task_info *task)
 {
-    char formatted_ip[FORMATTED_IP_SIZE];
    int time_distance;
    int result = 0;

@ -1081,10 +791,9 @@ static int calc_iops_and_trigger_polling(struct fast_task_info *task)
                fc_list_add_tail(&task->polling.dlink,
                        &task->thread_data->polling_queue);

-                format_ip_address(task->client_ip, formatted_ip);
                logInfo("file: "__FILE__", line: %d, client: %s:%u, "
                        "trigger polling iops: %"PRId64, __LINE__,
-                        formatted_ip, task->port, (task->req_count -
+                        task->client_ip, task->port, (task->req_count -
                            task->polling.last_req_count) / time_distance);
            }
        } else {
@ -1102,7 +811,6 @@ static int calc_iops_and_trigger_polling(struct fast_task_info *task)

 static int calc_iops_and_remove_polling(struct fast_task_info *task)
 {
-    char formatted_ip[FORMATTED_IP_SIZE];
    int time_distance;
    int result = 0;

@ -1122,12 +830,12 @@ static int calc_iops_and_remove_polling(struct fast_task_info *task)
                    ioevent_set_timeout(&task->thread_data->ev_puller,
                            task->thread_data->timeout_ms);
                }
-                result = sf_ioevent_add(task);
+                result = sf_ioevent_add(task, (IOEventCallback)
+                        sf_client_sock_read, task->network_timeout);

-                format_ip_address(task->client_ip, formatted_ip);
                logInfo("file: "__FILE__", line: %d, client: %s:%u, "
                        "remove polling iops: %"PRId64, __LINE__,
-                        formatted_ip, task->port, (task->req_count -
+                        task->client_ip, task->port, (task->req_count -
                            task->polling.last_req_count) / time_distance);
            }
        } else {
@ -1184,7 +892,7 @@ int sf_rdma_busy_polling_callback(struct nio_thread_data *thread_data)
    return 0;
 }

-static int sf_client_sock_read(int sock, const int event, void *arg)
+int sf_client_sock_read(int sock, short event, void *arg)
 {
    int result;
    int bytes;
@ -1194,15 +902,10 @@ static int sf_client_sock_read(int sock, const int event, void *arg)

    task = (struct fast_task_info *)arg;
    if ((result=check_task(task, event, SF_NIO_STAGE_RECV)) != 0) {
-#if IOEVENT_USE_URING
-        if (SF_CTX->use_io_uring && event != IOEVENT_TIMEOUT) {
-            CLEAR_OP_TYPE_AND_RELEASE_TASK(task);
-        }
-#endif
        return result >= 0 ? 0 : -1;
    }

-    if (event == IOEVENT_TIMEOUT) {
+    if (event & IOEVENT_TIMEOUT) {
        if (task->recv.ptr->offset == 0 && task->req_count > 0) {
            if (SF_CTX->callbacks.task_timeout != NULL) {
                if (SF_CTX->callbacks.task_timeout(task) != 0) {
@ -1212,10 +915,9 @@ static int sf_client_sock_read(int sock, const int event, void *arg)
            }

            task->event.timer.expires = g_current_time +
-                SF_CTX->net_buffer_cfg.network_timeout;
+                task->network_timeout;
            fast_timer_add(&task->thread_data->timer,
                &task->event.timer);
-            return 0;
        } else {
            if (task->recv.ptr->length > 0) {
                logWarning("file: "__FILE__", line: %d, "
@ -1232,20 +934,16 @@ static int sf_client_sock_read(int sock, const int event, void *arg)
            ioevent_add_to_deleted_list(task);
            return -1;
        }
-    }

-#if IOEVENT_USE_URING
-    if (SF_CTX->use_io_uring) {
-        CLEAR_OP_TYPE_AND_RELEASE_TASK(task);
+        return 0;
    }
-#endif

    total_read = 0;
    action = sf_comm_action_continue;
    while (1) {
        fast_timer_modify(&task->thread_data->timer,
            &task->event.timer, g_current_time +
-            SF_CTX->net_buffer_cfg.network_timeout);
+            task->network_timeout);

        if ((bytes=task->handler->recv_data(task, !task->handler->
                        explicit_post_recv, &action)) < 0)
@ -1286,72 +984,23 @@ static int sf_client_sock_read(int sock, const int event, void *arg)
    return total_read;
 }

-static int sock_write_done(struct fast_task_info *task,
-        const int length, const bool send_done)
-{
-    int next_stage;
-
-    release_iovec_buffer(task);
-    task->recv.ptr->offset = 0;
-    task->recv.ptr->length = 0;
-
-    if (SF_CTX->callbacks.send_done == NULL || !send_done) {
-        task->nio_stages.current = SF_NIO_STAGE_RECV;
-    } else {
-        if (SF_CTX->callbacks.send_done(task,
-                    length, &next_stage) != 0)
-        {
-            ioevent_add_to_deleted_list(task);
-            return -1;
-        }
-
-        if (task->nio_stages.current != next_stage) {
-            task->nio_stages.current = next_stage;
-        }
-    }
-
-#if IOEVENT_USE_URING
-    if (!SF_CTX->use_io_uring || task->nio_stages.
-            current == SF_NIO_STAGE_RECV)
-    {
-#endif
-
-        if (set_read_event(task) != 0) {
-            return -1;
-        }
-
-#if IOEVENT_USE_URING
-    }
-#endif
-
-    return 0;
-}
-
-static int sf_client_sock_write(int sock, const int event, void *arg)
+int sf_client_sock_write(int sock, short event, void *arg)
 {
    int result;
    int bytes;
    int total_write;
    int length;
+    int next_stage;
    SFCommAction action;
    bool send_done;
    struct fast_task_info *task;

    task = (struct fast_task_info *)arg;
    if ((result=check_task(task, event, SF_NIO_STAGE_SEND)) != 0) {
-#if IOEVENT_USE_URING
-        if (SF_CTX->use_io_uring && event != IOEVENT_TIMEOUT) {
-            if (event == IOEVENT_NOTIFY || !(FC_URING_IS_SEND_ZC(task) &&
-                        task->thread_data->ev_puller.send_zc_done_notify))
-            {
-                CLEAR_OP_TYPE_AND_RELEASE_TASK(task);
-            }
-        }
-#endif
        return result >= 0 ? 0 : -1;
    }

-    if (event == IOEVENT_TIMEOUT) {
+    if (event & IOEVENT_TIMEOUT) {
        logError("file: "__FILE__", line: %d, "
            "client ip: %s, send timeout. total length: %d, offset: %d, "
            "remain: %d", __LINE__, task->client_ip, task->send.ptr->length,
@ -1362,49 +1011,13 @@ static int sf_client_sock_write(int sock, const int event, void *arg)
        return -1;
    }

-#if IOEVENT_USE_URING
-    if (event == IOEVENT_NOTIFY) {
-        if (!FC_URING_IS_SEND_ZC(task)) {
-            logWarning("file: "__FILE__", line: %d, "
-                    "unexpected io_uring notify!", __LINE__);
-            return -1;
-        }
-
-        FC_URING_OP_TYPE(task) = IORING_OP_NOP;
-        if (!task->canceled) {
-            if (task->send.ptr->offset >= task->send.ptr->length) {
-                length = task->send.ptr->length;
-                if (task->send.ptr != task->recv.ptr) {  //double buffers
-                    task->send.ptr->offset = 0;
-                    task->send.ptr->length = 0;
-                }
-
-                result = sock_write_done(task, length, true);
-            } else {
-                result = prepare_next_send(task);
-            }
-        }
-
-        sf_release_task(task);
-        return result == 0 ? 0 : -1;
-    }
-
-    if (SF_CTX->use_io_uring) {
-        if (!(FC_URING_IS_SEND_ZC(task) && task->thread_data->
-                    ev_puller.send_zc_done_notify))
-        {
-            CLEAR_OP_TYPE_AND_RELEASE_TASK(task);
-        }
-    }
-#endif
-
    total_write = 0;
    length = task->send.ptr->length;
    action = sf_comm_action_continue;
    while (1) {
        fast_timer_modify(&task->thread_data->timer,
                &task->event.timer, g_current_time +
-                SF_CTX->net_buffer_cfg.network_timeout);
+                task->network_timeout);

        if ((bytes=task->handler->send_data(task, &action, &send_done)) < 0) {
            ioevent_add_to_deleted_list(task);
@ -1413,9 +1026,27 @@ static int sf_client_sock_write(int sock, const int event, void *arg)

        total_write += bytes;
        if (action == sf_comm_action_finish) {
-            if (sock_write_done(task, length, send_done) != 0) {
+            release_iovec_buffer(task);
+            task->recv.ptr->offset = 0;
+            task->recv.ptr->length = 0;
+            if (set_read_event(task) != 0) {
                return -1;
            }
+
+            if (SF_CTX->callbacks.send_done == NULL || !send_done) {
+                task->nio_stages.current = SF_NIO_STAGE_RECV;
+            } else {
+                if (SF_CTX->callbacks.send_done(task,
+                            length, &next_stage) != 0)
+                {
+                    return -1;
+                }
+
+                if (task->nio_stages.current != next_stage) {
+                    task->nio_stages.current = next_stage;
+                }
+            }
+
            break;
        } else if (action == sf_comm_action_break) {
            break;
@ -1424,8 +1055,3 @@ static int sf_client_sock_write(int sock, const int event, void *arg)

    return total_write;
 }
-
-bool sf_client_sock_in_read_stage(struct fast_task_info *task)
-{
-    return (task->event.callback == (IOEventCallback)sf_client_sock_read);
-}
--- a/src/sf_nio.h
+++ b/src/sf_nio.h
@ -28,7 +28,6 @@
 #include "sf_global.h"

 #define SF_CTX  (task->handler->fh->ctx)
-#define SF_NET_BUFFER_CFG   SF_CTX->net_buffer_cfg

 #ifdef __cplusplus
 extern "C" {
@ -68,6 +67,15 @@ static inline void sf_set_connect_done_callback_ex(SFContext *sf_context,
    sf_set_connect_done_callback_ex(&g_sf_context, done_callback)


+static inline void sf_set_remove_from_ready_list_ex(
+        SFContext *sf_context, const bool enabled)
+{
+    sf_context->remove_from_ready_list = enabled;
+}
+
+#define sf_set_remove_from_ready_list(enabled) \
+    sf_set_remove_from_ready_list_ex(&g_sf_context, enabled);
+
 static inline TaskCleanUpCallback sf_get_task_cleanup_callback_ex(
        SFContext *sf_context)
 {
@ -90,9 +98,10 @@ static inline void sf_nio_reset_task_length(struct fast_task_info *task)
    }
 }

-void sf_socket_close_connection(struct fast_task_info *task);
-void sf_recv_notify_read(int sock, const int event, void *arg);
+void sf_recv_notify_read(int sock, short event, void *arg);
 int sf_send_add_event(struct fast_task_info *task);
+int sf_client_sock_write(int sock, short event, void *arg);
+int sf_client_sock_read(int sock, short event, void *arg);

 void sf_task_finish_clean_up(struct fast_task_info *task);

@ -119,12 +128,12 @@ static inline int sf_set_body_length(struct fast_task_info *task)
    }

    task->recv.ptr->length += SF_CTX->header_size;
-    if (task->recv.ptr->length > SF_NET_BUFFER_CFG.max_pkg_size) {
+    if (task->recv.ptr->length > g_sf_global_vars.max_pkg_size) {
        logError("file: "__FILE__", line: %d, "
                "client ip: %s, pkg length: %d > "
                "max pkg size: %d", __LINE__,
                task->client_ip, task->recv.ptr->length,
-                SF_NET_BUFFER_CFG.max_pkg_size);
+                g_sf_global_vars.max_pkg_size);
        return -1;
    }

@ -148,6 +157,11 @@ static inline int sf_nio_forward_request(struct fast_task_info *task,
    return sf_nio_notify(task, SF_NIO_STAGE_FORWARDED);
 }

+static inline bool sf_client_sock_in_read_stage(struct fast_task_info *task)
+{
+    return (task->event.callback == (IOEventCallback)sf_client_sock_read);
+}
+
 static inline void sf_nio_add_to_deleted_list(struct nio_thread_data
        *thread_data, struct fast_task_info *task)
 {
@ -158,8 +172,6 @@ static inline void sf_nio_add_to_deleted_list(struct nio_thread_data
    }
 }

-bool sf_client_sock_in_read_stage(struct fast_task_info *task);
-
 #ifdef __cplusplus
 }
 #endif
--- a/src/sf_ordered_writer.c
+++ b/src/sf_ordered_writer.c
@ -106,7 +106,7 @@ void sf_ordered_writer_finish(SFOrderedWriterContext *ctx)
 {
    int count;

-    if (ctx->writer.fw.file.name.str != NULL) {
+    if (ctx->writer.fw.file.name != NULL) {
        fc_queue_terminate(&ctx->thread.queues.version);

        count = 0;
@ -120,8 +120,8 @@ void sf_ordered_writer_finish(SFOrderedWriterContext *ctx)
                    __LINE__, ctx->writer.fw.cfg.subdir_name);
        }

-        free(ctx->writer.fw.file.name.str);
-        ctx->writer.fw.file.name.str = NULL;
+        free(ctx->writer.fw.file.name);
+        ctx->writer.fw.file.name = NULL;
    }

    if (ctx->writer.fw.file.fd >= 0) {
@ -142,7 +142,8 @@ static void *binlog_writer_func(void *arg)
 #ifdef OS_LINUX
    {
        char thread_name[64];
-        fc_combine_two_strings(thread->name, "writer", '-', thread_name);
+        snprintf(thread_name, sizeof(thread_name),
+                "%s-writer", thread->name);
        prctl(PR_SET_NAME, thread_name);
    }
 #endif
@ -202,7 +203,7 @@ static int sf_ordered_writer_init_thread(SFOrderedWriterContext *context,

    thread = &context->thread;
    writer = &context->writer;
-    fc_safe_strcpy(thread->name, name);
+    snprintf(thread->name, sizeof(thread->name), "%s", name);
    writer->fw.cfg.max_record_size = max_record_size;
    writer->thread = thread;

@ -249,8 +250,8 @@ int sf_ordered_writer_init_ex(SFOrderedWriterContext *context,
 {
    int result;
    if ((result=sf_file_writer_init(&context->writer.fw, data_path,
-                    subdir_name, file_prefix, max_record_size,
-                    buffer_size, file_rotate_size, call_fsync)) != 0)
+                    subdir_name, file_prefix, buffer_size,
+                    file_rotate_size, call_fsync)) != 0)
    {
        return result;
    }
--- a/src/sf_ordered_writer.h
+++ b/src/sf_ordered_writer.h
@ -71,7 +71,7 @@ int sf_ordered_writer_init_ex(SFOrderedWriterContext *context,
 #define sf_ordered_writer_init(context, data_path, \
        subdir_name, buffer_size, max_record_size) \
    sf_ordered_writer_init_ex(context, data_path, subdir_name,   \
-            SF_BINLOG_FILE_PREFIX_STR, buffer_size, max_record_size, \
+            SF_BINLOG_FILE_PREFIX, buffer_size, max_record_size, \
            SF_BINLOG_DEFAULT_ROTATE_SIZE, true)

 #define sf_ordered_writer_set_flags(ctx, flags) \
--- a/src/sf_proto.c
+++ b/src/sf_proto.c
@ -14,6 +14,8 @@
 */


+#include <errno.h>
+#include "fastcommon/shared_func.h"
 #include "sf_util.h"
 #include "sf_nio.h"
 #include "sf_proto.h"
@ -27,16 +29,14 @@ static int64_t log_slower_than_us = 0;
 int sf_proto_set_body_length(struct fast_task_info *task)
 {
    SFCommonProtoHeader *header;
-    char formatted_ip[FORMATTED_IP_SIZE];

    header = (SFCommonProtoHeader *)task->recv.ptr->data;
    if (!SF_PROTO_CHECK_MAGIC(header->magic)) {
-        format_ip_address(task->client_ip, formatted_ip);
        logError("file: "__FILE__", line: %d, "
                "%s peer %s:%u, magic "SF_PROTO_MAGIC_FORMAT" is invalid, "
                "expect: "SF_PROTO_MAGIC_FORMAT", cmd: %d, body length: %d",
                __LINE__, (task->handler != NULL ? task->handler->fh->ctx->
-                    name : ""), formatted_ip, task->port,
+                    name : ""), task->client_ip, task->port,
                SF_PROTO_MAGIC_PARAMS(header->magic),
                SF_PROTO_MAGIC_EXPECT_PARAMS, header->cmd,
                buff2int(header->body_len));
@ -456,17 +456,14 @@ const char *sf_get_cmd_caption(const int cmd)
 int sf_proto_deal_ack(struct fast_task_info *task,
        SFRequestInfo *request, SFResponseInfo *response)
 {
-    char formatted_ip[FORMATTED_IP_SIZE];
-
    if (request->header.status != 0) {
        if (request->header.body_len > 0) {
            int remain_size;
            int len;

-            format_ip_address(task->client_ip, formatted_ip);
            response->error.length = sprintf(response->error.message,
                    "message from peer %s:%u => ",
-                    formatted_ip, task->port);
+                    task->client_ip, task->port);
            remain_size = sizeof(response->error.message) -
                response->error.length;
            if (request->header.body_len >= remain_size) {
@ -528,7 +525,6 @@ int sf_proto_get_group_servers(ConnectionInfo *conn,
    char out_buff[sizeof(SFCommonProtoHeader) +
        sizeof(SFProtoGetGroupServersReq)];
    char in_buff[1024];
-    char formatted_ip[FORMATTED_IP_SIZE];
    SFCommonProtoHeader *header;
    SFProtoGetGroupServersReq *req;
    SFProtoGetGroupServersRespBodyHeader *body_header;
@ -556,10 +552,9 @@ int sf_proto_get_group_servers(ConnectionInfo *conn,
    }

    if (body_len < sizeof(SFProtoGetGroupServersRespBodyHeader)) {
-        format_ip_address(conn->ip_addr, formatted_ip);
        logError("file: "__FILE__", line: %d, "
-                "server %s:%u response body length: %d < %d",
-                __LINE__, formatted_ip, conn->port, body_len,
+                "server %s:%d response body length: %d < %d",
+                __LINE__, conn->ip_addr, conn->port, body_len,
                (int)sizeof(SFProtoGetGroupServersRespBodyHeader));
        return EINVAL;
    }
@ -567,17 +562,15 @@ int sf_proto_get_group_servers(ConnectionInfo *conn,
    body_header = (SFProtoGetGroupServersRespBodyHeader *)in_buff;
    count = buff2int(body_header->count);
    if (count <= 0) {
-        format_ip_address(conn->ip_addr, formatted_ip);
        logError("file: "__FILE__", line: %d, "
-                "server %s:%u response server count: %d <= 0",
-                __LINE__, formatted_ip, conn->port, count);
+                "server %s:%d response server count: %d <= 0",
+                __LINE__, conn->ip_addr, conn->port, count);
        return EINVAL;
    }
    if (count > sarray->alloc) {
-        format_ip_address(conn->ip_addr, formatted_ip);
        logError("file: "__FILE__", line: %d, "
-                "server %s:%u response server count: %d is too large, "
-                "exceeds %d", __LINE__, formatted_ip, conn->port,
+                "server %s:%d response server count: %d is too large, "
+                "exceeds %d", __LINE__, conn->ip_addr, conn->port,
                count, sarray->alloc);
        return EOVERFLOW;
    }
@ -637,7 +630,6 @@ int sf_proto_deal_task_done(struct fast_task_info *task,
    int r;
    int64_t time_used;
    int log_level;
-    char formatted_ip[FORMATTED_IP_SIZE];
    char time_buff[32];

    if (ctx->log_level != LOG_NOTHING && ctx->response.error.length > 0) {
@ -645,8 +637,7 @@ int sf_proto_deal_task_done(struct fast_task_info *task,
                "file: "__FILE__", line: %d, %s "
                "peer %s:%u, cmd: %d (%s), req body length: %d, "
                "resp status: %d, %s", __LINE__, service_name,
-                format_ip_address(task->client_ip, formatted_ip),
-                task->port, ctx->request.header.cmd,
+                task->client_ip, task->port, ctx->request.header.cmd,
                GET_CMD_CAPTION(ctx->request.header.cmd),
                ctx->request.header.body_len, ctx->response.header.status,
                ctx->response.error.message);
@ -659,8 +650,7 @@ int sf_proto_deal_task_done(struct fast_task_info *task,
            log_it_ex(&g_log_context, log_level, "file: "__FILE__", line: %d, "
                    "%s client %s:%u, req cmd: %d (%s), req body_len: %d, "
                    "resp status: %d, time used: %s us", __LINE__, service_name,
-                    format_ip_address(task->client_ip, formatted_ip),
-                    task->port, ctx->request.header.cmd,
+                    task->client_ip, task->port, ctx->request.header.cmd,
                    GET_CMD_CAPTION(ctx->request.header.cmd),
                    ctx->request.header.body_len, ctx->response.header.status,
                    long_to_comma_str(time_used, time_buff));
@ -684,7 +674,6 @@ int sf_proto_deal_task_done(struct fast_task_info *task,

    status = sf_unify_errno(FC_ABS(ctx->response.header.status));
    short2buff(status, proto_header->status);
-    short2buff(ctx->response.header.flags, proto_header->flags);
    proto_header->cmd = ctx->response.header.cmd;
    int2buff(ctx->response.header.body_len, proto_header->body_len);
    task->send.ptr->length = sizeof(SFCommonProtoHeader) +
@ -701,9 +690,8 @@ int sf_proto_deal_task_done(struct fast_task_info *task,
        blen = sprintf(buff, "timed used: %s us, %s client %s:%u, "
                "req cmd: %d (%s), req body len: %d, resp cmd: %d (%s), "
                "status: %d, resp body len: %d", long_to_comma_str(time_used,
-                    time_buff), service_name, format_ip_address(task->
-                        client_ip, formatted_ip), task->port, ctx->request.
-                header.cmd, GET_CMD_CAPTION(ctx->request.header.cmd),
+                    time_buff), service_name, task->client_ip, task->port, ctx->
+                request.header.cmd, GET_CMD_CAPTION(ctx->request.header.cmd),
                ctx->request.header.body_len, ctx->response.header.cmd,
                GET_CMD_CAPTION(ctx->response.header.cmd),
                ctx->response.header.status, ctx->response.header.body_len);
@ -716,8 +704,7 @@ int sf_proto_deal_task_done(struct fast_task_info *task,
                "%s client %s:%u, req cmd: %d (%s), req body_len: %d, "
                "resp cmd: %d (%s), status: %d, resp body_len: %d, "
                "time used: %s us", __LINE__, service_name,
-                format_ip_address(task->client_ip, formatted_ip),
-                task->port, ctx->request.header.cmd,
+                task->client_ip, task->port, ctx->request.header.cmd,
                GET_CMD_CAPTION(ctx->request.header.cmd),
                ctx->request.header.body_len, ctx->response.header.cmd,
                GET_CMD_CAPTION(ctx->response.header.cmd),
--- a/src/sf_proto.h
+++ b/src/sf_proto.h
@ -68,17 +68,19 @@
 #define SF_PROTO_MAGIC_PARAMS(m) \
    m[0], m[1], m[2], m[3]

-#define SF_PROTO_SET_HEADER_EX(header, _cmd, _flags, _body_len) \
+#define SF_PROTO_SET_HEADER(header, _cmd, _body_len) \
    do {  \
        SF_PROTO_SET_MAGIC((header)->magic);   \
        (header)->cmd = _cmd;      \
        (header)->status[0] = (header)->status[1] = 0; \
-        short2buff(_flags, (header)->flags); \
        int2buff(_body_len, (header)->body_len); \
    } while (0)

-#define SF_PROTO_SET_HEADER(header, _cmd, _body_len) \
-        SF_PROTO_SET_HEADER_EX(header, _cmd, 0, _body_len)
+#define SF_PROTO_SET_HEADER_EX(header, _cmd, _flags, _body_len) \
+    do {  \
+        SF_PROTO_SET_HEADER(header, _cmd, _body_len); \
+        short2buff(_flags, (header)->flags); \
+    } while (0)

 #define SF_PROTO_SET_RESPONSE_HEADER(proto_header, resp_header) \
    do {  \
@ -307,7 +309,6 @@ static inline void sf_proto_init_task_context(struct fast_task_info *task,
    ctx->response.header.cmd = SF_PROTO_ACK;
    ctx->response.header.body_len = 0;
    ctx->response.header.status = 0;
-    ctx->response.header.flags = 0;
    ctx->response.error.length = 0;
    ctx->response.error.message[0] = '\0';
    ctx->log_level = LOG_ERR;
@ -319,8 +320,6 @@ static inline void sf_proto_init_task_context(struct fast_task_info *task,
    ctx->request.header.body_len = SF_RECV_BODY_LENGTH(task);
    ctx->request.header.status = buff2short(((SFCommonProtoHeader *)
                task->recv.ptr->data)->status);
-    ctx->request.header.flags = buff2short(((SFCommonProtoHeader *)
-                task->recv.ptr->data)->flags);
    if (task->recv_body != NULL) {
        ctx->request.body = task->recv_body;
    } else {
@ -458,16 +457,15 @@ static inline void sf_log_network_error_ex1(SFResponseInfo *response,
    sf_log_network_error_ex1(response, conn, service_name, result, \
            LOG_ERR, __FILE__, __LINE__)

-#define sf_log_network_error_for_update_ex(response, conn,  \
-        service_name, result, enoent_log_level, file, line) \
+#define sf_log_network_error_for_update_ex(response, \
+        conn, service_name, result, file, line) \
        sf_log_network_error_ex1(response, conn, service_name, result, \
                (result == SF_RETRIABLE_ERROR_CHANNEL_INVALID) ? \
-                LOG_DEBUG : ((result == ENOENT || result == ENODATA) ? \
-                    enoent_log_level : LOG_ERR), file, line)
+                LOG_DEBUG : LOG_ERR, file, line)

 #define sf_log_network_error_for_update(response, conn, service_name, result) \
-    sf_log_network_error_for_update_ex(response, conn, service_name, \
-            result, LOG_ERR, __FILE__, __LINE__)
+    sf_log_network_error_for_update_ex(response, conn, \
+            service_name, result, __FILE__, __LINE__)

 #define sf_log_network_error_for_delete_ex(response, conn,   \
        service_name, result, enoent_log_level, file, line)  \
@ -562,16 +560,6 @@ int sf_recv_response(ConnectionInfo *conn, SFResponseInfo *response,
        const int network_timeout, const unsigned char expect_cmd,
        char *recv_data, const int expect_body_len);

-static inline int sf_recv_none_body_response(ConnectionInfo *conn,
-        SFResponseInfo *response, const int network_timeout,
-        const unsigned char expect_cmd)
-{
-    char *recv_data = NULL;
-    const int expect_body_len = 0;
-    return sf_recv_response(conn, response, network_timeout,
-            expect_cmd, recv_data, expect_body_len);
-}
-
 int sf_recv_vary_response(ConnectionInfo *conn, SFResponseInfo *response,
        const int network_timeout, const unsigned char expect_cmd,
        SFProtoRecvBuffer *buffer, const int min_body_len);
@ -627,35 +615,6 @@ static inline int sf_proto_send_buf1(ConnectionInfo *conn, char *data,
    return result;
 }

-static inline int sf_proto_send_buf2(ConnectionInfo *conn, char *buff1,
-        const int length1, char *buff2, const int length2,
-        SFResponseInfo *response, const int network_timeout)
-{
-    int result;
-
-    if (conn->comm_type == fc_comm_type_rdma) {
-        result = G_RDMA_CONNECTION_CALLBACKS.request_by_buf2(
-                conn, buff1, length1, buff2, length2,
-                network_timeout * 1000);
-    } else {
-        if ((result=tcpsenddata_nb(conn->sock, buff1, length1,
-                        network_timeout)) == 0)
-        {
-            result = tcpsenddata_nb(conn->sock, buff2, length2,
-                    network_timeout);
-        }
-    }
-
-    if (result != 0) {
-        response->error.length = snprintf(response->error.message,
-                sizeof(response->error.message),
-                "send data fail, errno: %d, error info: %s",
-                result, STRERROR(result));
-    }
-
-    return result;
-}
-
 int sf_send_and_recv_response_header(ConnectionInfo *conn, char *data,
        const int len, SFResponseInfo *response, const int network_timeout);

--- a/src/sf_service.c
+++ b/src/sf_service.c
@ -33,8 +33,9 @@
 #include "fastcommon/sched_thread.h"
 #include "fastcommon/ioevent_loop.h"
 #include "fastcommon/fc_memory.h"
-#include "sf_proto.h"
+#include "sf_nio.h"
 #include "sf_util.h"
+#include "sf_global.h"
 #include "sf_service.h"

 #if defined(OS_LINUX)
@ -57,17 +58,22 @@ struct worker_thread_context {
    struct nio_thread_data *thread_data;
 };

+int sf_init_task(struct fast_task_info *task)
+{
+    task->connect_timeout = SF_G_CONNECT_TIMEOUT; //for client side
+    task->network_timeout = SF_G_NETWORK_TIMEOUT;
+    return 0;
+}
+
 static void *worker_thread_entrance(void *arg);

-static int sf_init_free_queue(SFContext *sf_context, const char *name,
-        const bool double_buffers, const bool need_shrink_task_buffer,
+static int sf_init_free_queue(struct fast_task_queue *free_queue,
+        const char *name, const bool double_buffers,
        const int task_padding_size, const int task_arg_size,
-        TaskInitCallback init_callback, void *init_arg)
+        TaskInitCallback init_callback)
 {
    int result;
-    int buffer_size;
    int m;
-    int max_m;
    int alloc_conn_once;

    if ((result=set_rand_seed()) != 0) {
@ -76,27 +82,19 @@ static int sf_init_free_queue(SFContext *sf_context, const char *name,
        return result;
    }

-    if (strcmp(name, "cluster") == 0 || strcmp(name, "replica") == 0) {
-        buffer_size = FC_MAX(4 * 1024 * 1024, sf_context->
-                net_buffer_cfg.max_buff_size);
-        max_m = 64;
-    } else {
-        buffer_size = sf_context->net_buffer_cfg.min_buff_size;
-        max_m = 16;
-    }
-    m = buffer_size / (64 * 1024);
+    m = g_sf_global_vars.min_buff_size / (64 * 1024);
    if (m == 0) {
        m = 1;
-    } else if (m > max_m) {
-        m = max_m;
+    } else if (m > 16) {
+        m = 16;
    }
    alloc_conn_once = 256 / m;
-
-    return free_queue_init_ex2(&sf_context->free_queue, name, double_buffers,
-            need_shrink_task_buffer, sf_context->net_buffer_cfg.max_connections,
-            alloc_conn_once, sf_context->net_buffer_cfg.min_buff_size,
-            sf_context->net_buffer_cfg.max_buff_size, task_padding_size,
-            task_arg_size, init_callback, init_arg);
+    return free_queue_init_ex2(free_queue, name, double_buffers,
+            g_sf_global_vars.max_connections, alloc_conn_once,
+            g_sf_global_vars.min_buff_size, g_sf_global_vars.
+            max_buff_size, task_padding_size, task_arg_size,
+            (init_callback != NULL ? init_callback :
+             sf_init_task));
 }

 int sf_service_init_ex2(SFContext *sf_context, const char *name,
@ -111,14 +109,12 @@ int sf_service_init_ex2(SFContext *sf_context, const char *name,
        sf_recv_timeout_callback timeout_callback, const int net_timeout_ms,
        const int proto_header_size, const int task_padding_size,
        const int task_arg_size, const bool double_buffers,
-        const bool need_shrink_task_buffer, const bool explicit_post_recv,
-        TaskInitCallback init_callback, void *init_arg,
+        const bool explicit_post_recv, TaskInitCallback init_callback,
        sf_release_buffer_callback release_buffer_callback)
 {
    int result;
    int bytes;
    int extra_events;
-    int max_entries;
    int i;
    struct worker_thread_context *thread_contexts;
    struct worker_thread_context *thread_ctx;
@ -127,10 +123,10 @@ int sf_service_init_ex2(SFContext *sf_context, const char *name,
    pthread_t tid;
    pthread_attr_t thread_attr;

-    fc_safe_strcpy(sf_context->name, name);
+    snprintf(sf_context->name, sizeof(sf_context->name), "%s", name);
    sf_context->connect_need_log = true;
-    sf_context->realloc_task_buffer = sf_context->net_buffer_cfg.
-        min_buff_size < sf_context->net_buffer_cfg.max_buff_size;
+    sf_context->realloc_task_buffer = g_sf_global_vars.
+                    min_buff_size < g_sf_global_vars.max_buff_size;
    sf_context->callbacks.accept_done = accept_done_callback;
    sf_set_parameters_ex(sf_context, proto_header_size,
            set_body_length_func, alloc_recv_buffer_func,
@ -143,9 +139,9 @@ int sf_service_init_ex2(SFContext *sf_context, const char *name,
        }
    }

-    if ((result=sf_init_free_queue(sf_context, name, double_buffers,
-                    need_shrink_task_buffer, task_padding_size,
-                    task_arg_size, init_callback, init_arg)) != 0)
+    if ((result=sf_init_free_queue(&sf_context->free_queue,
+                    name, double_buffers, task_padding_size,
+                    task_arg_size, init_callback)) != 0)
    {
        return result;
    }
@ -173,11 +169,7 @@ int sf_service_init_ex2(SFContext *sf_context, const char *name,

    if (SF_G_EPOLL_EDGE_TRIGGER) {
 #ifdef OS_LINUX
-#if IOEVENT_USE_EPOLL
        extra_events = EPOLLET;
-#else
-        extra_events = 0;
-#endif
 #elif defined(OS_FREEBSD)
        extra_events = EV_CLEAR;
 #else
@ -187,40 +179,6 @@ int sf_service_init_ex2(SFContext *sf_context, const char *name,
        extra_events = 0;
    }

-    max_entries = (sf_context->net_buffer_cfg.max_connections +
-            sf_context->work_threads - 1) / sf_context->work_threads;
-    if (strcmp(sf_context->name, "cluster") == 0 ||
-            strcmp(sf_context->name, "replica") == 0)
-    {
-        if (max_entries < 1024) {
-            max_entries += 8;
-        } else {
-            max_entries = 1024;
-        }
-    } else {
-        if (max_entries < 4 * 1024) {
-            max_entries = max_entries * 2;
-        } else if (max_entries < 8 * 1024) {
-            max_entries = (max_entries * 3) / 2;
-        } else if (max_entries < 16 * 1024) {
-            max_entries = (max_entries * 5) / 4;
-        } else if (max_entries < 32 * 1024) {
-            max_entries = (max_entries * 6) / 5;
-        } else if (max_entries < 64 * 1024) {
-            max_entries = (max_entries * 11) / 10;
-        } else if (max_entries < 128 * 1024) {
-            max_entries = (max_entries * 21) / 20;
-        }
-
-#if IOEVENT_USE_URING
-        if (sf_context->use_io_uring) {
-            if (max_entries > 32 * 1024) {
-                max_entries = 32 * 1024;
-            }
-        }
-#endif
-    }
-
    g_current_time = time(NULL);
    sf_context->thread_count = 0;
    data_end = sf_context->thread_data + sf_context->work_threads;
@ -245,45 +203,19 @@ int sf_service_init_ex2(SFContext *sf_context, const char *name,
            thread_data->arg = NULL;
        }

-        if ((result=ioevent_init(&thread_data->ev_puller, sf_context->
-                        name, sf_context->use_io_uring, max_entries,
-                        net_timeout_ms, extra_events)) != 0)
+        if (ioevent_init(&thread_data->ev_puller, 2 + g_sf_global_vars.
+                    max_connections, net_timeout_ms, extra_events) != 0)
        {
-            char prompt[256];
-#if IOEVENT_USE_URING
-            if (sf_context->use_io_uring) {
-                if (result == EPERM) {
-                    strcpy(prompt, " make sure kernel."
-                            "io_uring_disabled set to 0");
-                } else if (result == EINVAL) {
-                    sprintf(prompt, " maybe max_connections: %d is too large"
-                            " or [%s]'s work_threads: %d is too small",
-                            sf_context->net_buffer_cfg.max_connections,
-                            sf_context->name, sf_context->work_threads);
-                } else {
-                    *prompt = '\0';
-                }
-            } else {
-#endif
-                *prompt = '\0';
-#if IOEVENT_USE_URING
-            }
-#endif
-
+            result  = errno != 0 ? errno : ENOMEM;
            logError("file: "__FILE__", line: %d, "
-                "ioevent_init fail, errno: %d, error info: %s.%s"
-                , __LINE__, result, strerror(result), prompt);
+                "ioevent_init fail, "
+                "errno: %d, error info: %s",
+                __LINE__, result, strerror(result));
            return result;
        }

-#if IOEVENT_USE_URING
-        if (sf_context->use_io_uring && send_done_callback != NULL) {
-            ioevent_set_send_zc_done_notify(&thread_data->ev_puller, true);
-        }
-#endif
-
-        result = fast_timer_init(&thread_data->timer, 2 * sf_context->
-                net_buffer_cfg.network_timeout, g_current_time);
+        result = fast_timer_init(&thread_data->timer,
+                2 * g_sf_global_vars.network_timeout, g_current_time);
        if (result != 0) {
            logError("file: "__FILE__", line: %d, "
                    "fast_timer_init fail, errno: %d, error info: %s",
@ -427,9 +359,7 @@ int sf_socket_create_server(SFListener *listener,
        return result;
    }

-    if ((result=tcpsetserveropt(listener->sock, listener->handler->
-                    fh->ctx->net_buffer_cfg.network_timeout)) != 0)
-    {
+    if ((result=tcpsetserveropt(listener->sock, SF_G_NETWORK_TIMEOUT)) != 0) {
        return result;
    }

@ -562,9 +492,7 @@ struct fast_task_info *sf_socket_accept_connection(SFListener *listener)
    }
    FC_SET_CLOEXEC(incomesock);

-    if ((task=sf_alloc_init_server_task(listener->handler,
-                    incomesock)) == NULL)
-    {
+    if ((task=sf_alloc_init_task(listener->handler, incomesock)) == NULL) {
        close(incomesock);
        return NULL;
    }
@ -575,6 +503,12 @@ struct fast_task_info *sf_socket_accept_connection(SFListener *listener)
    return task;
 }

+void sf_socket_close_connection(struct fast_task_info *task)
+{
+    close(task->event.fd);
+    task->event.fd = -1;
+}
+
 void sf_socket_close_ex(SFContext *sf_context)
 {
    int i;
@ -853,13 +787,15 @@ int sf_setup_signal_handler()
    return 0;
 }

+#define LOG_SCHEDULE_ENTRIES_COUNT 3
+
 int sf_startup_schedule(pthread_t *schedule_tid)
 {
    ScheduleArray scheduleArray;
-    ScheduleEntry scheduleEntries[SF_LOG_SCHEDULE_ENTRIES_COUNT];
+    ScheduleEntry scheduleEntries[LOG_SCHEDULE_ENTRIES_COUNT];

    scheduleArray.entries = scheduleEntries;
-    sf_logger_setup_schedule(&g_log_context, &g_sf_global_vars.error_log,
+    sf_setup_schedule(&g_log_context, &g_sf_global_vars.error_log,
            &scheduleArray);
    return sched_start(&scheduleArray, schedule_tid,
            g_sf_global_vars.thread_stack_size, (bool * volatile)
@ -870,7 +806,7 @@ int sf_add_slow_log_schedule(SFSlowLogContext *slowlog_ctx)
 {
    int result;
    ScheduleArray scheduleArray;
-    ScheduleEntry scheduleEntries[SF_LOG_SCHEDULE_ENTRIES_COUNT];
+    ScheduleEntry scheduleEntries[LOG_SCHEDULE_ENTRIES_COUNT];

    if (!slowlog_ctx->cfg.enabled) {
        return 0;
@ -883,8 +819,8 @@ int sf_add_slow_log_schedule(SFSlowLogContext *slowlog_ctx)
    }

    scheduleArray.entries = scheduleEntries;
-    sf_logger_setup_schedule(&slowlog_ctx->ctx, &slowlog_ctx->
-            cfg.log_cfg, &scheduleArray);
+    sf_setup_schedule(&slowlog_ctx->ctx, &slowlog_ctx->cfg.log_cfg,
+            &scheduleArray);
    return sched_add_entries(&scheduleArray);
 }

--- a/src/sf_service.h
+++ b/src/sf_service.h
@ -25,9 +25,6 @@
 #include "fastcommon/ioevent.h"
 #include "fastcommon/fast_task_queue.h"
 #include "sf_types.h"
-#include "sf_proto.h"
-#include "sf_global.h"
-#include "sf_nio.h"

 typedef void* (*sf_alloc_thread_extra_data_callback)(const int thread_index);
 typedef void (*sf_sig_quit_handler)(int sig);
@ -48,8 +45,7 @@ int sf_service_init_ex2(SFContext *sf_context, const char *name,
        sf_recv_timeout_callback timeout_callback, const int net_timeout_ms,
        const int proto_header_size, const int task_padding_size,
        const int task_arg_size, const bool double_buffers,
-        const bool need_shrink_task_buffer, const bool explicit_post_recv,
-        TaskInitCallback init_callback, void *init_arg,
+        const bool explicit_post_recv, TaskInitCallback init_callback,
        sf_release_buffer_callback release_buffer_callback);

 #define sf_service_init_ex(sf_context, name, alloc_thread_extra_data_callback,\
@ -60,7 +56,7 @@ int sf_service_init_ex2(SFContext *sf_context, const char *name,
        thread_loop_callback, accept_done_callback, set_body_length_func,     \
        NULL, send_done_callback, deal_func, task_cleanup_func, \
        timeout_callback, net_timeout_ms, proto_header_size, \
-        0, task_arg_size, false, true, false, NULL, NULL, NULL)
+        0, task_arg_size, false, false, NULL, NULL)

 #define sf_service_init(name, alloc_thread_extra_data_callback, \
        thread_loop_callback, accept_done_callback, set_body_length_func,   \
@ -69,8 +65,8 @@ int sf_service_init_ex2(SFContext *sf_context, const char *name,
    sf_service_init_ex2(&g_sf_context, name, alloc_thread_extra_data_callback, \
        thread_loop_callback, accept_done_callback, set_body_length_func, NULL,\
        send_done_callback, deal_func, task_cleanup_func, timeout_callback, \
-        net_timeout_ms, proto_header_size, 0, task_arg_size, false, true,   \
-        false, NULL, NULL, NULL)
+        net_timeout_ms, proto_header_size, 0, task_arg_size, false, false,  \
+        NULL, NULL)

 int sf_service_destroy_ex(SFContext *sf_context);

@ -112,6 +108,8 @@ int sf_socket_create_server(SFListener *listener,
 void sf_socket_close_server(SFListener *listener);
 struct fast_task_info *sf_socket_accept_connection(SFListener *listener);

+void sf_socket_close_connection(struct fast_task_info *task);
+
 int sf_socket_server_ex(SFContext *sf_context);
 #define sf_socket_server() sf_socket_server_ex(&g_sf_context)

@ -150,6 +148,8 @@ void sf_notify_all_threads_ex(SFContext *sf_context);

 void sf_set_sig_quit_handler(sf_sig_quit_handler quit_handler);

+int sf_init_task(struct fast_task_info *task);
+
 static inline struct fast_task_info *sf_alloc_init_task_ex(
        SFNetworkHandler *handler, const int fd,
        const int reffer_count)
@ -165,11 +165,6 @@ static inline struct fast_task_info *sf_alloc_init_task_ex(
        return NULL;
    }

-    if (task->shrinked) {
-        task->shrinked = false;
-        sf_proto_init_task_magic(task);
-    }
-
    __sync_add_and_fetch(&task->reffer_count, reffer_count);
    __sync_bool_compare_and_swap(&task->canceled, 1, 0);
    task->handler = handler;
@ -177,42 +172,9 @@ static inline struct fast_task_info *sf_alloc_init_task_ex(
    return task;
 }

-#define sf_hold_task_ex(task, inc_count)  fc_hold_task_ex(task, inc_count)
-#define sf_hold_task(task)  fc_hold_task(task)
-
+#define sf_hold_task(task) __sync_add_and_fetch(&task->reffer_count, 1)
 #define sf_alloc_init_task(handler, fd) sf_alloc_init_task_ex(handler, fd, 1)

-static inline struct fast_task_info *sf_alloc_init_server_task(
-        SFNetworkHandler *handler, const int fd)
-{
-    const int reffer_count = 1;
-    struct fast_task_info *task;
-
-    if ((task=sf_alloc_init_task_ex(handler, fd, reffer_count)) != NULL) {
-#if IOEVENT_USE_URING
-        FC_URING_IS_CLIENT(task) = false;
-#endif
-    }
-
-    return task;
-}
-
-static inline struct fast_task_info *sf_alloc_init_client_task(
-        SFNetworkHandler *handler)
-{
-    const int fd = -1;
-    const int reffer_count = 1;
-    struct fast_task_info *task;
-
-    if ((task=sf_alloc_init_task_ex(handler, fd, reffer_count)) != NULL) {
-#if IOEVENT_USE_URING
-        FC_URING_IS_CLIENT(task) = true;
-#endif
-    }
-
-    return task;
-}
-
 static inline void sf_release_task(struct fast_task_info *task)
 {
    if (__sync_sub_and_fetch(&task->reffer_count, 1) == 0) {
@ -224,15 +186,6 @@ static inline void sf_release_task(struct fast_task_info *task)
                "used: %d, freed: %d", __LINE__, task,
                alloc_count, alloc_count - free_count, free_count);
                */
-
-#if IOEVENT_USE_URING
-        if (SF_CTX->use_io_uring) {
-            task->handler->close_connection(task);
-            __sync_fetch_and_sub(&g_sf_global_vars.
-                    connection_stat.current_count, 1);
-        }
-#endif
-
        free_queue_push(task);
    }
 }
@ -308,19 +261,6 @@ static inline SFNetworkHandler *sf_get_rdma_network_handler3(
    return sf_get_rdma_network_handler(sf_context3);
 }

-static inline bool sf_get_double_buffers_flag(FCServerGroupInfo *server_group)
-{
-    if (server_group->comm_type == fc_comm_type_sock) {
-#if IOEVENT_USE_URING
-        return true;
-#else
-        return false;
-#endif
-    } else {  //RDMA
-        return true;
-    }
-}
-
 #ifdef __cplusplus
 }
 #endif
--- a/src/sf_types.h
+++ b/src/sf_types.h
@ -42,11 +42,6 @@
 #define SF_SOCKET_NETWORK_HANDLER_INDEX   0
 #define SF_RDMACM_NETWORK_HANDLER_INDEX   1

-#define SF_BINLOG_BUFFER_PRODUCER_DATA_LENGTH(bf) ((bf).data_end - (bf).buff)
-#define SF_BINLOG_BUFFER_PRODUCER_BUFF_REMAIN(bf) ((bf).buff_end - (bf).data_end)
-#define SF_BINLOG_BUFFER_CONSUMER_DATA_LENGTH(bf) ((bf).current  - (bf).buff)
-#define SF_BINLOG_BUFFER_CONSUMER_DATA_REMAIN(bf) ((bf).data_end - (bf).current)
-
 typedef int (*sf_accept_done_callback)(struct fast_task_info *task,
        const in_addr_64_t client_addr, const bool bInnerPort);
 typedef int (*sf_set_body_length_callback)(struct fast_task_info *task);
@ -115,7 +110,6 @@ typedef struct sf_listener {

 struct sf_context;
 struct sf_address_family_handler;
-
 typedef struct sf_network_handler {
    bool enabled;
    bool explicit_post_recv;
@ -166,32 +160,20 @@ typedef struct sf_address_family_handler {
    struct sf_context *ctx;
 } SFAddressFamilyHandler;

-typedef struct sf_net_buffer_config {
-    int connect_timeout;
-    int network_timeout;
-    int max_connections;
-    int max_pkg_size;
-    int min_buff_size;
-    int max_buff_size;
-} SFNetBufferConfig;
-
 typedef struct sf_context {
    char name[64];
    struct nio_thread_data *thread_data;
    volatile int thread_count;

-    bool is_client;    //since v1.2.5
-    bool use_io_uring; //since v1.2.9
-    bool use_send_zc;  //since v1.2.9
+    //int rdma_port_offset;
    SFAddressFamily address_family;
    SFAddressFamilyHandler handlers[SF_ADDRESS_FAMILY_COUNT];

-    SFNetBufferConfig net_buffer_cfg;
-
    int accept_threads;
    int work_threads;

    int header_size;
+    bool remove_from_ready_list;
    bool realloc_task_buffer;
    bool connect_need_log;  //for client connect
    FCSmartPollingConfig smart_polling;
@ -239,8 +221,7 @@ typedef struct sf_binlog_file_position {
 typedef struct server_binlog_buffer {
    char *buff;    //the buffer pointer
    char *current; //for the consumer
-    char *data_end;   //data end ptr
-    char *buff_end;   //buffer end ptr
+    char *end;     //data end ptr
    int size;      //the buffer size (capacity)
 } SFBinlogBuffer;

@ -370,7 +351,6 @@ typedef struct sf_synchronize_context {
    int result;
    union {
        bool finished;
-        bool ready;
        int waiting_count;
    };
 } SFSynchronizeContext;
--- a/src/sf_util.c
+++ b/src/sf_util.c
@ -281,7 +281,7 @@ int sf_logger_init(LogContext *pContext, const char *filename_prefix)
    return 0;
 }

-ScheduleEntry *sf_logger_set_schedule_entries(struct log_context *pContext,
+ScheduleEntry *sf_logger_set_schedule_entry(struct log_context *pContext,
        SFLogConfig *log_cfg, ScheduleEntry *pScheduleEntry)
 {
    INIT_SCHEDULE_ENTRY(*pScheduleEntry, sched_generate_next_id(),
--- a/src/sf_util.h
+++ b/src/sf_util.h
@ -96,14 +96,14 @@ void sf_parse_cmd_option_bool(int argc, char *argv[],

 int sf_logger_init(LogContext *pContext, const char *filename_prefix);

-ScheduleEntry *sf_logger_set_schedule_entries(struct log_context *pContext,
+ScheduleEntry *sf_logger_set_schedule_entry(struct log_context *pContext,
        SFLogConfig *log_cfg, ScheduleEntry *pScheduleEntry);

-static inline void sf_logger_setup_schedule(struct log_context *pContext,
+static inline void sf_setup_schedule(struct log_context *pContext,
        SFLogConfig *log_cfg, ScheduleArray *scheduleArray)
 {
    ScheduleEntry *scheduleEntry;
-    scheduleEntry = sf_logger_set_schedule_entries(pContext,
+    scheduleEntry = sf_logger_set_schedule_entry(pContext,
            log_cfg, scheduleArray->entries);
    scheduleArray->count = scheduleEntry - scheduleArray->entries;
 }