debian/changelog

@@ -1,33 +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

debian/substvars

@@ -1 +1 @@
-libfastcommon:Version=1.0.83
+libfastcommon:Version=1.0.75

libserverframe.spec

@@ -2,7 +2,7 @@
 %define CommitVersion %(echo $COMMIT_VERSION)
 
 Name: libserverframe
-Version: 1.2.11
+Version: 1.2.7
 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.77
 Requires: %__cp %__mv %__chmod %__grep %__mkdir %__install %__id
-Requires: libfastcommon >= 1.0.83
+Requires: libfastcommon >= 1.0.77
 
 %description
 common framework library 

make.sh

@@ -9,13 +9,10 @@ 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;}')
 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;}')
 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

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);
+        sf_release_task(task);
-        free_queue_push(task);
         return NULL;
     }
     return task;
@@ -216,14 +215,6 @@ int idempotency_client_channel_check_reconnect(
     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;
     }
@@ -240,9 +231,6 @@ int idempotency_client_channel_check_reconnect(
                 formatted_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 +255,7 @@ struct idempotency_client_channel *idempotency_client_channel_get(
     IdempotencyClientChannel *current;
     IdempotencyClientChannel *channel;
 
-    key_len = strlen(server_ip);
+    key_len = snprintf(key, sizeof(key), "%s-%u", server_ip, server_port);
-    memcpy(key, server_ip, key_len);
-    *(key + key_len++) = '-';
-    key_len += fc_itoa(server_port, key + key_len);
     hash_code = fc_simple_hash(key, key_len);
     bucket = channel_context.htable.buckets +
         hash_code % channel_context.htable.capacity;
@@ -354,8 +339,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 (__sync_add_and_fetch(&channel->in_ioevent, 0)) {
-            if (FC_ATOMIC_GET(channel->established)) {
+            if (__sync_add_and_fetch(&channel->established, 0)) {
                 sf_nio_notify(channel->task, SF_NIO_STAGE_CONTINUE);
             }
         } else {

src/idempotency/client/client_channel.h

@@ -76,13 +76,13 @@ 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 {
         /*

src/idempotency/client/receipt_handler.c

@@ -49,10 +49,6 @@ static IdempotencyReceiptGlobalVars receipt_global_vars;
 
 static int receipt_init_task(struct fast_task_info *task, void *arg)
 {
-#if IOEVENT_USE_URING
-    FC_URING_IS_CLIENT(task) = true;
-#endif
-
     if (RDMA_INIT_CONNECTION != NULL) {
         return RDMA_INIT_CONNECTION(task, arg);
     } else {
@@ -96,6 +92,7 @@ static void receipt_task_finish_cleanup(struct fast_task_info *task)
 
     if (task->event.fd >= 0) {
         sf_task_detach_thread(task);
+        task->handler->close_connection(task);
     }
 
     sf_nio_reset_task_length(task);
@@ -285,7 +282,7 @@ static int deal_setup_channel_response(struct fast_task_info *task)
     }
 
     channel = (IdempotencyClientChannel *)task->arg;
-    if (FC_ATOMIC_GET(channel->established)) {
+    if (__sync_add_and_fetch(&channel->established, 0)) {
         format_ip_address(task->server_ip, formatted_ip);
         logWarning("file: "__FILE__", line: %d, "
                 "response from server %s:%u, unexpected cmd: "
@@ -523,7 +520,6 @@ 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;
@@ -556,8 +552,8 @@ static int do_init(FCAddressPtrArray *address_array)
             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,
+            task_arg_size, double_buffers, explicit_post_recv,
-            explicit_post_recv, receipt_init_task, pd, NULL);
+            receipt_init_task, pd, NULL);
 }
 
 int receipt_handler_init(FCAddressPtrArray *address_array)
@@ -569,6 +565,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;

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 += sprintf(p, "%d %"PRId64"\n",
-    p += fc_itoa(ctx->index_array.count, p);
+            ctx->index_array.count,
-    *p++ = ' ';
+            ctx->last_version);
-    p += fc_itoa(ctx->last_version, p);
-    *p++ = '\n';
 
     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;
     }

src/sf_binlog_writer.c

@@ -305,7 +305,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 +333,8 @@ void sf_binlog_writer_finish(SFBinlogWriterInfo *writer)
             deal_binlog_records(writer->thread, wb_head, &last_timestamp);
         }
 
-        free(writer->fw.file.name.str);
+        free(writer->fw.file.name);
-        writer->fw.file.name.str = NULL;
+        writer->fw.file.name = NULL;
     }
 
     if (writer->fw.file.fd >= 0) {
@@ -357,7 +357,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
@@ -496,7 +497,7 @@ 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;

src/sf_binlog_writer.h

@@ -132,14 +132,14 @@ int sf_binlog_writer_init_thread_ex(SFBinlogWriterThread *thread,
 
 #define sf_binlog_writer_init_normal(writer, data_path, \
         subdir_name, max_record_size, buffer_size)      \
-    sf_binlog_writer_init_normal_ex(writer, data_path, subdir_name,  \
+    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, max_record_size, 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)           \
     sf_binlog_writer_init_by_version_ex(writer, data_path, subdir_name,  \
-            SF_BINLOG_FILE_PREFIX_STR, max_record_size, next_version,    \
+            SF_BINLOG_FILE_PREFIX, max_record_size, next_version,        \
             buffer_size, ring_size, SF_BINLOG_DEFAULT_ROTATE_SIZE, true)
 
 #define sf_binlog_writer_init_thread(thread, name, \
@@ -169,7 +169,7 @@ static inline int sf_binlog_writer_init_ex(SFBinlogWriterContext *context,
 #define sf_binlog_writer_init(context, data_path, subdir_name,      \
         buffer_size, write_interval_ms, 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,  \
+            SF_BINLOG_FILE_PREFIX, buffer_size, write_interval_ms,  \
             max_delay, max_record_size, true)
 
 void sf_binlog_writer_finish(SFBinlogWriterInfo *writer);

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);

src/sf_define.h

@@ -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

src/sf_file_writer.c

@@ -34,69 +34,25 @@
 #include "sf_func.h"
 #include "sf_file_writer.h"
 
-#define BINLOG_INDEX_ITEM_START_INDEX_STR       "start_index"
+#define BINLOG_INDEX_ITEM_START_INDEX       "start_index"
-#define BINLOG_INDEX_ITEM_START_INDEX_LEN      \
+#define BINLOG_INDEX_ITEM_CURRENT_WRITE     "current_write"
-    (sizeof(BINLOG_INDEX_ITEM_START_INDEX_STR) - 1)
+#define BINLOG_INDEX_ITEM_CURRENT_COMPRESS  "current_compress"
 
-#define BINLOG_INDEX_ITEM_CURRENT_WRITE_STR     "current_write"
+#define GET_BINLOG_FILENAME(writer) \
-#define BINLOG_INDEX_ITEM_CURRENT_WRITE_LEN      \
+    sprintf(writer->file.name, "%s/%s/%s"SF_BINLOG_FILE_EXT_FMT, \
-    (sizeof(BINLOG_INDEX_ITEM_CURRENT_WRITE_STR) - 1)
+            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 GET_BINLOG_INDEX_FILENAME_EX(data_path,    \
-#define BINLOG_INDEX_ITEM_CURRENT_COMPRESS_LEN      \
+        subdir_name, file_prefix, filename, size)  \
-    (sizeof(BINLOG_INDEX_ITEM_CURRENT_COMPRESS_STR) - 1)
+    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';
-}
 
 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,
+    GET_BINLOG_INDEX_FILENAME_EX(data_path, subdir_name,
-            SF_BINLOG_FILE_PREFIX_STR, SF_BINLOG_FILE_PREFIX_LEN,
+            SF_BINLOG_FILE_PREFIX, filename, size);
-            filename, size);
     return filename;
 }
 
@@ -107,35 +63,17 @@ int sf_file_writer_write_to_binlog_index_file_ex(const char *data_path,
 {
     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,
+    GET_BINLOG_INDEX_FILENAME_EX(data_path, subdir_name,
-            strlen(file_prefix), filename, sizeof(filename));
+            file_prefix, filename, sizeof(filename));
-    p = buff;
+    len = sprintf(buff, "%s=%d\n"
-    memcpy(p, BINLOG_INDEX_ITEM_START_INDEX_STR,
+            "%s=%d\n"
-            BINLOG_INDEX_ITEM_START_INDEX_LEN);
+            "%s=%d\n",
-    p += BINLOG_INDEX_ITEM_START_INDEX_LEN;
+            BINLOG_INDEX_ITEM_START_INDEX, start_index,
-    *p++ = '=';
+            BINLOG_INDEX_ITEM_CURRENT_WRITE, last_index,
-    p += fc_itoa(start_index, p);
+            BINLOG_INDEX_ITEM_CURRENT_COMPRESS, compress_index);
-    *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;
     if ((result=safeWriteToFile(filename, buff, len)) != 0) {
         logError("file: "__FILE__", line: %d, "
                 "write to file \"%s\" fail, errno: %d, error info: %s",
@@ -161,8 +99,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,
+    GET_BINLOG_INDEX_FILENAME_EX(data_path,
-            SF_BINLOG_FILE_PREFIX_STR, SF_BINLOG_FILE_PREFIX_LEN,
+            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 +114,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 +170,14 @@ static int open_writable_binlog(SFFileWriterInfo *writer)
         close(writer->file.fd);
     }
 
-    sf_file_writer_get_binlog_filename(writer);
+    GET_BINLOG_FILENAME(writer);
-    writer->file.fd = open(writer->file.name.str, O_WRONLY |
+    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 +187,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 +197,23 @@ static int open_writable_binlog(SFFileWriterInfo *writer)
 
 static int open_next_binlog(SFFileWriterInfo *writer)
 {
-    sf_file_writer_get_binlog_filename(writer);
+    GET_BINLOG_FILENAME(writer);
-    if (access(writer->file.name.str, F_OK) == 0) {
+    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",
+        snprintf(bak_filename, sizeof(bak_filename), "%s.%s",
-                date_str, sizeof(date_str));
+                writer->file.name, formatDatetime(g_current_time,
-        fc_combine_two_strings(writer->file.name.str,
+                    "%Y%m%d%H%M%S", date_str, sizeof(date_str)));
-                date_str, '.', bak_filename);
+        if (rename(writer->file.name, bak_filename) == 0) {
-        if (rename(writer->file.name.str, 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 +232,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;
     }
@@ -305,7 +242,7 @@ static int do_write_to_file(SFFileWriterInfo *writer,
             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,
+                    "error info: %s", __LINE__, writer->file.name,
                     result, STRERROR(result));
             return result;
         }
@@ -339,7 +276,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;
     }
 
@@ -382,7 +319,7 @@ int sf_file_writer_fsync(SFFileWriterInfo *writer)
         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,
+                "error info: %s", __LINE__, writer->file.name,
                 result, STRERROR(result));
         return result;
     }
@@ -506,7 +443,8 @@ int sf_file_writer_init(SFFileWriterInfo *writer, const char *data_path,
     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 +453,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);
+    snprintf(writer->cfg.subdir_name,
-    fc_safe_strcpy(writer->cfg.file_prefix, file_prefix);
+            sizeof(writer->cfg.subdir_name),
-    writer->file.name.size = path_len + 32;
+            "%s", subdir_name);
-    writer->file.name.str = (char *)fc_malloc(writer->file.name.size);
+    snprintf(writer->cfg.file_prefix,
-    if (writer->file.name.str == NULL) {
+            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 +481,9 @@ void sf_file_writer_destroy(SFFileWriterInfo *writer)
         close(writer->file.fd);
         writer->file.fd = -1;
     }
-    if (writer->file.name.str != NULL) {
+    if (writer->file.name != NULL) {
-        free(writer->file.name.str);
+        free(writer->file.name);
-        writer->file.name.str = NULL;
+        writer->file.name = NULL;
     }
     sf_binlog_buffer_destroy(&writer->binlog_buffer);
 }

src/sf_file_writer.h

@@ -24,13 +24,11 @@
 #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          "binlog"
-#define SF_BINLOG_FILE_PREFIX_LEN      (sizeof(SF_BINLOG_FILE_PREFIX_STR) - 1)
+#define SF_BINLOG_FILE_EXT_FMT         ".%06d"
-#define SF_BINLOG_FILE_EXT_LEN 6
-#define SF_BINLOG_FILE_EXT_FMT ".%0"FC_MACRO_TOSTRING(SF_BINLOG_FILE_EXT_LEN)"d"
 
 struct sf_file_writer_info;
 
@@ -41,7 +39,7 @@ 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 +53,8 @@ typedef struct sf_file_writer_info {
 
     struct {
         int fd;
-        int64_t size;  //file size
+        int64_t size;
-        struct {
+        char *name;
-            char *str;
-            int size;
-        } name;
     } file;
 
     int64_t total_count;
@@ -227,8 +222,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),
+    snprintf(filepath, size, "%s/%s", data_path, subdir_name);
-            subdir_name, strlen(subdir_name), filepath, size);
     return filepath;
 }
 
@@ -237,41 +231,15 @@ static inline const char *sf_file_writer_get_filename_ex(
         const char *file_prefix, const int binlog_index,
         char *filename, const int size)
 {
-    char *p;
+    snprintf(filename, size, "%s/%s/%s"SF_BINLOG_FILE_EXT_FMT,
-    int data_path_len;
+            data_path, subdir_name, file_prefix, binlog_index);
-    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);
@@ -314,7 +282,7 @@ int sf_file_writer_write_to_binlog_index_file_ex(const char *data_path,
 #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)
+            SF_BINLOG_FILE_PREFIX, start_index, last_index, 0)
 
 #ifdef __cplusplus
 }

src/sf_global.c

@@ -47,12 +47,11 @@ SFGlobalVariables g_sf_global_vars = {
     {0, 0}, NULL, {NULL, 0}
 };
 
-SFContext g_sf_context = {{'\0'}, NULL, 0, false, false, false,
+SFContext g_sf_context = {{'\0'}, NULL, 0, false, sf_address_family_auto,
-    sf_address_family_auto, {{AF_UNSPEC, {{true, fc_comm_type_sock},
+    {{AF_UNSPEC, {{true, fc_comm_type_sock}, {false, fc_comm_type_rdma}}},
-        {false, fc_comm_type_rdma}}},
+        {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,
+    SF_DEF_MAX_BUFF_SIZE}, 1, DEFAULT_WORK_THREADS, 0, true, true, true,
     {false, 0, 0}, {sf_task_finish_clean_up}
 };
 
@@ -221,7 +220,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 +250,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 +271,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)
@@ -330,7 +329,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 +356,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();
@@ -522,7 +525,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 +535,9 @@ static void set_bind_address(const char *bind_addr, char *ipv4_bind_addr,
                 ++ip_addr;
                 len -= 2;
             }
-            if (len >= addr_size) {
+            snprintf(ipv6_bind_addr, addr_size, "%.*s", len, ip_addr);
-                len = addr_size - 1;
-            }
-            memcpy(ipv6_bind_addr, ip_addr, len);
-            *(ipv6_bind_addr + len) = '\0';
         } else {
-            fc_strlcpy(ipv4_bind_addr, ip_addr, addr_size);
+            snprintf(ipv4_bind_addr, addr_size, "%s", ip_addr);
         }
     }
 }
@@ -670,10 +669,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 +705,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;
@@ -763,14 +747,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,
@@ -887,7 +865,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 +935,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,
@@ -1032,27 +1005,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, ",
+            "network_timeout=%d, thread_stack_size=%d KB, "
-            SF_G_BASE_PATH_STR,
+            "%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.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);
+            g_sf_global_vars.thread_stack_size / 1024,
-
+            pkg_buff, g_sf_global_vars.tcp_quick_ack,
-#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,
             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 +1028,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) {
+    logInfo("%s, %s%s%s",
-        sf_context_config_to_string(&g_sf_context, sz_context_config,
+            sz_global_config, 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,
             (other_config != NULL && *other_config != '\0')  ? ", " : "",
             (other_config != NULL) ? other_config : ""
            );
@@ -1083,8 +1042,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 +1057,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->len = strlen(SF_G_BASE_PATH_STR) + strlen(data_path) + 1;
-        path->str = (char *)fc_malloc(path_size);
+        path->str = (char *)fc_malloc(path->len + 1);
         if (path->str == NULL) {
             return ENOMEM;
         }
-
+        path->len = sprintf(path->str, "%s/%s",
-        path->len = fc_get_full_filepath_ex(SF_G_BASE_PATH_STR,
+                SF_G_BASE_PATH_STR, data_path);
-                SF_G_BASE_PATH_LEN, data_path, data_path_len,
-                path->str, path_size);
     }
     chopPath(path->str);
     path->len = strlen(path->str);

src/sf_global.h

@@ -32,7 +32,6 @@ typedef struct sf_connection_stat {
 typedef struct sf_global_variables {
     struct {
         char str[MAX_PATH_SIZE];
-        int len;
         bool inited;
         bool created;
     } base_path;
@@ -80,7 +79,6 @@ 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
@@ -319,8 +317,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,
+    normalize_path(NULL, &path_string, SF_G_BASE_PATH_STR,
-            SF_G_BASE_PATH_STR, sizeof(SF_G_BASE_PATH_STR));
+            sizeof(SF_G_BASE_PATH_STR));
     SF_G_BASE_PATH_INITED = true;
 }
 

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
+    ioevent_detach(&task->thread_data->ev_puller, task->event.fd);
-    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);
+    task->handler->close_connection(task);
 
-#if IOEVENT_USE_URING
+    __sync_fetch_and_sub(&g_sf_global_vars.connection_stat.current_count, 1);
-    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
-
     sf_release_task(task);
 }
 
@@ -176,115 +139,46 @@ 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 (task->event.callback == (IOEventCallback)sf_client_sock_read) {
-    if (SF_CTX->use_io_uring) {
+        return 0;
-        if (FC_URING_OP_TYPE(task) != IORING_OP_NOP) {
+    }
-            if (FC_URING_OP_TYPE(task) == IORING_OP_RECV) {
+
-                logWarning("file: "__FILE__", line: %d, "
+    task->event.callback = (IOEventCallback)sf_client_sock_read;
-                        "trigger recv again!", __LINE__);
+    if (ioevent_modify(&task->thread_data->ev_puller,
-                return 0;
+                task->event.fd, IOEVENT_READ, task) != 0)
-            } else {
+    {
-                logWarning("file: "__FILE__", line: %d, "
+        result = errno != 0 ? errno : ENOENT;
-                        "another operation in progress, op_type: %d!",
+        ioevent_add_to_deleted_list(task);
-                        __LINE__, FC_URING_OP_TYPE(task));
+
-                return EBUSY;
+        logError("file: "__FILE__", line: %d, "
-            }
+                "ioevent_modify fail, "
-        }
+                "errno: %d, error info: %s",
-
+                __LINE__, result, strerror(result));
-        if (task->event.callback != (IOEventCallback)sf_client_sock_read) {
+        return result;
-            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)
-        {
-            result = errno != 0 ? errno : ENOENT;
-            ioevent_add_to_deleted_list(task);
-
-            logError("file: "__FILE__", line: %d, "
-                    "ioevent_modify fail, "
-                    "errno: %d, error info: %s",
-                    __LINE__, result, strerror(result));
-            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,
+            IOEVENT_READ, callback, timeout);
-            SF_CTX->net_buffer_cfg.network_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,
+            SF_CTX->net_buffer_cfg.network_timeout);
 }
 
 int sf_socket_async_connect_check(struct fast_task_info *task)
@@ -317,7 +212,7 @@ 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;
@@ -325,31 +220,16 @@ static int sf_client_connect_done(int sock, const int event, void *arg)
 
     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
+        result = task->handler->async_connect_check(task);
-        if (SF_CTX->use_io_uring) {
+        if (result == EINPROGRESS) {
-            CLEAR_OP_TYPE_AND_RELEASE_TASK(task);
+            return 0;
-            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) {
@@ -380,26 +260,14 @@ 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 ((task->event.fd=socketCreateEx2(AF_UNSPEC, task->server_ip,
-#if IOEVENT_USE_URING
+                    O_NONBLOCK, NULL, &result)) < 0)
-    if (SF_CTX->use_io_uring) {
+    {
-        if ((result=uring_prep_connect(task)) != 0) {
+        return result > 0 ? -1 * result : result;
-            return result;
-        }
-        return EINPROGRESS;
-    } else {
-#endif
-        if ((task->event.fd=socketCreateEx2(AF_UNSPEC, task->server_ip,
-                        O_NONBLOCK, NULL, &result)) < 0)
-        {
-            return result > 0 ? -1 * result : result;
-        }
-
-        return asyncconnectserverbyip(task->event.fd,
-                task->server_ip, task->port);
-#if IOEVENT_USE_URING
     }
-#endif
+
+    return asyncconnectserverbyip(task->event.fd,
+            task->server_ip, task->port);
 }
 
 static int sf_async_connect_server(struct fast_task_info *task)
@@ -419,7 +287,10 @@ 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, SF_CTX->
+                            net_buffer_cfg.network_timeout)) != 0)
+            {
                 return result;
             }
 
@@ -460,12 +331,10 @@ 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,
-                    if (sf_client_sock_read(task->event.fd,
+                            IOEVENT_READ, task) < 0)
-                                IOEVENT_READ, task) < 0)
+                {
-                    {
+                    result = errno != 0 ? errno : EIO;
-                        result = errno != 0 ? errno : EIO;
-                    }
                 }
             }
             break;
@@ -476,7 +345,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,
+                            SF_CTX->net_buffer_cfg.network_timeout)) == 0)
+            {
                 result = SF_CTX->callbacks.deal_task(task, SF_NIO_STAGE_SEND);
             }
             break;
@@ -544,7 +416,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 +435,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 +463,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;
+    thread_data = ((struct ioevent_notify_entry *)arg)->thread_data;
-    if (read(fd, &n, sizeof(n)) < 0) {
+    if (read(sock, &n, sizeof(n)) < 0) {
-#if IOEVENT_USE_URING
-        if (errno == EAGAIN) {
-            return;
-        }
-#endif
-
         logWarning("file: "__FILE__", line: %d, "
-                "read from fd %d fail, errno: %d, error info: %s",
+                "read from eventfd %d fail, errno: %d, error info: %s",
-                __LINE__, fd, errno, STRERROR(errno));
+                __LINE__, sock, errno, STRERROR(errno));
     }
 
-    PTHREAD_MUTEX_LOCK(&notify_entry->thread_data->waiting_queue.lock);
+    PTHREAD_MUTEX_LOCK(&thread_data->waiting_queue.lock);
-    current = notify_entry->thread_data->waiting_queue.head;
+    current = thread_data->waiting_queue.head;
-    notify_entry->thread_data->waiting_queue.head = NULL;
+    thread_data->waiting_queue.head = NULL;
-    notify_entry->thread_data->waiting_queue.tail = NULL;
+    thread_data->waiting_queue.tail = NULL;
-    PTHREAD_MUTEX_UNLOCK(&notify_entry->thread_data->waiting_queue.lock);
+    PTHREAD_MUTEX_UNLOCK(&thread_data->waiting_queue.lock);
 
     while (current != NULL) {
         task = current;
@@ -634,7 +499,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 +508,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_client_sock_write(task->event.fd, IOEVENT_WRITE, task) < 0) {
-        if (SF_CTX->use_io_uring) {
+            return errno != 0 ? errno : EIO;
-            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 +537,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,69 +553,28 @@ 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 (task->iovec_array.iovs != NULL) {
-    if (SF_CTX->use_io_uring) {
+        bytes = writev(task->event.fd, task->iovec_array.iovs,
-        bytes = task->event.res;
+                FC_MIN(task->iovec_array.count, IOV_MAX));
     } else {
-#endif
+        bytes = write(task->event.fd, task->send.ptr->data +
-        if (task->iovec_array.iovs != NULL) {
+                task->send.ptr->offset, task->send.ptr->length -
-            bytes = writev(task->event.fd, task->iovec_array.iovs,
+                task->send.ptr->offset);
-                    FC_MIN(task->iovec_array.count, IOV_MAX));
-        } else {
-            bytes = write(task->event.fd, task->send.ptr->data +
-                    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 (errno == EAGAIN || errno == EWOULDBLOCK)
-        if (SF_CTX->use_io_uring) {
+        {
-            result = -bytes;
+            if (set_write_event(task) != 0) {
-        } else {
+                return -1;
-#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 (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) {
+        } else if (errno == EINTR) {  //should retry
-            /* should try again */
             logDebug("file: "__FILE__", line: %d, "
                     "client ip: %s, ignore interupt signal",
                     __LINE__, task->client_ip);
@@ -789,40 +585,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 (task->send.ptr != task->recv.ptr) {  //double buffers
-        if (SF_CTX->use_io_uring && FC_URING_IS_SEND_ZC(task) &&
+            task->send.ptr->offset = 0;
-                task->thread_data->ev_puller.send_zc_done_notify)
+            task->send.ptr->length = 0;
-        {
-            *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
+        *action = sf_comm_action_finish;
-
+        *send_done = true;
     } 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 +637,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,56 +646,30 @@ 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 (task->recv.ptr->length == 0) { //recv header
-    if (SF_CTX->use_io_uring) {
+        recv_bytes = SF_CTX->header_size - task->recv.ptr->offset;
-        bytes = task->event.res;
+        bytes = read(task->event.fd, task->recv.ptr->data +
+                task->recv.ptr->offset, recv_bytes);
     } else {
-#endif
+        recv_bytes = task->recv.ptr->length - task->recv.ptr->offset;
-        if (task->recv.ptr->length == 0) { //recv header
+        if (task->recv_body == NULL) {
-            recv_bytes = SF_CTX->header_size - task->recv.ptr->offset;
             bytes = read(task->event.fd, task->recv.ptr->data +
                     task->recv.ptr->offset, recv_bytes);
         } else {
-            recv_bytes = task->recv.ptr->length - task->recv.ptr->offset;
+            bytes = read(task->event.fd, task->recv_body +
-            if (task->recv_body == NULL) {
+                    (task->recv.ptr->offset - SF_CTX->
-                bytes = read(task->event.fd, task->recv.ptr->data +
+                     header_size), recv_bytes);
-                        task->recv.ptr->offset, recv_bytes);
-            } else {
-                bytes = read(task->event.fd, task->recv_body +
-                        (task->recv.ptr->offset - SF_CTX->
-                         header_size), recv_bytes);
-            }
         }
-#if IOEVENT_USE_URING
     }
-#endif
 
     if (bytes < 0) {
-#if IOEVENT_USE_URING
+        if (errno == EAGAIN || errno == EWOULDBLOCK) {
-        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
             *action = sf_comm_action_break;
             return 0;
-        } else if (result == EINTR && !SF_CTX->use_io_uring) {
+        } else if (errno == EINTR) {  //should retry
-            /* should try again */
             logDebug("file: "__FILE__", line: %d, "
                     "client ip: %s, ignore interupt signal",
                     __LINE__, task->client_ip);
@@ -939,7 +680,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 +712,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
+            *action = sf_comm_action_continue;
-            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 +765,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
+        *action = sf_comm_action_continue;
-        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;
@@ -1122,7 +841,8 @@ 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, SF_CTX->net_buffer_cfg.network_timeout);
 
                 format_ip_address(task->client_ip, formatted_ip);
                 logInfo("file: "__FILE__", line: %d, client: %s:%u, "
@@ -1184,7 +904,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 +914,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) {
@@ -1214,8 +929,7 @@ 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;
             fast_timer_add(&task->thread_data->timer,
-                    &task->event.timer);
+                &task->event.timer);
-            return 0;
         } else {
             if (task->recv.ptr->length > 0) {
                 logWarning("file: "__FILE__", line: %d, "
@@ -1232,13 +946,9 @@ 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
+        return 0;
-    if (SF_CTX->use_io_uring) {
-        CLEAR_OP_TYPE_AND_RELEASE_TASK(task);
     }
-#endif
 
     total_read = 0;
     action = sf_comm_action_continue;
@@ -1286,72 +996,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,
+int sf_client_sock_write(int sock, short event, void *arg)
-        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 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,42 +1023,6 @@ 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;
@@ -1413,9 +1038,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 +1067,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);
-}

src/sf_nio.h

@@ -68,6 +68,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 +99,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, short event, void *arg);
-void sf_recv_notify_read(int sock, const int 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);
 
@@ -148,6 +158,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 +173,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

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);
+        free(ctx->writer.fw.file.name);
-        ctx->writer.fw.file.name.str = NULL;
+        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;
 

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) \

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)
@@ -60,14 +61,12 @@ struct worker_thread_context {
 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,
+        const bool double_buffers, const int task_padding_size,
-        const int task_padding_size, const int task_arg_size,
+        const int task_arg_size, TaskInitCallback init_callback,
-        TaskInitCallback init_callback, void *init_arg)
+        void *init_arg)
 {
     int result;
-    int buffer_size;
     int m;
-    int max_m;
     int alloc_conn_once;
 
     if ((result=set_rand_seed()) != 0) {
@@ -76,26 +75,17 @@ static int sf_init_free_queue(SFContext *sf_context, const char *name,
         return result;
     }
 
-    if (strcmp(name, "cluster") == 0 || strcmp(name, "replica") == 0) {
+    m = sf_context->net_buffer_cfg.min_buff_size / (64 * 1024);
-        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);
     if (m == 0) {
         m = 1;
-    } else if (m > max_m) {
+    } else if (m > 16) {
-        m = max_m;
+        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,
+            sf_context->net_buffer_cfg.max_connections, alloc_conn_once,
-            alloc_conn_once, sf_context->net_buffer_cfg.min_buff_size,
+            sf_context->net_buffer_cfg.min_buff_size, sf_context->
-            sf_context->net_buffer_cfg.max_buff_size, task_padding_size,
+            net_buffer_cfg.max_buff_size, task_padding_size,
             task_arg_size, init_callback, init_arg);
 }
 
@@ -111,14 +101,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,
+        const bool explicit_post_recv, TaskInitCallback init_callback,
-        TaskInitCallback init_callback, void *init_arg,
+        void *init_arg, sf_release_buffer_callback release_buffer_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,7 +115,7 @@ 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;
@@ -144,8 +132,8 @@ 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_padding_size, task_arg_size, init_callback,
-                    task_arg_size, init_callback, init_arg)) != 0)
+                    init_arg)) != 0)
     {
         return result;
     }
@@ -173,11 +161,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 +171,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,43 +195,18 @@ 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->
+        if (ioevent_init(&thread_data->ev_puller, 2 + sf_context->
-                        name, sf_context->use_io_uring, max_entries,
+                    net_buffer_cfg.max_connections, net_timeout_ms,
-                        net_timeout_ms, extra_events)) != 0)
+                    extra_events) != 0)
         {
-            char prompt[256];
+            result  = errno != 0 ? errno : ENOMEM;
-#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
-
             logError("file: "__FILE__", line: %d, "
-                "ioevent_init fail, errno: %d, error info: %s.%s"
+                "ioevent_init fail, "
-                , __LINE__, result, strerror(result), prompt);
+                "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);
         if (result != 0) {
@@ -562,9 +487,7 @@ struct fast_task_info *sf_socket_accept_connection(SFListener *listener)
     }
     FC_SET_CLOEXEC(incomesock);
 
-    if ((task=sf_alloc_init_server_task(listener->handler,
+    if ((task=sf_alloc_init_task(listener->handler, incomesock)) == NULL) {
-                    incomesock)) == NULL)
-    {
         close(incomesock);
         return NULL;
     }
@@ -575,6 +498,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 +782,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 +801,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 +814,8 @@ int sf_add_slow_log_schedule(SFSlowLogContext *slowlog_ctx)
     }
 
     scheduleArray.entries = scheduleEntries;
-    sf_logger_setup_schedule(&slowlog_ctx->ctx, &slowlog_ctx->
+    sf_setup_schedule(&slowlog_ctx->ctx, &slowlog_ctx->cfg.log_cfg,
-            cfg.log_cfg, &scheduleArray);
+            &scheduleArray);
     return sched_add_entries(&scheduleArray);
 }
 

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,9 +45,8 @@ 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,
+        const bool explicit_post_recv, TaskInitCallback init_callback,
-        TaskInitCallback init_callback, void *init_arg,
+        void *init_arg, sf_release_buffer_callback release_buffer_callback);
-        sf_release_buffer_callback release_buffer_callback);
 
 #define sf_service_init_ex(sf_context, name, alloc_thread_extra_data_callback,\
         thread_loop_callback, accept_done_callback, set_body_length_func,   \
@@ -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, 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,   \
+        net_timeout_ms, proto_header_size, 0, task_arg_size, false, false,  \
-        false, NULL, NULL, NULL)
+        NULL, 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)
 
@@ -165,11 +163,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 +170,12 @@ 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_ex(task, inc_count) __sync_add_and_fetch( \
-#define sf_hold_task(task)  fc_hold_task(task)
+        &task->reffer_count, inc_count)
+#define sf_hold_task(task)  sf_hold_task_ex(task, 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 +187,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 +262,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

src/sf_types.h

@@ -115,7 +115,6 @@ typedef struct sf_listener {
 
 struct sf_context;
 struct sf_address_family_handler;
-
 typedef struct sf_network_handler {
     bool enabled;
     bool explicit_post_recv;
@@ -180,9 +179,8 @@ typedef struct sf_context {
     struct nio_thread_data *thread_data;
     volatile int thread_count;
 
-    bool is_client;    //since v1.2.5
+    //int rdma_port_offset;
-    bool use_io_uring; //since v1.2.9
+    bool is_client;   //since v1.2.5
-    bool use_send_zc;  //since v1.2.9
     SFAddressFamily address_family;
     SFAddressFamilyHandler handlers[SF_ADDRESS_FAMILY_COUNT];
 
@@ -192,6 +190,7 @@ typedef struct sf_context {
     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;

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(),

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;
 }