gh actions: upgrade to 1.0.83-1

Added: 增加IPv6支持

.gitignore

@@ -1,5 +1,6 @@
 # Makefile.in
 src/Makefile
+src/tests/Makefile
 
 # Prerequisites
 *.d
@@ -54,6 +55,17 @@ src/tests/test_file_write_hole
 src/tests/test_file_lock
 src/tests/test_thread_pool
 src/tests/test_data_visible
+src/tests/test_pthread_wait
+src/tests/test_mutex_lock_perf
+src/tests/test_queue_perf
+src/tests/test_normalize_path
+src/tests/test_sorted_array
+src/tests/test_sorted_queue
+src/tests/test_thread_local
+src/tests/test_memcpy
+src/tests/mblock_benchmark
+src/tests/cpool_benchmark
+src/tests/test_fast_buffer
 
 # other
 *.swp

HISTORY

@@ -1,4 +1,201 @@
 
+Version 1.83  2025-11-15
+  * fast_task_queue.h: remove field finish_callback
+
+Version 1.82  2025-11-04
+  * set use_io_uring explicitly
+
+Version 1.81  2025-10-05
+  * support Linux io_uring
+  * free_queue support parameter: need_shrink and set task->shrinked
+  * IOEventCallback: change event type from short to int
+
+Version 1.80  2025-09-10
+  * getIpaddrByNameEx: IPv4 has priority over IPv6
+  * shared_func.[hc]: add function fc_ftoa
+
+Version 1.79  2025-08-29
+  * logger.h export function log_it_ex3
+  * shared_func.[hc]: add function bytes_to_human_str
+
+Version 1.78  2025-08-07
+  * getIpaddrByName: normalize ip addr when input addr is IPv4 or IPv6
+  * add files: spinlock.[hc]
+  * shared_func.[hc]: change int2buff, buff2int etc. functions to static inline
+  * shared_func.[hc]: add functions short2hex, int2hex, long2hex etc.
+  * performance opt.: replace sprintf and snprintf as necessary
+
+Version 1.77  2025-03-18
+  * impl. shorten_path for /./ and /../
+  * add function fc_compare_int64_ptr
+
+Version 1.76  2025-01-27
+  * get_mounted_filesystems act as program df
+  * add function get_statfs_by_path
+  * add function is_rotational_device_by_path
+  * conn_pool_get_connection_ex add parameter: shared
+
+Version 1.75  2024-09-22
+  * task init callback support extra argument
+  * connection pool performance optimization
+
+Version 1.74  2024-05-18
+  * add functions: get_log_level and get_log_level_caption
+  * adapt to FreeBSD 13
+
+Version 1.73  2024-03-05
+  * add macro FC_SET_STRING_EMPTY
+  * struct fast_task_info remove fields: connect_timeout and network_timeout
+  * format ip address for IPv6
+
+Version 1.72  2024-01-21
+  * call fast_mblock_ref_counter_dec for delay free node correctly
+  * fc_queue.[hc]: add function fc_queue_remove
+
+Version 1.71  2023-12-23
+  * full support IPv6 by pull request #47
+  * replace inet_ntop to getnameinfo for IPv6
+
+Version 1.70  2023-09-30
+  * get full mac address of infiniband NIC under Linux
+  * struct fast_task_info add field conn for RDMA connection
+  * server_id_func.[hc]: support communication type
+  * connection_pool.[hc] support callbacks for RDMA 
+  * nio thread data support busy_polling_callback
+  * connection_pool.[hc] support thread local for performance
+  * struct fast_task_info support send and recv double buffers
+  * add functions: fc_queue_push_with_check and fc_queue_peek
+
+Version 1.69  2023-08-05
+  * bugfixed: array_allocator_alloc MUST init the array
+  * uniq_skiplist support arg for free callback
+
+Version 1.68  2023-07-05
+  * sorted_queue.[hc]: pop_compare_func support argument
+
+Version 1.67  2023-05-29
+  * lc_pair in struct fc_queue change to lcp
+  * sorted queue use double link chain for quick push
+  * add function uniq_skiplist_clear
+  * fast_mblock_malloc_trunk_notify_func prototype changed
+  * fast_mblock_init_ex2 add parameter prealloc_trunk_count
+  * sorted_queue.[hc] support pop_compare_func
+  * bugfixed: fast_mblock_batch_alloc correct return value
+  * add function fc_safe_writev
+
+Version 1.66  2023-02-12
+  * struct fast_task_info add field: notify_next for nio notify queue
+
+Version 1.65  2023-01-09
+  * locked_list.h: add functions locked_list_move and locked_list_move_tail
+  * add function tcp_socket_connected
+  * parse_bytes support space charactors (before and after the unit)
+  * add function get_groups
+
+Version 1.64  2022-11-19
+  * shared_func.[hc]: normalize_path use type string_t for general purpose
+  * bugfixed: common_blocked_queue_[alloc|free]_node must use lock
+  * bugfixed: can't use global malloc_allocator
+
+Version 1.63  2022-10-16
+  * sockopt.[hc]: getIpAndPort support ipv6
+
+Version 1.62  2022-09-28
+  * add function fc_sleep_us
+  * add function fc_itoa
+
+Version 1.61  2022-09-21
+  * get_base_path_from_conf_file_ex support parameter: noent_log_level
+  * add function common_blocked_queue_push_chain
+
+Version 1.60  2022-08-27
+  * normalize_path for base_path
+  * struct fast_task_info add field recv_body for dynamic recv buffer
+  * add functions: iniGetDoubleCorrectValueEx and iniGetPercentCorrectValueEx
+  * fast_allocator.[hc] support object size and callbacks
+
+Version 1.59  2022-07-21
+  * open file with flag O_CLOEXEC
+  * add global var g_set_cloexec and macro FC_SET_CLOEXEC
+  * add function fc_get_first_lines
+
+Version 1.58  2022-06-04
+  * add function conn_pool_connect_server_ex1 to support service name
+  * add function conn_pool_get_connection_ex to support service name
+  * add function iniGetCharValueEx
+  * json_parser.[hc] refined for better performance
+
+Version 1.57  2022-04-22
+  * add function fc_format_path
+  * add functions: fc_get_path_child_count and fc_copy_file
+  * fast_mblock.[hc] support object destroy callback
+  * bugfixed: fc_get_file_line_count_ex should rewind file
+
+Version 1.56  2022-03-09
+  * add function fc_gettid
+  * function normalize_path: NULL from parameter for getcwd
+  * sockopt.[hc] support tcpwritev and tcpreadv
+  * add function fc_iov_get_bytes
+  * rename hash_xxx to fc_hash_xxx
+  * rename trim to fc_trim
+  * add function fc_check_rename_ex
+
+Version 1.55  2022-01-12
+  * fastcommon php extension adapt to php 8
+  * function fast_mblock_batch_alloc changed
+  * add function sched_delay_free_ptr
+
+Version 1.54  2021-12-23
+  * fast_allocator.[hc]: correct reclaim_interval logic
+  * shared_func.[hc]: add functions getFileContentEx1 and getFileContent1
+  * fc_queue.[hc]: add function fc_queue_timedpeek
+  * pthread_func.[hc]: add function init_pthread_rwlock
+  * add files: sorted_queue.[hc]
+  * add files: array_allocator.[hc]
+  * add files: sorted_array.[hc]
+  * shared_func.[hc]: add function fc_read_lines
+  * normalize_path removes prefix one ./ and multi ../
+
+Version 1.53  2021-06-30
+  * process_action support action status
+  * uniq_skiplist.h: add function uniq_skiplist_iterator_at
+
+Version 1.52  2021-06-08
+  * process_stop more gracefully (kill -9 on timeout)
+  * add function fc_queue_pop_to_queue_ex
+  * add function get_path_block_size and get_device_block_size
+  * add function fc_check_realloc_iovec_array
+
+Version 1.51  2021-05-27
+  * fast_mblock.[hc]: support batch alloc and batch free
+  * uniq_skiplist.[hc]: init function add parameter: allocator_use_lock
+  * add function normalize_path_ex and normalize_uri
+  * use libcurl to fetch URL resource
+  * add function get_kernel_version
+
+Version 1.50  2021-05-11
+  * add function is_digital_string
+  * add function fc_server_load_from_ini_context
+  * set thread name as necessary
+  * add macro fc_fallocate
+
+Version 1.49  2021-04-17
+  * add macros: FC_ABS and FC_NEGATIVE
+  * uniq_skiplist.c: add uniq_skiplist_pair struct and init function
+  * add functions: fc_mkdirs and str_replace
+  * add FilenameString type and macro
+  * add functions: fc_string_case_compare, fc_string_case_equal etc.
+  * add function: fc_check_filename_ex
+  * add functions: fc_queue_push_queue_to_tail etc.
+  * add file locked_list.h
+  * parse_bytes function more graceful
+
+Version 1.48  2021-02-01
+  * fast_buffer.[hc]: add function fast_buffer_append_binary
+  * fc_check_mkdir_ex return 0 when mkdir with errno EEXIST
+  * add function common_blocked_queue_timedpop
+  * add function fc_queue_timedpop
+
 Version 1.47  2021-01-20
   * fc_atomic.h: add FC_ATOMIC_GET and FC_ATOMIC_SET etc.
   * fast_mblock.[hc]: support wait with element limit

INSTALL

@@ -6,12 +6,20 @@ Please visit the libfastcommon Home Page for more detail.
 English language: https://github.com/happyfish100/libfastcommon
 Chinese language: http://www.fastken.com/
 
+[Optional Step]
+You can enable io_uring for higher performance when Linux kernel version >= 6.2,
+CentOS, RockyLinux, AlmaLinux, RHEL etc.:
+   sudo yum install liburing-devel -y
+
+Debian, Ubuntu etc.:
+   sudo apt install liburing-dev -y
+
+
 # download libfastcommon source codes and install it,
 #   github address:  https://github.com/happyfish100/libfastcommon.git
 #   gitee address:   https://gitee.com/fastdfs100/libfastcommon.git
 # the command lines as:
 
    git clone https://github.com/happyfish100/libfastcommon.git
-   cd libfastcommon; git checkout V1.0.45
-   ./make.sh clean && ./make.sh && ./make.sh install
-
+   cd libfastcommon; git checkout V1.0.83
+   ./make.sh clean && ./make.sh && sudo ./make.sh install

debian/README.Debian

@@ -0,0 +1,6 @@
+libfastcommon for Debian
+-----------------------
+
+<possible notes regarding this package - if none, delete this file>
+
+ -- zhangchunsheng <zhangchunsheng423@gmail.com>  Mon, 24 May 2021 18:54:01 +0800

debian/changelog

@@ -0,0 +1,192 @@
+libfastcommon (1.0.83-1) unstable; urgency=medium
+
+  * upgrade to 1.0.83-1
+
+ -- YuQing <384681@qq.com>  Sun, 23 Nov 2025 10:47:37 +0000
+
+libfastcommon (1.0.83-1) unstable; urgency=medium
+
+  * upgrade to 1.0.83-1
+
+ -- YuQing <384681@qq.com>  Sun, 23 Nov 2025 10:00:00 +0000
+
+libfastcommon (1.0.83-1) unstable; urgency=medium
+
+  * upgrade to 1.0.83-1
+
+ -- YuQing <384681@qq.com>  Sun, 23 Nov 2025 09:05:57 +0000
+
+libfastcommon (1.0.78-1) unstable; urgency=medium
+
+  * upgrade to 1.0.78-1
+
+ -- YuQing <384681@qq.com>  Sat, 16 Aug 2025 16:31:05 +0000
+
+libfastcommon (1.0.77-1) unstable; urgency=medium
+
+  * upgrade to 1.0.77-1
+
+ -- YuQing <384681@qq.com>  Sun, 06 Apr 2025 16:55:50 +0000
+
+libfastcommon (1.0.75-1) unstable; urgency=medium
+
+  * upgrade to 1.0.75-1
+
+ -- YuQing <384681@qq.com>  Sun, 29 Sep 2024 15:23:57 +0000
+
+libfastcommon (1.0.74-1) unstable; urgency=medium
+
+  * upgrade to 1.0.74-1
+
+ -- YuQing <384681@qq.com>  Sat, 15 Jun 2024 14:45:01 +0000
+
+libfastcommon (1.0.73-1) unstable; urgency=medium
+
+  * upgrade to 1.0.73-1
+
+ -- YuQing <384681@qq.com>  Sun, 17 Mar 2024 15:10:21 +0000
+
+libfastcommon (1.0.72-1) unstable; urgency=medium
+
+  * upgrade to 1.0.72-1
+
+ -- YuQing <384681@qq.com>  Wed, 31 Jan 2024 11:59:25 +0000
+
+libfastcommon (1.0.71-1) unstable; urgency=medium
+
+  * upgrade to 1.0.71-1
+
+ -- YuQing <384681@qq.com>  Mon, 01 Jan 2024 11:23:54 +0000
+
+libfastcommon (1.0.70-3) unstable; urgency=medium
+
+  * upgrade to 1.0.70-3
+
+ -- YuQing <384681@qq.com>  Tue, 21 Nov 2023 14:35:29 +0000
+
+libfastcommon (1.0.70-2) unstable; urgency=medium
+
+  * upgrade to 1.0.70-2
+
+ -- YuQing <384681@qq.com>  Mon, 20 Nov 2023 13:23:17 +0000
+
+libfastcommon (1.0.70-1) unstable; urgency=medium
+
+  * upgrade to 1.0.70-1
+
+ -- YuQing <384681@qq.com>  Sun, 19 Nov 2023 14:45:34 +0000
+
+libfastcommon (1.0.69-1) unstable; urgency=medium
+
+  * upgrade to 1.0.69-1
+
+ -- YuQing <384681@qq.com>  Sun, 06 Aug 2023 07:21:50 +0000
+
+libfastcommon (1.0.68-1) unstable; urgency=medium
+
+  * upgrade to 1.0.68-1
+
+ -- YuQing <384681@qq.com>  Sun, 23 Jul 2023 14:27:27 +0000
+
+libfastcommon (1.0.67-1) unstable; urgency=medium
+
+  * upgrade to 1.0.67-1
+
+ -- YuQing <384681@qq.com>  Sun, 04 Jun 2023 10:51:06 +0000
+
+libfastcommon (1.0.66-1) unstable; urgency=medium
+
+  * upgrade to 1.0.66-1
+
+ -- YuQing <384681@qq.com>  Sat, 18 Feb 2023 05:43:58 +0000
+
+libfastcommon (1.0.65-1) unstable; urgency=medium
+
+  * upgrade to 1.0.65-1
+
+ -- YuQing <384681@qq.com>  Sun, 15 Jan 2023 13:49:19 +0000
+
+libfastcommon (1.0.63-1) unstable; urgency=medium
+
+  * upgrade to 1.0.63-1
+
+ -- YuQing <384681@qq.com>  Mon, 21 Nov 2022 14:54:56 +0000
+
+libfastcommon (1.0.62-1) unstable; urgency=medium
+
+  * upgrade to 1.0.62-1
+
+ -- YuQing <384681@qq.com>  Sat, 08 Oct 2022 13:28:15 +0000
+
+libfastcommon (1.0.61-1) unstable; urgency=medium
+
+  * upgrade to 1.0.61-1
+
+ -- YuQing <384681@qq.com>  Thu, 22 Sep 2022 12:22:09 +0000
+
+libfastcommon (1.0.60-1) unstable; urgency=medium
+
+  * upgrade to 1.0.60-1
+
+ -- YuQing <384681@qq.com>  Wed, 07 Sep 2022 13:36:01 +0000
+
+libfastcommon (1.0.59-1) unstable; urgency=medium
+
+  * upgrade to 1.0.59-1
+
+ -- YuQing <384681@qq.com>  Mon, 25 Jul 2022 13:51:25 +0000
+
+libfastcommon (1.0.58-1) unstable; urgency=medium
+
+  * upgrade to 1.0.58-1
+
+ -- YuQing <384681@qq.com>  Wed, 15 Jun 2022 14:26:02 +0000
+
+libfastcommon (1.0.57-1) unstable; urgency=medium
+
+  * upgrade to 1.0.57-1
+
+ -- YuQing <384681@qq.com>  Thu, 28 Apr 2022 11:53:21 +0000
+
+libfastcommon (1.0.56-1) unstable; urgency=medium
+
+  * check pthread_rwlockattr_getkind_np for porting
+  * correct pthread_rwlockattr getkind_np to setkind_np
+  * change include <sys/poll.h> to #include <poll.h>
+  * add function fc_gettid
+  * NULL from parameter for getcwd
+  * sockopt.[hc] support tcpwritev and tcpreadv
+  * add const modifier for unification
+  * make.sh refined
+  * add function fc_iov_get_bytes
+  * make.sh: generate macros for dirent fields
+  * add function log_try_init2
+  * rename hash_xxx to fc_hash_xxx
+  * rename trim to fc_trim
+  * php-fastcommon compile OK
+  * add function locked_list_destroy
+  * upgrade version to 1.0.56
+  * add function fc_check_rename_ex
+  * small changes for logger.[hc]
+
+ -- YuQing <384681@qq.com>  Sun, 13 Mar 2022 16:43:08 +0800
+
+libfastcommon (1.0.55-1) unstable; urgency=medium
+
+  * upgrade version to 1.0.55 
+
+ -- YuQing <384681@qq.com>  Sat, 15 Jan 2022 19:50:26 +0800
+
+libfastcommon (1.0.54-1) unstable; urgency=medium
+  
+  * upgrade version to 1.0.54
+
+ -- YuQing <384681@qq.com>  Sun, 26 Dec 2021 20:29:05 +0800
+
+libfastcommon (1.0.53-1) unstable; urgency=medium
+  
+  * open for write MUST have the third parameter: mode
+  * uniq_skiplist.h: add function uniq_skiplist_iterator_at
+  * process_action support action status
+
+ -- YuQing <384681@qq.com>  Tue, 6 Jul 2021 21:23:31 +0800

debian/compat

@@ -0,0 +1 @@
+11

debian/control

@@ -0,0 +1,25 @@
+Source: libfastcommon
+Section: libs
+Priority: optional
+Maintainer: YuQing <384681@qq.com>
+Build-Depends: debhelper (>=11~)
+Standards-Version: 4.1.4
+Homepage: http://github.com/happyfish100/libfastcommon/
+
+Package: libfastcommon-dev
+Architecture: any
+Section: libdevel
+Depends: libfastcommon (= ${binary:Version}), ${misc:Depends}
+Description: libfastcommon (development files)
+ This package contains header files.
+
+Package: libfastcommon
+Architecture: any
+Depends: ${shlibs:Depends}, ${misc:Depends}
+Description: c common functions library
+ c common functions library extracted from my open source projects FastDFS and 
+ FastDHT. this library is very simple and stable.
+ .
+ some functions are wrappered into php extension, such as fastcommon_gethostaddrs,
+     fastcommon_id_generator_xxx, fastcommon_get_ifconfigs, fastcommon_get_sysinfo etc.
+

debian/copyright

@@ -0,0 +1,530 @@
+Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: libfastcommon
+Source: http://github.com/happyfish100/libfastcommon/
+#
+# Please double check copyright with the licensecheck(1) command.
+
+Files:     php-fastcommon/fastcommon.c
+           php-fastcommon/fastcommon.h
+           src/avl_tree.c
+           src/avl_tree.h
+           src/base64.c
+           src/buffered_file_writer.c
+           src/buffered_file_writer.h
+           src/chain.c
+           src/chain.h
+           src/char_convert_loader.c
+           src/char_convert_loader.h
+           src/char_converter.c
+           src/char_converter.h
+           src/common_blocked_queue.c
+           src/common_blocked_queue.h
+           src/common_define.h
+           src/connection_pool.c
+           src/connection_pool.h
+           src/fast_allocator.c
+           src/fast_allocator.h
+           src/fast_blocked_queue.c
+           src/fast_blocked_queue.h
+           src/fast_buffer.c
+           src/fast_buffer.h
+           src/fast_mblock.c
+           src/fast_mblock.h
+           src/fast_mpool.c
+           src/fast_mpool.h
+           src/fast_task_queue.c
+           src/fast_task_queue.h
+           src/fast_timer.c
+           src/fast_timer.h
+           src/fc_atomic.h
+           src/fc_memory.c
+           src/fc_memory.h
+           src/fc_queue.c
+           src/fc_queue.h
+           src/flat_skiplist.c
+           src/flat_skiplist.h
+           src/hash.c
+           src/hash.h
+           src/http_func.h
+           src/id_generator.c
+           src/ini_file_reader.c
+           src/ini_file_reader.h
+           src/ioevent.c
+           src/ioevent.h
+           src/ioevent_loop.c
+           src/ioevent_loop.h
+           src/json_parser.c
+           src/json_parser.h
+           src/local_ip_func.c
+           src/local_ip_func.h
+           src/locked_timer.c
+           src/locked_timer.h
+           src/logger.c
+           src/multi_skiplist.c
+           src/multi_skiplist.h
+           src/multi_socket_client.c
+           src/multi_socket_client.h
+           src/process_ctrl.c
+           src/process_ctrl.h
+           src/pthread_func.c
+           src/pthread_func.h
+           src/sched_thread.c
+           src/sched_thread.h
+           src/server_id_func.c
+           src/server_id_func.h
+           src/shared_buffer.c
+           src/shared_buffer.h
+           src/shared_func.c
+           src/shared_func.h
+           src/skiplist_common.h
+           src/skiplist_set.c
+           src/system_info.c
+           src/system_info.h
+           src/tests/test_allocator.c
+           src/tests/test_atomic.c
+           src/tests/test_blocked_queue.c
+           src/tests/test_char_convert.c
+           src/tests/test_char_convert_loader.c
+           src/tests/test_crc32.c
+           src/tests/test_data_visible.c
+           src/tests/test_file_lock.c
+           src/tests/test_file_write_hole.c
+           src/tests/test_id_generator.c
+           src/tests/test_ini_parser.c
+           src/tests/test_json_parser.c
+           src/tests/test_logger.c
+           src/tests/test_mblock.c
+           src/tests/test_multi_skiplist.c
+           src/tests/test_mutex_lock_perf.c
+           src/tests/test_normalize_path.c
+           src/tests/test_pipe.c
+           src/tests/test_pthread_lock.c
+           src/tests/test_pthread_wait.c
+           src/tests/test_queue_perf.c
+           src/tests/test_sched_thread.c
+           src/tests/test_server_id_func.c
+           src/tests/test_skiplist.c
+           src/tests/test_skiplist_set.c
+           src/tests/test_split_string.c
+           src/tests/test_thourands_seperator.c
+           src/tests/test_thread_pool.c
+           src/tests/test_uniq_skiplist.c
+           src/thread_pool.c
+           src/thread_pool.h
+           src/uniq_skiplist.c
+           src/uniq_skiplist.h
+Copyright: 2020 YuQing <384681@qq.com>
+License:   GPL-3.0+
+ This program is free software: you can use, redistribute, and/or modify
+ it under the terms of the Lesser GNU General Public License, version 3
+ or later ("LGPL"), as published by the Free Software Foundation.
+ .
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.
+ .
+ You should have received a copy of the Lesser GNU General Public License
+ along with this program. If not, see <https://www.gnu.org/licenses/>.
+ .
+ On Debian systems, the complete text of the GNU General Public License
+ Version 3 can be found in `/usr/share/common-licenses/GPL-3'.
+
+Files:     .gitignore
+           HISTORY
+           INSTALL
+           debian/README.Debian
+           debian/compat
+           debian/control
+           debian/libfastcommon-dev.install
+           debian/libfastcommon.install
+           debian/rules
+           debian/source/format
+           debian/watch
+           doc/id_generator-Chinese.md
+           doc/ini_file_reader-Chinese.md
+           doc/php_log_file_performance-Chinese.md
+           libfastcommon.spec
+           make.sh
+           php-fastcommon/config.m4
+           php-fastcommon/fastcommon.ini
+           php-fastcommon/php-fastcommon.spec.in
+           src/Makefile.in
+           src/fast_link_library.sh
+           src/fc_list.h
+           src/io_opt.c
+           src/io_opt.h
+           src/locked_list.h
+           src/md5.c
+           src/md5.h
+           src/tests/Makefile
+           src/tests/servers.conf
+           src/tests/test.ini
+Copyright: __NO_COPYRIGHT_NOR_LICENSE__
+License:   __NO_COPYRIGHT_NOR_LICENSE__
+
+Files:     src/skiplist.h
+Copyright: 2020 YuQing <384681@qq.com>
+License:   GPL-3.0+
+ This program is free software: you can use, redistribute, and/or modify
+ it under the terms of the Lesser GNU General Public License, version 3
+ or later ("LGPL"), as published by the Free Software Foundation.
+ .
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.
+ .
+ You should have received a copy of the Lesser GNU General Public License
+ along with this program. If not, see <https://www.gnu.org/licenses/>.
+ .
+ skiplist.h, support stable sort  :)
+ .
+ On Debian systems, the complete text of the GNU General Public License
+ Version 3 can be found in `/usr/share/common-licenses/GPL-3'.
+
+Files:     src/skiplist_set.h
+Copyright: 2020 YuQing <384681@qq.com>
+License:   GPL-3.0+
+ This program is free software: you can use, redistribute, and/or modify
+ it under the terms of the Lesser GNU General Public License, version 3
+ or later ("LGPL"), as published by the Free Software Foundation.
+ .
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.
+ .
+ You should have received a copy of the Lesser GNU General Public License
+ along with this program. If not, see <https://www.gnu.org/licenses/>.
+ .
+ a set implemented by skiplist, the entry can occur only once
+ .
+ On Debian systems, the complete text of the GNU General Public License
+ Version 3 can be found in `/usr/share/common-licenses/GPL-3'.
+
+Files:     src/sockopt.c
+Copyright: 2020 YuQing <384681@qq.com>
+License:   GPL-3.0+
+ This program is free software: you can use, redistribute, and/or modify
+ it under the terms of the Lesser GNU General Public License, version 3
+ or later ("LGPL"), as published by the Free Software Foundation.
+ .
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.
+ .
+ You should have received a copy of the Lesser GNU General Public License
+ along with this program. If not, see <https://www.gnu.org/licenses/>.
+ .
+ socketopt.c
+ .
+ On Debian systems, the complete text of the GNU General Public License
+ Version 3 can be found in `/usr/share/common-licenses/GPL-3'.
+
+Files:     src/sockopt.h
+Copyright: 2020 YuQing <384681@qq.com>
+License:   GPL-3.0+
+ This program is free software: you can use, redistribute, and/or modify
+ it under the terms of the Lesser GNU General Public License, version 3
+ or later ("LGPL"), as published by the Free Software Foundation.
+ .
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.
+ .
+ You should have received a copy of the Lesser GNU General Public License
+ along with this program. If not, see <https://www.gnu.org/licenses/>.
+ .
+ socketopt.h
+ .
+ On Debian systems, the complete text of the GNU General Public License
+ Version 3 can be found in `/usr/share/common-licenses/GPL-3'.
+
+Files:     src/http_func.c
+Copyright: 2008 Happy Fish / YuQing
+           2020 YuQing <384681@qq.com>
+License:   GPL-3.0+
+ This program is free software: you can use, redistribute, and/or modify
+ it under the terms of the Lesser GNU General Public License, version 3
+ or later ("LGPL"), as published by the Free Software Foundation.
+ .
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.
+ .
+ You should have received a copy of the Lesser GNU General Public License
+ along with this program. If not, see <https://www.gnu.org/licenses/>.
+ .
+ FastDFS may be copied only under the terms of the GNU General
+ Public License V3, which may be found in the FastDFS source kit.
+ Please visit the FastDFS Home Page http://www.fastken.com/ for more detail.
+ .
+ On Debian systems, the complete text of the GNU General Public License
+ Version 3 can be found in `/usr/share/common-licenses/GPL-3'.
+
+Files:     src/id_generator.h
+Copyright: 2020 YuQing <384681@qq.com>
+License:   GPL-3.0+
+ This program is free software: you can use, redistribute, and/or modify
+ it under the terms of the Lesser GNU General Public License, version 3
+ or later ("LGPL"), as published by the Free Software Foundation.
+ .
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.
+ .
+ You should have received a copy of the Lesser GNU General Public License
+ along with this program. If not, see <https://www.gnu.org/licenses/>.
+ .
+ 64 bits id generator for multi processes, the generated id format:
+ 32 bits timestamp + X bits machine id  + Y bits of extra data + Z bits serial number
+ such as 12 bits machine id, 0 bits extra data and 20 bits serial number
+ .
+ On Debian systems, the complete text of the GNU General Public License
+ Version 3 can be found in `/usr/share/common-licenses/GPL-3'.
+
+Files:     src/php7_ext_wrapper.h
+Copyright: 2020 YuQing <384681@qq.com>
+License:   GPL-3.0+
+ This program is free software: you can use, redistribute, and/or modify
+ it under the terms of the Lesser GNU General Public License, version 3
+ or later ("LGPL"), as published by the Free Software Foundation.
+ .
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.
+ .
+ You should have received a copy of the Lesser GNU General Public License
+ along with this program. If not, see <https://www.gnu.org/licenses/>.
+ .
+ php7 extension wrapper
+ for compatibility, these wrapper functions are designed for old php version.
+ .
+ On Debian systems, the complete text of the GNU General Public License
+ Version 3 can be found in `/usr/share/common-licenses/GPL-3'.
+
+Files:     src/base64.h
+Copyright: 2020 YuQing <384681@qq.com>
+License:   GPL-3.0+
+ This program is free software: you can use, redistribute, and/or modify
+ it under the terms of the Lesser GNU General Public License, version 3
+ or later ("LGPL"), as published by the Free Software Foundation.
+ .
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.
+ .
+ You should have received a copy of the Lesser GNU General Public License
+ along with this program. If not, see <https://www.gnu.org/licenses/>.
+ .
+ base64.h
+ .
+ On Debian systems, the complete text of the GNU General Public License
+ Version 3 can be found in `/usr/share/common-licenses/GPL-3'.
+
+Files:     src/logger.h
+Copyright: 2020 YuQing <384681@qq.com>
+License:   GPL-3.0+
+ This program is free software: you can use, redistribute, and/or modify
+ it under the terms of the Lesser GNU General Public License, version 3
+ or later ("LGPL"), as published by the Free Software Foundation.
+ .
+ This program is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE.
+ .
+ You should have received a copy of the Lesser GNU General Public License
+ along with this program. If not, see <https://www.gnu.org/licenses/>.
+ .
+ logger.h
+ .
+ On Debian systems, the complete text of the GNU General Public License
+ Version 3 can be found in `/usr/share/common-licenses/GPL-3'.
+
+Files:     README
+Copyright: 2010 Happy Fish / YuQing
+License:   __UNKNOWN__
+ libfastcommon may be copied only under the terms of the Less GNU General
+ Public License(LGPL).
+ Please visit the libfastcommon Home Page for more detail.
+ English language: https://github.com/happyfish100/libfastcommon
+ Chinese language: http://www.fastken.com/
+ .
+ c common functions library extracted from my open source projects FastDFS and
+ FastDHT. this library is very simple and stable.
+
+#----------------------------------------------------------------------------
+# xml and html files (skipped):
+#         php-fastcommon/test_file_put_contents.php
+#         php-fastcommon/test.php
+#         php-fastcommon/test_error_log.php
+
+#----------------------------------------------------------------------------
+# Files marked as NO_LICENSE_TEXT_FOUND may be covered by the following
+# license/copyright files.
+
+#----------------------------------------------------------------------------
+# License file: LICENSE
+                    GNU LESSER GENERAL PUBLIC LICENSE
+                        Version 3, 29 June 2007
+ .
+  Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+  Everyone is permitted to copy and distribute verbatim copies
+  of this license document, but changing it is not allowed.
+ .
+ .
+   This version of the GNU Lesser General Public License incorporates
+ the terms and conditions of version 3 of the GNU General Public
+ License, supplemented by the additional permissions listed below.
+ .
+   0. Additional Definitions.
+ .
+   As used herein, "this License" refers to version 3 of the GNU Lesser
+ General Public License, and the "GNU GPL" refers to version 3 of the GNU
+ General Public License.
+ .
+   "The Library" refers to a covered work governed by this License,
+ other than an Application or a Combined Work as defined below.
+ .
+   An "Application" is any work that makes use of an interface provided
+ by the Library, but which is not otherwise based on the Library.
+ Defining a subclass of a class defined by the Library is deemed a mode
+ of using an interface provided by the Library.
+ .
+   A "Combined Work" is a work produced by combining or linking an
+ Application with the Library.  The particular version of the Library
+ with which the Combined Work was made is also called the "Linked
+ Version".
+ .
+   The "Minimal Corresponding Source" for a Combined Work means the
+ Corresponding Source for the Combined Work, excluding any source code
+ for portions of the Combined Work that, considered in isolation, are
+ based on the Application, and not on the Linked Version.
+ .
+   The "Corresponding Application Code" for a Combined Work means the
+ object code and/or source code for the Application, including any data
+ and utility programs needed for reproducing the Combined Work from the
+ Application, but excluding the System Libraries of the Combined Work.
+ .
+   1. Exception to Section 3 of the GNU GPL.
+ .
+   You may convey a covered work under sections 3 and 4 of this License
+ without being bound by section 3 of the GNU GPL.
+ .
+   2. Conveying Modified Versions.
+ .
+   If you modify a copy of the Library, and, in your modifications, a
+ facility refers to a function or data to be supplied by an Application
+ that uses the facility (other than as an argument passed when the
+ facility is invoked), then you may convey a copy of the modified
+ version:
+ .
+    a) under this License, provided that you make a good faith effort to
+    ensure that, in the event an Application does not supply the
+    function or data, the facility still operates, and performs
+    whatever part of its purpose remains meaningful, or
+ .
+    b) under the GNU GPL, with none of the additional permissions of
+    this License applicable to that copy.
+ .
+   3. Object Code Incorporating Material from Library Header Files.
+ .
+   The object code form of an Application may incorporate material from
+ a header file that is part of the Library.  You may convey such object
+ code under terms of your choice, provided that, if the incorporated
+ material is not limited to numerical parameters, data structure
+ layouts and accessors, or small macros, inline functions and templates
+ (ten or fewer lines in length), you do both of the following:
+ .
+    a) Give prominent notice with each copy of the object code that the
+    Library is used in it and that the Library and its use are
+    covered by this License.
+ .
+    b) Accompany the object code with a copy of the GNU GPL and this license
+    document.
+ .
+   4. Combined Works.
+ .
+   You may convey a Combined Work under terms of your choice that,
+ taken together, effectively do not restrict modification of the
+ portions of the Library contained in the Combined Work and reverse
+ engineering for debugging such modifications, if you also do each of
+ the following:
+ .
+    a) Give prominent notice with each copy of the Combined Work that
+    the Library is used in it and that the Library and its use are
+    covered by this License.
+ .
+    b) Accompany the Combined Work with a copy of the GNU GPL and this license
+    document.
+ .
+    c) For a Combined Work that displays copyright notices during
+    execution, include the copyright notice for the Library among
+    these notices, as well as a reference directing the user to the
+    copies of the GNU GPL and this license document.
+ .
+    d) Do one of the following:
+ .
+        0) Convey the Minimal Corresponding Source under the terms of this
+        License, and the Corresponding Application Code in a form
+        suitable for, and under terms that permit, the user to
+        recombine or relink the Application with a modified version of
+        the Linked Version to produce a modified Combined Work, in the
+        manner specified by section 6 of the GNU GPL for conveying
+        Corresponding Source.
+ .
+        1) Use a suitable shared library mechanism for linking with the
+        Library.  A suitable mechanism is one that (a) uses at run time
+        a copy of the Library already present on the user's computer
+        system, and (b) will operate properly with a modified version
+        of the Library that is interface-compatible with the Linked
+        Version.
+ .
+    e) Provide Installation Information, but only if you would otherwise
+    be required to provide such information under section 6 of the
+    GNU GPL, and only to the extent that such information is
+    necessary to install and execute a modified version of the
+    Combined Work produced by recombining or relinking the
+    Application with a modified version of the Linked Version. (If
+    you use option 4d0, the Installation Information must accompany
+    the Minimal Corresponding Source and Corresponding Application
+    Code. If you use option 4d1, you must provide the Installation
+    Information in the manner specified by section 6 of the GNU GPL
+    for conveying Corresponding Source.)
+ .
+   5. Combined Libraries.
+ .
+   You may place library facilities that are a work based on the
+ Library side by side in a single library together with other library
+ facilities that are not Applications and are not covered by this
+ License, and convey such a combined library under terms of your
+ choice, if you do both of the following:
+ .
+    a) Accompany the combined library with a copy of the same work based
+    on the Library, uncombined with any other library facilities,
+    conveyed under the terms of this License.
+ .
+    b) Give prominent notice with the combined library that part of it
+    is a work based on the Library, and explaining where to find the
+    accompanying uncombined form of the same work.
+ .
+   6. Revised Versions of the GNU Lesser General Public License.
+ .
+   The Free Software Foundation may publish revised and/or new versions
+ of the GNU Lesser General Public License from time to time. Such new
+ versions will be similar in spirit to the present version, but may
+ differ in detail to address new problems or concerns.
+ .
+   Each version is given a distinguishing version number. If the
+ Library as you received it specifies that a certain numbered version
+ of the GNU Lesser General Public License "or any later version"
+ applies to it, you have the option of following the terms and
+ conditions either of that published version or of any later version
+ published by the Free Software Foundation. If the Library as you
+ received it does not specify a version number of the GNU Lesser
+ General Public License, you may choose any version of the GNU Lesser
+ General Public License ever published by the Free Software Foundation.
+ .
+   If the Library as you received it specifies that a proxy can decide
+ whether future versions of the GNU Lesser General Public License shall
+ apply, that proxy's public statement of acceptance of any version is
+ permanent authorization for you to choose that version for the
+ Library.

debian/libfastcommon-dev.install

@@ -0,0 +1 @@
+usr/include/fastcommon/*

debian/libfastcommon.install

@@ -0,0 +1 @@
+usr/lib/libfastcommon.so*

debian/rules

@@ -0,0 +1,14 @@
+#!/usr/bin/make -f
+
+export DESTDIR = $(CURDIR)/debian/tmp
+
+%:
+	dh $@
+
+
+override_dh_auto_build:
+	./make.sh clean && ./make.sh
+
+override_dh_auto_install:
+	./make.sh install
+	dh_auto_install

debian/source/format

@@ -0,0 +1 @@
+3.0 (quilt)

debian/watch

@@ -0,0 +1,3 @@
+version=3
+opts="mode=git" https://github.com/happyfish100/libfastcommon.git \
+   refs/tags/v([\d\.]+) debian uupdate

libfastcommon.spec

@@ -1,10 +1,9 @@
 
 %define LibFastcommonDevel  libfastcommon-devel
-%define LibFastcommonDebuginfo  libfastcommon-debuginfo
 %define CommitVersion %(echo $COMMIT_VERSION)
 
 Name: libfastcommon
-Version: 1.0.47
+Version: 1.0.83
 Release: 1%{?dist}
 Summary: c common functions library extracted from my open source projects FastDFS
 License: LGPL
@@ -12,21 +11,30 @@ Group: Arch/Tech
 URL:  http://github.com/happyfish100/libfastcommon/
 Source: http://github.com/happyfish100/libfastcommon/%{name}-%{version}.tar.gz
 
-BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n) 
+BuildRoot: %{_tmppath}/%{name}-%{version}-%{release}-root-%(%{__id_u} -n)
 
-#Requires: /sbin/chkconfig
-#BuildRequires: perl %{_includedir}/linux/if.h gettext
+BuildRequires: libcurl-devel
+Requires: libcurl
 Requires: %__cp %__mv %__chmod %__grep %__mkdir %__install %__id
 
+%define kernel_major %(uname -r | cut -d'.' -f1)
+%define kernel_minor %(uname -r | cut -d'.' -f2)
+%define kernel_ver_int %(expr %{kernel_major} \\* 100 + %{kernel_minor})
+%if %{kernel_ver_int} >= 514
+BuildRequires: liburing-devel >= 2.4
+Requires: liburing >= 2.4
+%endif
+
 %description
 c common functions library extracted from my open source projects FastDFS.
 this library is very simple and stable. functions including: string, logger,
 chain, hash, socket, ini file reader, base64 encode / decode,
-url encode / decode, fasttimer etc. 
+url encode / decode, fasttimer etc.
 commit version: %{CommitVersion}
 
 %package devel
 Summary: Development header file
+Requires: libcurl-devel
 Requires: %{name}%{?_isa} = %{version}-%{release}
 
 %description devel

make.sh

@@ -1,3 +1,9 @@
+GCC_VERSION=$(gcc -dM -E -  < /dev/null | grep -w __GNUC__ | awk '{print $NF;}')
+if [ -z "$GCC_VERSION" ]; then
+  echo -e "gcc not found, please install gcc first\n" 1>&2
+  exit 2
+fi
+
 tmp_src_filename=fast_check_bits.c
 cat <<EOF > $tmp_src_filename
 #include <stdio.h>
@@ -7,56 +13,82 @@ int main()
 {
 	printf("%d\n", (int)sizeof(void*));
 	printf("%d\n", (int)sizeof(off_t));
+#ifdef __GLIBC_MINOR__
+	printf("%d\n", __GLIBC_MINOR__);
+#endif
 	return 0;
 }
 EOF
 
 gcc -D_FILE_OFFSET_BITS=64 -o a.out $tmp_src_filename
-output=`./a.out`
+output=$(./a.out)
+if [ $? -ne 0 ]; then
+  echo -e "Can't find a.out program\n" 1>&2
+  exit 2
+fi
 
 if [ -f /bin/expr ]; then
   EXPR=/bin/expr
-else
+elif [ -f /usr/bin/expr ]; then
   EXPR=/usr/bin/expr
+else
+  EXPR=$(which expr)
+  if [ $? -ne 0 ]; then
+    echo -e "Can't find expr program\n" 1>&2
+    exit 2
+  fi
 fi
 
 count=0
 int_bytes=4
 off_bytes=8
+glibc_minor=0
 LIB_VERSION=lib64
 
 for col in $output; do
     if [ $count -eq 0 ]; then
         int_bytes=$col
-    else
+    elif [ $count -eq 1 ]; then
         off_bytes=$col
+    else
+        glibc_minor=$col
     fi
 
-    count=`$EXPR $count + 1`
+    count=$($EXPR $count + 1)
 done
 
 /bin/rm -f a.out $tmp_src_filename
 
+uname=$(uname)
 TARGET_PREFIX=$DESTDIR/usr
 if [ "$int_bytes" -eq 8 ]; then
- OS_BITS=64
- LIB_VERSION=lib64
+  OS_BITS=64
+  if [ $uname = 'Linux' ]; then
+    osname=$(cat /etc/os-release | grep -w NAME | awk -F '=' '{print $2;}' | \
+            awk -F '"' '{if (NF==3) {print $2} else {print $1}}' | awk '{print $1}')
+    if [ $osname = 'Ubuntu' -o $osname = 'Debian' ]; then
+      LIB_VERSION=lib
+    else
+      LIB_VERSION=lib64
+    fi
+  else
+    LIB_VERSION=lib
+  fi
 else
- OS_BITS=32
- LIB_VERSION=lib
+  OS_BITS=32
+  LIB_VERSION=lib
 fi
 
 if [ "$off_bytes" -eq 8 ]; then
- OFF_BITS=64
+  OFF_BITS=64
 else
- OFF_BITS=32
+  OFF_BITS=32
 fi
 
 DEBUG_FLAG=0
 
 export CC=gcc
 CFLAGS='-Wall'
-GCC_VERSION=$(gcc -dM -E -  < /dev/null | grep -w __GNUC__ | awk '{print $NF;}')
 if [ -n "$GCC_VERSION" ] && [ $GCC_VERSION -ge 7 ]; then
   CFLAGS="$CFLAGS -Wformat-truncation=0 -Wformat-overflow=0"
 fi
@@ -67,21 +99,46 @@ else
   CFLAGS="$CFLAGS -g -O3"
 fi
 
+INCS=''
 LIBS='-lm -ldl'
+if [ -f /usr/include/curl/curl.h ] || [ -f /usr/local/include/curl/curl.h ]; then
+  CFLAGS="$CFLAGS -DUSE_LIBCURL"
+  LIBS="$LIBS -lcurl"
+fi
+
 uname=`uname`
 
 HAVE_VMMETER_H=0
 HAVE_USER_H=0
 if [ "$uname" = "Linux" ]; then
   OS_NAME=OS_LINUX
-  IOEVENT_USE=IOEVENT_USE_EPOLL
+
+  major_version=$(uname -r | awk -F . '{print $1;}')
+  minor_version=$(uname -r | awk -F . '{print $2;}')
+  if [ $major_version -eq 5 -a $minor_version -ge 14 ] || [ $major_version -gt 5 ]; then
+    out=$(grep -F IORING_OP_SEND_ZC /usr/include/liburing/io_uring.h 2>/dev/null)
+    if [ -n "$out" ]; then
+      IOEVENT_USE=IOEVENT_USE_URING
+      LIBS="$LIBS -luring"
+    else
+      IOEVENT_USE=IOEVENT_USE_EPOLL
+    fi
+  else
+    IOEVENT_USE=IOEVENT_USE_EPOLL
+  fi
+
+  if [ $glibc_minor -lt 17 ]; then
+    LIBS="$LIBS -lrt"
+  fi
 elif [ "$uname" = "FreeBSD" ] || [ "$uname" = "Darwin" ]; then
   OS_NAME=OS_FREEBSD 
   IOEVENT_USE=IOEVENT_USE_KQUEUE
   if [ "$uname" = "Darwin" ]; then
     CFLAGS="$CFLAGS -DDARWIN"
     TARGET_PREFIX=$TARGET_PREFIX/local
-    LIB_VERSION=lib
+  else
+    INCS="$INCS -I/usr/local/include"
+    LIBS="$LIBS -L/usr/local/lib"
   fi
 
   if [ -f /usr/include/sys/vmmeter.h ]; then
@@ -108,6 +165,36 @@ else
   IOEVENT_USE=IOEVENT_USE_NONE
 fi
 
+check_dirent_field()
+{
+    field_name=$1
+    upper_fname=$(echo $field_name | tr '[a-z]' '[A-Z]')
+
+tmp_src_filename=fast_check_dirent.c
+cat <<EOF > $tmp_src_filename
+#include <stdio.h>
+#include <dirent.h>
+
+int main(int argc, char *argv[])
+{
+    struct dirent dir;
+    dir.$field_name = 1;
+    printf("#define HAVE_DIRENT_$upper_fname  %d\n", dir.$field_name);
+    return 0;
+}
+EOF
+
+gcc -o a.out $tmp_src_filename 2>/dev/null && ./a.out
+/bin/rm -f a.out $tmp_src_filename
+
+}
+
+tmp_filename=fast_dirent_macros.txt
+check_dirent_field d_type   >  $tmp_filename
+check_dirent_field d_reclen >> $tmp_filename
+check_dirent_field d_namlen >> $tmp_filename
+check_dirent_field d_off    >> $tmp_filename
+
 cat <<EOF > src/_os_define.h
 #ifndef _OS_DEFINE_H
 #define _OS_DEFINE_H
@@ -130,13 +217,35 @@ cat <<EOF > src/_os_define.h
 #ifndef HAVE_USER_H
 #define HAVE_USER_H $HAVE_USER_H
 #endif
+
+$(cat $tmp_filename && /bin/rm -f $tmp_filename)
+
 #endif
 EOF
 
-if [ -f /usr/lib/libpthread.so ] || [ -f /usr/local/lib/libpthread.so ] || [ -f /usr/lib64/libpthread.so ] || [ -f /usr/lib/libpthread.a ] || [ -f /usr/local/lib/libpthread.a ] || [ -f /usr/lib64/libpthread.a ]; then
+pthread_path=''
+for path in /lib /lib64 /usr/lib /usr/lib64 /usr/local/lib; do
+  if [ -d $path ]; then
+    pthread_path=$(find $path -name libpthread.so | head -n 1)
+    if [ -n "$pthread_path" ]; then
+      break
+    fi
+
+    pthread_path=$(find $path -name libpthread.a | head -n 1)
+    if [ -n "$pthread_path" ]; then
+      break
+    fi
+  fi
+done
+
+if [ -n "$pthread_path" ]; then
   LIBS="$LIBS -lpthread"
+  line=$(nm $pthread_path 2>/dev/null | grep -F pthread_rwlockattr_setkind_np | grep -w T)
+  if [ -n "$line" ]; then
+    CFLAGS="$CFLAGS -DWITH_PTHREAD_RWLOCKATTR_SETKIND_NP=1"
+  fi
 elif [ -f /usr/lib/libc_r.so ]; then
-  line=`nm -D /usr/lib/libc_r.so | grep pthread_create | grep -w T`
+  line=$(nm -D /usr/lib/libc_r.so 2>/dev/null | grep -F pthread_create | grep -w T)
   if [ -n "$line" ]; then
     LIBS="$LIBS -lc_r"
   fi
@@ -155,7 +264,9 @@ sed_replace()
 
 cd src
 cp Makefile.in Makefile
+sed_replace "s#\\\$(CC)#gcc#g" Makefile
 sed_replace "s#\\\$(CFLAGS)#$CFLAGS#g" Makefile
+sed_replace "s#\\\$(INCS)#$INCS#g" Makefile
 sed_replace "s#\\\$(LIBS)#$LIBS#g" Makefile
 sed_replace "s#\\\$(TARGET_PREFIX)#$TARGET_PREFIX#g" Makefile
 sed_replace "s#\\\$(LIB_VERSION)#$LIB_VERSION#g" Makefile
@@ -165,3 +276,11 @@ if [ "$1" = "clean" ]; then
   /bin/rm -f Makefile _os_define.h
 fi
 
+cd tests
+cp Makefile.in Makefile
+sed_replace "s#\\\$(CC)#gcc#g" Makefile
+sed_replace "s#\\\$(INCS)#$INCS#g" Makefile
+sed_replace "s#\\\$(LIBS)#$LIBS#g" Makefile
+if [ "$1" = "clean" ]; then
+  /bin/rm -f Makefile
+fi

php-fastcommon/fastcommon.c

@@ -12,7 +12,6 @@
  * You should have received a copy of the Lesser GNU General Public License
  * along with this program. If not, see <https://www.gnu.org/licenses/>.
  */
-
 #include "php7_ext_wrapper.h"
 #include "ext/standard/info.h"
 #include "ext/standard/file.h"
@@ -94,26 +93,111 @@ const zend_fcall_info empty_fcall_info = { 0, NULL, NULL, NULL, NULL, 0, NULL, N
         { NULL, 0, NULL, 0, 0, 0, pass_rest_by_reference, return_reference, required_num_args },
 #endif
 
+ZEND_BEGIN_ARG_INFO_EX(arginfo_version, 0, 0, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_gethostaddrs, 0, 0, 0)
+ZEND_ARG_INFO(0, if_alias_prefix)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_time33_hash, 0, 0, 1)
+ZEND_ARG_INFO(0, str)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_simple_hash, 0, 0, 1)
+ZEND_ARG_INFO(0, str)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_get_line_distance_km, 0, 0, 4)
+ZEND_ARG_INFO(0, lat1)
+ZEND_ARG_INFO(0, lon1)
+ZEND_ARG_INFO(0, lat2)
+ZEND_ARG_INFO(0, lon2)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_get_first_local_ip, 0, 0, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_get_next_local_ip, 0, 0, 1)
+ZEND_ARG_INFO(0, previous_ip)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_is_private_ip, 0, 0, 1)
+ZEND_ARG_INFO(0, ip)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_id_generator_init, 0, 0, 0)
+ZEND_ARG_INFO(0, filename)
+ZEND_ARG_INFO(0, machine_id)
+ZEND_ARG_INFO(0, mid_bits)
+ZEND_ARG_INFO(0, extra_bits)
+ZEND_ARG_INFO(0, sn_bits)
+ZEND_ARG_INFO(0, mode)
+ZEND_ARG_INFO(0, flags)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_id_generator_next, 0, 0, 0)
+ZEND_ARG_INFO(0, extra)
+ZEND_ARG_INFO(0, handle)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_id_generator_get_extra, 0, 0, 1)
+ZEND_ARG_INFO(0, id)
+ZEND_ARG_INFO(0, handle)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_id_generator_get_timestamp, 0, 0, 1)
+ZEND_ARG_INFO(0, id)
+ZEND_ARG_INFO(0, handle)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_id_generator_destroy, 0, 0, 0)
+ZEND_ARG_INFO(0, handle)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_get_ifconfigs, 0, 0, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_get_cpu_count, 0, 0, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_get_sysinfo, 0, 0, 0)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_error_log, 0, 0, 1)
+ZEND_ARG_INFO(0, message)
+ZEND_ARG_INFO(0, message_type)
+ZEND_ARG_INFO(0, destination)
+ZEND_ARG_INFO(0, headers)
+ZEND_END_ARG_INFO()
+
+ZEND_BEGIN_ARG_INFO_EX(arginfo_file_put_contents, 0, 0, 2)
+ZEND_ARG_INFO(0, filename)
+ZEND_ARG_INFO(0, data)
+ZEND_ARG_INFO(0, flags)
+ZEND_ARG_INFO(0, context)
+ZEND_END_ARG_INFO()
+
 // Every user visible function must have an entry in fastcommon_functions[].
 	zend_function_entry fastcommon_functions[] = {
-		ZEND_FE(fastcommon_version, NULL)
-		ZEND_FE(fastcommon_gethostaddrs, NULL)
-		ZEND_FE(fastcommon_time33_hash, NULL)
-		ZEND_FE(fastcommon_simple_hash, NULL)
-		ZEND_FE(fastcommon_get_line_distance_km, NULL)
-		ZEND_FE(fastcommon_get_first_local_ip, NULL)
-		ZEND_FE(fastcommon_get_next_local_ip, NULL)
-		ZEND_FE(fastcommon_is_private_ip, NULL)
-		ZEND_FE(fastcommon_id_generator_init, NULL)
-		ZEND_FE(fastcommon_id_generator_next, NULL)
-		ZEND_FE(fastcommon_id_generator_get_extra, NULL)
-		ZEND_FE(fastcommon_id_generator_get_timestamp, NULL)
-		ZEND_FE(fastcommon_id_generator_destroy, NULL)
-		ZEND_FE(fastcommon_get_ifconfigs, NULL)
-		ZEND_FE(fastcommon_get_cpu_count, NULL)
-		ZEND_FE(fastcommon_get_sysinfo, NULL)
-		ZEND_FE(fastcommon_error_log, NULL)
-		ZEND_FE(fastcommon_file_put_contents, NULL)
+		ZEND_FE(fastcommon_version, arginfo_version)
+		ZEND_FE(fastcommon_gethostaddrs, arginfo_gethostaddrs)
+		ZEND_FE(fastcommon_time33_hash, arginfo_time33_hash)
+		ZEND_FE(fastcommon_simple_hash, arginfo_simple_hash)
+		ZEND_FE(fastcommon_get_line_distance_km, arginfo_get_line_distance_km)
+		ZEND_FE(fastcommon_get_first_local_ip, arginfo_get_first_local_ip)
+		ZEND_FE(fastcommon_get_next_local_ip, arginfo_get_next_local_ip)
+		ZEND_FE(fastcommon_is_private_ip, arginfo_is_private_ip)
+		ZEND_FE(fastcommon_id_generator_init, arginfo_id_generator_init)
+		ZEND_FE(fastcommon_id_generator_next, arginfo_id_generator_next)
+		ZEND_FE(fastcommon_id_generator_get_extra, arginfo_id_generator_get_extra)
+		ZEND_FE(fastcommon_id_generator_get_timestamp, arginfo_id_generator_get_timestamp)
+		ZEND_FE(fastcommon_id_generator_destroy, arginfo_id_generator_destroy)
+		ZEND_FE(fastcommon_get_ifconfigs, arginfo_get_ifconfigs)
+		ZEND_FE(fastcommon_get_cpu_count, arginfo_get_cpu_count)
+		ZEND_FE(fastcommon_get_sysinfo, arginfo_get_sysinfo)
+		ZEND_FE(fastcommon_error_log, arginfo_error_log)
+		ZEND_FE(fastcommon_file_put_contents, arginfo_file_put_contents)
 		{NULL, NULL, NULL}  /* Must be the last line */
 	};
 
@@ -168,7 +252,7 @@ PHP_MINIT_FUNCTION(fastcommon)
     log_try_init();
     le_consumer = zend_register_list_destructors_ex(id_generator_dtor, NULL,
             PHP_IDG_RESOURCE_NAME, module_number);
-    if (hash_init(&idg_htable, simple_hash, 64, 0.75) != 0) {
+    if (fc_hash_init(&idg_htable, fc_simple_hash, 64, 0.75) != 0) {
         return FAILURE;
     }
 
@@ -381,7 +465,7 @@ ZEND_FUNCTION(fastcommon_simple_hash)
 		RETURN_BOOL(false);
 	}
 
-    RETURN_LONG(simple_hash(str, str_len) & 0x7FFFFFFF);
+    RETURN_LONG(fc_simple_hash(str, str_len) & 0x7FFFFFFF);
 }
 
 /*
@@ -518,7 +602,7 @@ static struct idg_context *get_idg_context(const char *filename,
     key_info.extra_bits = extra_bits;
     key_info.sn_bits = sn_bits;
 
-    idg_context = (struct idg_context *)hash_find(&idg_htable,
+    idg_context = (struct idg_context *)fc_hash_find(&idg_htable,
             &key_info, sizeof(key_info));
     if (idg_context == NULL) {
         idg_context = (struct idg_context *)malloc(sizeof(struct idg_context));
@@ -534,7 +618,7 @@ static struct idg_context *get_idg_context(const char *filename,
         {
             return NULL;
         }
-        hash_insert_ex(&idg_htable, &key_info, sizeof(key_info),
+        fc_hash_insert_ex(&idg_htable, &key_info, sizeof(key_info),
                 idg_context, 0, false);
     }
 
@@ -1153,8 +1237,8 @@ static PHPFileContext *fetch_file_context(const char *filename)
 
 static int fc_open_file(PHPFileContext *ctx)
 {
-	if ((ctx->fd = open(ctx->filename, O_WRONLY |
-				O_CREAT | O_APPEND, 0644)) < 0)
+	if ((ctx->fd = open(ctx->filename, O_WRONLY | O_CREAT |
+                    O_APPEND | O_CLOEXEC, 0644)) < 0)
     {
         logError("file: "__FILE__", line: %d, "
                 "open file \"%s\" to write fail, "

src/Makefile.in

@@ -1,7 +1,7 @@
 .SUFFIXES: .c .o .lo
 
 COMPILE = $(CC) $(CFLAGS)
-INC_PATH = 
+INC_PATH = $(INCS)
 LIB_PATH = $(LIBS)
 TARGET_LIB = $(TARGET_PREFIX)/$(LIB_VERSION)
 
@@ -14,9 +14,10 @@ FAST_SHARED_OBJS = hash.lo chain.lo shared_func.lo ini_file_reader.lo \
                    fast_buffer.lo multi_skiplist.lo flat_skiplist.lo \
                    system_info.lo fast_blocked_queue.lo id_generator.lo \
 				   char_converter.lo char_convert_loader.lo common_blocked_queue.lo \
-                   multi_socket_client.lo skiplist_set.lo uniq_skiplist.lo \
-                   json_parser.lo buffered_file_writer.lo server_id_func.lo \
-                   fc_queue.lo fc_memory.lo shared_buffer.lo thread_pool.lo
+                   multi_socket_client.lo skiplist_set.lo uniq_skiplist.lo   \
+                   json_parser.lo buffered_file_writer.lo server_id_func.lo  \
+                   fc_queue.lo sorted_queue.lo fc_memory.lo shared_buffer.lo \
+                   thread_pool.lo array_allocator.lo sorted_array.lo spinlock.lo
 
 FAST_STATIC_OBJS = hash.o chain.o shared_func.o ini_file_reader.o \
                    logger.o sockopt.o base64.o sched_thread.o \
@@ -27,9 +28,10 @@ FAST_STATIC_OBJS = hash.o chain.o shared_func.o ini_file_reader.o \
                    fast_buffer.o multi_skiplist.o flat_skiplist.o  \
                    system_info.o fast_blocked_queue.o id_generator.o \
 				   char_converter.o char_convert_loader.o common_blocked_queue.o \
-                   multi_socket_client.o skiplist_set.o uniq_skiplist.o \
+                   multi_socket_client.o skiplist_set.o uniq_skiplist.o  \
                    json_parser.o buffered_file_writer.o server_id_func.o \
-                   fc_queue.o fc_memory.o shared_buffer.o thread_pool.o
+                   fc_queue.o sorted_queue.o fc_memory.o shared_buffer.o \
+                   thread_pool.o array_allocator.o sorted_array.o spinlock.o
 
 HEADER_FILES = common_define.h hash.h chain.h logger.h base64.h \
                shared_func.h pthread_func.h ini_file_reader.h _os_define.h \
@@ -42,8 +44,10 @@ HEADER_FILES = common_define.h hash.h chain.h logger.h base64.h \
                php7_ext_wrapper.h id_generator.h char_converter.h \
 			   char_convert_loader.h common_blocked_queue.h  \
                multi_socket_client.h skiplist_set.h uniq_skiplist.h \
-               fc_list.h json_parser.h buffered_file_writer.h server_id_func.h \
-               fc_queue.h fc_memory.h shared_buffer.h thread_pool.h fc_atomic.h
+               fc_list.h locked_list.h json_parser.h buffered_file_writer.h \
+               server_id_func.h fc_queue.h sorted_queue.h fc_memory.h \
+               shared_buffer.h thread_pool.h fc_atomic.h array_allocator.h \
+               sorted_array.h spinlock.h
 
 ALL_OBJS = $(FAST_STATIC_OBJS) $(FAST_SHARED_OBJS)
 
@@ -74,7 +78,7 @@ install:
 	install -m 644 $(HEADER_FILES) $(TARGET_PREFIX)/include/fastcommon
 
 	@BUILDROOT=$$(echo "$(TARGET_PREFIX)" | grep BUILDROOT); \
-	if [ -z "$$BUILDROOT" ] && [ ! -e $(TARGET_PREFIX)/lib/libfastcommon.so ]; then ln -s $(TARGET_LIB)/libfastcommon.so $(TARGET_PREFIX)/lib/libfastcommon.so; fi
+	if [ -z "$$BUILDROOT" ] && [ "$(TARGET_LIB)" != "$(TARGET_PREFIX)/lib" ]; then ln -sf $(TARGET_LIB)/libfastcommon.so $(TARGET_PREFIX)/lib/libfastcommon.so; fi
 clean:
 	rm -f $(ALL_OBJS) $(ALL_PRGS) $(ALL_LIBS)
 

src/array_allocator.c

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) 2020 YuQing <384681@qq.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "shared_func.h"
+#include "array_allocator.h"
+
+int array_allocator_init_ex(ArrayAllocatorContext *ctx,
+        const char *name_prefix, const int element_size,
+        const int min_bits, const int max_bits,
+        const bool need_lock)
+{
+    const int obj_size = 0;
+    const int reclaim_interval = 0;
+    char name[32];
+    struct fast_region_info regions[32];
+    struct fast_region_info *region;
+    int bit;
+    int start;
+    int end;
+    int alloc_elements_once;
+    int step;
+
+    ctx->element_size = element_size;
+    ctx->min_count = (1 << min_bits);
+    start = 0;
+    alloc_elements_once = (1 << (max_bits - min_bits + 2));
+    for (bit=min_bits, region=regions;
+            bit<=max_bits; bit++, region++)
+    {
+        end = sizeof(VoidArray) + (1 << bit) * ctx->element_size;
+        step = end - start;
+        FAST_ALLOCATOR_INIT_REGION(*region, start,
+                end, step, alloc_elements_once);
+        alloc_elements_once /= 2;
+        start = end;
+    }
+
+    fc_combine_two_strings(name_prefix, "array", '-', name);
+    return fast_allocator_init_ex(&ctx->allocator, name,
+            obj_size, NULL, regions, region - regions, 0,
+            0.9999, reclaim_interval, need_lock);
+}
+
+VoidArray *array_allocator_alloc(ArrayAllocatorContext *ctx,
+        const int target_count)
+{
+    int alloc;
+    int bytes;
+    VoidArray *array;
+
+    if (target_count <= ctx->min_count) {
+        alloc = ctx->min_count;
+    } else if (is_power2(target_count)) {
+        alloc = target_count;
+    } else {
+        alloc = ctx->min_count;
+        while (alloc < target_count) {
+            alloc *= 2;
+        }
+    }
+
+    bytes = sizeof(VoidArray) + alloc * ctx->element_size;
+    if ((array=fast_allocator_alloc(&ctx->allocator, bytes)) != NULL) {
+        array->alloc = alloc;
+        array->count = 0;
+    }
+    return array;
+}
+
+VoidArray *array_allocator_realloc(ArrayAllocatorContext *ctx,
+        VoidArray *old_array, const int target_count)
+{
+    VoidArray *new_array;
+
+    if (old_array == NULL) {
+        return array_allocator_alloc(ctx, target_count);
+    }
+
+    if (old_array->alloc >= target_count) {
+        return old_array;
+    }
+
+    if ((new_array=array_allocator_alloc(ctx, target_count)) != NULL) {
+        if (old_array->count > 0) {
+            memcpy(new_array->elts, old_array->elts, ctx->
+                    element_size * old_array->count);
+        }
+        new_array->count = old_array->count;
+    }
+
+    array_allocator_free(ctx, old_array);
+    return new_array;
+}
+
+int array_compare_element_int64(const int64_t *n1, const int64_t *n2)
+{
+    int64_t sub;
+    sub = *n1 - *n2;
+    if (sub < 0) {
+        return -1;
+    } else if (sub > 0) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+int array_compare_element_int32(const int32_t *n1, const int32_t *n2)
+{
+    return *n1 - *n2;
+}
+
+int array_compare_element_id_name(const id_name_pair_t *pair1,
+        const id_name_pair_t *pair2)
+{
+    return fc_compare_int64(pair1->id, pair2->id);
+}

src/array_allocator.h

@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2020 YuQing <384681@qq.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef ARRAY_ALLOCATOR_H
+#define ARRAY_ALLOCATOR_H
+
+#include "fast_allocator.h"
+
+typedef struct
+{
+    int alloc;
+    int count;
+    char elts[0];
+} VoidArray;
+
+typedef struct
+{
+    int alloc;
+    int count;
+    int64_t elts[0];
+} I64Array;
+
+typedef struct
+{
+    int alloc;
+    int count;
+    int32_t elts[0];
+} I32Array;
+
+typedef struct
+{
+    int alloc;
+    int count;
+    id_name_pair_t elts[0];
+} IdNameArray;
+
+typedef struct
+{
+    int alloc;
+    int count;
+    void *elts[0];
+} PointerArray;
+
+typedef struct array_allocator_context
+{
+    struct fast_allocator_context allocator;
+    int element_size;
+    int min_count;
+} ArrayAllocatorContext;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    int array_allocator_init_ex(ArrayAllocatorContext *ctx,
+            const char *name_prefix, const int element_size,
+            const int min_bits, const int max_bits,
+            const bool need_lock);
+
+    VoidArray *array_allocator_alloc(ArrayAllocatorContext *ctx,
+            const int target_count);
+
+    VoidArray *array_allocator_realloc(ArrayAllocatorContext *ctx,
+            VoidArray *old_array, const int target_count);
+
+    static inline void array_allocator_free(ArrayAllocatorContext *ctx,
+            VoidArray *array)
+    {
+        fast_allocator_free(&ctx->allocator, array);
+    }
+
+    /* comparator for 64 bits integer */
+    int array_compare_element_int64(const int64_t *n1, const int64_t *n2);
+
+    /* comparator for 32 bits integer */
+    int array_compare_element_int32(const int32_t *n1, const int32_t *n2);
+
+    /* comparator for id name pair (sorted by id) */
+    int array_compare_element_id_name(const id_name_pair_t *pair1,
+            const id_name_pair_t *pair2);
+
+#define array_allocator_init(ctx, name_prefix, \
+        element_size, min_bits, max_bits)      \
+    array_allocator_init_ex(ctx, name_prefix,  \
+        element_size, min_bits, max_bits, true)
+
+#define i64_array_allocator_init_ex(ctx, min_bits, max_bits, need_lock) \
+    array_allocator_init_ex(ctx, "i64", sizeof(int64_t), \
+            min_bits, max_bits, need_lock)
+
+#define i64_array_allocator_init(ctx, min_bits, max_bits) \
+        i64_array_allocator_init_ex(ctx, min_bits, max_bits, true)
+
+#define i64_array_allocator_alloc(ctx, target_count) \
+    (I64Array *)array_allocator_alloc(ctx, target_count)
+
+#define i64_array_allocator_realloc(ctx, old_array, target_count) \
+    (I64Array *)array_allocator_realloc(ctx, \
+            (VoidArray *)old_array, target_count)
+
+#define i64_array_allocator_free(ctx, array) \
+    array_allocator_free(ctx, (VoidArray *)array)
+
+
+#define i32_array_allocator_init_ex(ctx, min_bits, max_bits, need_lock) \
+    array_allocator_init_ex(ctx, "i32", sizeof(int32_t), \
+            min_bits, max_bits, need_lock)
+
+#define i32_array_allocator_init(ctx, min_bits, max_bits) \
+        i32_array_allocator_init_ex(ctx, min_bits, max_bits, true)
+
+#define i32_array_allocator_alloc(ctx, target_count) \
+    (I32Array *)array_allocator_alloc(ctx, target_count)
+
+#define i32_array_allocator_realloc(ctx, old_array, target_count) \
+    (I32Array *)array_allocator_realloc(ctx, \
+            (VoidArray *)old_array, target_count)
+
+#define i32_array_allocator_free(ctx, array) \
+    array_allocator_free(ctx, (VoidArray *)array)
+
+
+#define id_name_array_allocator_init_ex(ctx, min_bits, max_bits, need_lock) \
+    array_allocator_init_ex(ctx, "id_name", sizeof(id_name_pair_t), \
+            min_bits, max_bits, need_lock)
+
+#define id_name_array_allocator_init(ctx, min_bits, max_bits) \
+    id_name_array_allocator_init_ex(ctx, min_bits, max_bits, true)
+
+#define id_name_array_allocator_alloc(ctx, target_count) \
+    (IdNameArray *)array_allocator_alloc(ctx, target_count)
+
+#define id_name_array_allocator_realloc(ctx, old_array, target_count) \
+    (IdNameArray *)array_allocator_realloc(ctx, \
+            (VoidArray *)old_array, target_count)
+
+#define id_name_array_allocator_free(ctx, array) \
+    array_allocator_free(ctx, (VoidArray *)array)
+
+
+#define ptr_array_allocator_init_ex(ctx, min_bits, max_bits, need_lock) \
+    array_allocator_init_ex(ctx, "ptr", sizeof(void *), \
+            min_bits, max_bits, need_lock)
+
+#define ptr_array_allocator_init(ctx, min_bits, max_bits) \
+        ptr_array_allocator_init_ex(ctx, min_bits, max_bits, true)
+
+#define ptr_array_allocator_alloc(ctx, target_count) \
+    (PointerArray *)array_allocator_alloc(ctx, target_count)
+
+#define ptr_array_allocator_realloc(ctx, old_array, target_count) \
+    (PointerArray *)array_allocator_realloc(ctx, \
+            (VoidArray *)old_array, target_count)
+
+#define ptr_array_allocator_free(ctx, array) \
+    array_allocator_free(ctx, (VoidArray *)array)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/base64.c

@@ -24,6 +24,7 @@
 #include <fcntl.h>
 #include <errno.h>
 #include "fc_memory.h"
+#include "shared_func.h"
 #include "base64.h"
 
 /**
@@ -53,15 +54,11 @@ void base64_set_line_length(struct base64_context *context, const int length)
     * Usually contains only a combination of chars \n and \r.
     * Could be any chars not in set A-Z a-z 0-9 + /.
 */
-void base64_set_line_separator(struct base64_context *context, \
+void base64_set_line_separator(struct base64_context *context,
 		const char *pLineSeparator)
 {
-    context->line_sep_len = snprintf(context->line_separator, \
-			sizeof(context->line_separator), "%s", pLineSeparator);
-    if (context->line_sep_len >= sizeof(context->line_separator))
-    {
-        context->line_sep_len = sizeof(context->line_separator) - 1;
-    }
+    context->line_sep_len = fc_safe_strcpy(context->
+            line_separator, pLineSeparator);
 }
 
 void base64_init_ex(struct base64_context *context, const int nLineLength, \

src/buffered_file_writer.c

@@ -48,8 +48,9 @@ int buffered_file_writer_open_ex(BufferedFileWriter *writer,
         return ENOMEM;
     }
 
-    snprintf(writer->filename, sizeof(writer->filename), "%s", filename);
-    writer->fd = open(writer->filename, O_WRONLY | O_CREAT | O_TRUNC, mode);
+    fc_safe_strcpy(writer->filename, filename);
+    writer->fd = open(writer->filename, O_WRONLY |
+            O_CREAT | O_TRUNC | O_CLOEXEC, mode);
     if (writer->fd < 0)
     {
         result = errno != 0 ? errno : EIO;

src/common_blocked_queue.c

@@ -34,7 +34,7 @@ int common_blocked_queue_init_ex(struct common_blocked_queue *queue,
 		return result;
 	}
 
-    if ((result=fast_mblock_init_ex1(&queue->mblock, "queue_node",
+    if ((result=fast_mblock_init_ex1(&queue->mblock, "queue-node",
                     sizeof(struct common_blocked_node),
                     alloc_elements_once, alloc_elements_limit,
                     NULL, NULL, false)) != 0)
@@ -102,6 +102,29 @@ int common_blocked_queue_push_ex(struct common_blocked_queue *queue,
 	return 0;
 }
 
+void common_blocked_queue_push_chain_ex(struct common_blocked_queue *queue,
+        struct common_blocked_chain *chain, bool *notify)
+{
+    if (chain->head == NULL)
+    {
+        return;
+    }
+
+    pthread_mutex_lock(&(queue->lc_pair.lock));
+    if (queue->head == NULL)
+    {
+        queue->head = chain->head;
+        *notify = true;
+    }
+    else
+    {
+        queue->tail->next = chain->head;
+        *notify = false;
+    }
+    queue->tail = chain->tail;
+    pthread_mutex_unlock(&(queue->lc_pair.lock));
+}
+
 void common_blocked_queue_return_nodes(struct common_blocked_queue *queue,
         struct common_blocked_node *node)
 {
@@ -185,6 +208,58 @@ void *common_blocked_queue_pop_ex(struct common_blocked_queue *queue,
 	return data;
 }
 
+void *common_blocked_queue_timedpop(struct common_blocked_queue *queue,
+        const int timeout, const int time_unit)
+{
+    struct common_blocked_node *node;
+    void *data;
+    int result;
+
+    if ((result=pthread_mutex_lock(&(queue->lc_pair.lock))) != 0)
+    {
+        logError("file: "__FILE__", line: %d, "
+                "call pthread_mutex_lock fail, "
+                "errno: %d, error info: %s",
+                __LINE__, result, STRERROR(result));
+        return NULL;
+    }
+
+    do {
+        node = queue->head;
+        if (node == NULL)
+        {
+            fc_cond_timedwait(&queue->lc_pair, timeout, time_unit);
+            node = queue->head;
+        }
+
+        if (node != NULL)
+        {
+            queue->head = node->next;
+            if (queue->head == NULL)
+            {
+                queue->tail = NULL;
+            }
+
+            data = node->data;
+            fast_mblock_free_object(&queue->mblock, node);
+        }
+        else
+        {
+            data = NULL;
+        }
+    } while (0);
+
+    if ((result=pthread_mutex_unlock(&(queue->lc_pair.lock))) != 0)
+    {
+        logError("file: "__FILE__", line: %d, "
+                "call pthread_mutex_unlock fail, "
+                "errno: %d, error info: %s",
+                __LINE__, result, STRERROR(result));
+    }
+
+    return data;
+}
+
 struct common_blocked_node *common_blocked_queue_pop_all_nodes_ex(
         struct common_blocked_queue *queue, const bool blocked)
 {

src/common_blocked_queue.h

@@ -31,6 +31,12 @@ struct common_blocked_node
     struct common_blocked_node *next;
 };
 
+struct common_blocked_chain
+{
+    struct common_blocked_node *head;
+    struct common_blocked_node *tail;
+};
+
 struct common_blocked_queue
 {
 	struct common_blocked_node *head;
@@ -88,6 +94,41 @@ static inline int common_blocked_queue_push(struct common_blocked_queue
     return result;
 }
 
+static inline struct common_blocked_node *common_blocked_queue_alloc_node(
+        struct common_blocked_queue *queue)
+{
+    struct common_blocked_node *node;
+
+    pthread_mutex_lock(&(queue->lc_pair.lock));
+    node = (struct common_blocked_node *)fast_mblock_alloc_object(&queue->mblock);
+    pthread_mutex_unlock(&(queue->lc_pair.lock));
+    return node;
+}
+
+static inline void common_blocked_queue_free_node(
+        struct common_blocked_queue *queue,
+        struct common_blocked_node *node)
+{
+    pthread_mutex_lock(&(queue->lc_pair.lock));
+    fast_mblock_free_object(&queue->mblock, node);
+    pthread_mutex_unlock(&(queue->lc_pair.lock));
+}
+
+void common_blocked_queue_push_chain_ex(struct common_blocked_queue *queue,
+        struct common_blocked_chain *chain, bool *notify);
+
+static inline void common_blocked_queue_push_chain(
+        struct common_blocked_queue *queue,
+        struct common_blocked_chain *chain)
+{
+    bool notify;
+
+    common_blocked_queue_push_chain_ex(queue, chain, &notify);
+    if (notify)
+    {
+        pthread_cond_signal(&(queue->lc_pair.cond));
+    }
+}
 
 void common_blocked_queue_return_nodes(struct common_blocked_queue *queue,
         struct common_blocked_node *node);
@@ -95,6 +136,36 @@ void common_blocked_queue_return_nodes(struct common_blocked_queue *queue,
 void *common_blocked_queue_pop_ex(struct common_blocked_queue *queue,
         const bool blocked);
 
+static inline bool common_blocked_queue_empty(
+        struct common_blocked_queue *queue)
+{
+    bool empty;
+
+    pthread_mutex_lock(&queue->lc_pair.lock);
+    empty = (queue->head == NULL);
+    pthread_mutex_unlock(&queue->lc_pair.lock);
+    return empty;
+}
+
+static inline int common_blocked_queue_count(
+        struct common_blocked_queue *queue)
+{
+    int count;
+    struct common_blocked_node *node;
+
+    count = 0;
+    pthread_mutex_lock(&queue->lc_pair.lock);
+    node = queue->head;
+    while (node != NULL)
+    {
+        ++count;
+        node = node->next;
+    }
+    pthread_mutex_unlock(&queue->lc_pair.lock);
+    return count;
+}
+
+
 #define common_blocked_queue_pop(queue) \
     common_blocked_queue_pop_ex(queue, true)
 
@@ -111,11 +182,23 @@ struct common_blocked_node *common_blocked_queue_pop_all_nodes_ex(
     common_blocked_queue_pop_all_nodes_ex(queue, false)
 
 #define common_blocked_queue_free_one_node(queue, node) \
-    fast_mblock_free_object(&queue->mblock, node)
+    common_blocked_queue_free_node(&queue->mblock, node)
 
 void common_blocked_queue_free_all_nodes(struct common_blocked_queue *queue,
         struct common_blocked_node *node);
 
+void *common_blocked_queue_timedpop(struct common_blocked_queue *queue,
+        const int timeout, const int time_unit);
+
+#define common_blocked_queue_timedpop_sec(queue, timeout) \
+    common_blocked_queue_timedpop(queue, timeout, FC_TIME_UNIT_SECOND)
+
+#define common_blocked_queue_timedpop_ms(queue, timeout) \
+    common_blocked_queue_timedpop(queue, timeout, FC_TIME_UNIT_MSECOND)
+
+#define common_blocked_queue_timedpop_us(queue, timeout) \
+    common_blocked_queue_timedpop(queue, timeout, FC_TIME_UNIT_USECOND)
+
 #ifdef __cplusplus
 }
 #endif

src/common_define.h

@@ -21,6 +21,7 @@
 #include <pthread.h>
 #include <string.h>
 #include <errno.h>
+#include <limits.h>
 
 #ifdef WIN32
 
@@ -34,6 +35,7 @@ typedef DWORD (WINAPI *ThreadEntranceFunc)(LPVOID lpThreadParameter);
 #else
 
 #include <unistd.h>
+#include <fcntl.h>
 #include <signal.h>
 #include <stdbool.h>
 #include <inttypes.h>
@@ -41,6 +43,14 @@ typedef DWORD (WINAPI *ThreadEntranceFunc)(LPVOID lpThreadParameter);
 #include <arpa/inet.h>
 #include <sys/types.h>
 #include <sys/socket.h>
+
+#ifdef OS_FREEBSD
+//#include <sys/syscall.h>
+#endif
+
+/* Internet address (兼容IPv6长度).  */
+typedef uint64_t in_addr_64_t;
+
 #define FILE_SEPERATOR	"/"
 typedef int SOCKET;
 #define closesocket     close
@@ -58,6 +68,10 @@ extern int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind);
 
 #include "_os_define.h"
 
+#ifdef OS_LINUX
+#include <sys/prctl.h>
+#endif
+
 #ifdef OS_LINUX
 #ifndef PTHREAD_MUTEX_ERRORCHECK
 #define PTHREAD_MUTEX_ERRORCHECK PTHREAD_MUTEX_ERRORCHECK_NP
@@ -98,9 +112,37 @@ extern int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind);
 #define SYNC_LOG_BUFF_DEF_INTERVAL      10
 #define TIME_NONE                       -1
 
-#define IP_ADDRESS_SIZE	16
+#define FC_BYTES_ONE_KB      (  1 << 10)
+#define FC_BYTES_ONE_MB      (  1 << 20)
+#define FC_BYTES_ONE_GB      (  1 << 30)
+#define FC_BYTES_ONE_TB      (1LL << 40)
+#define FC_BYTES_ONE_PB      (1LL << 50)
+#define FC_BYTES_ONE_EB      (1LL << 60)
+
+#if defined(IOV_MAX) && IOV_MAX > 256
+#define FC_IOV_BATCH_SIZE  256
+#else
+#define FC_IOV_BATCH_SIZE  IOV_MAX
+#endif
+
+#define IPV4_ADDRESS_SIZE   INET_ADDRSTRLEN   //16
+#define IPV6_ADDRESS_SIZE   INET6_ADDRSTRLEN  //46
+#define IP_ADDRESS_SIZE     INET6_ADDRSTRLEN  //46
+#define FORMATTED_IP_SIZE   (IP_ADDRESS_SIZE + 2)
 #define INFINITE_FILE_SIZE (256 * 1024LL * 1024 * 1024 * 1024 * 1024LL)
 
+#define FILE_RESOURCE_TAG_STR  "file://"
+#define FILE_RESOURCE_TAG_LEN  (sizeof(FILE_RESOURCE_TAG_STR) - 1)
+
+#define IS_FILE_RESOURCE(filename) \
+    (strncasecmp(filename, FILE_RESOURCE_TAG_STR,  \
+                 FILE_RESOURCE_TAG_LEN) == 0)
+
+#define IS_FILE_RESOURCE_EX(filename) \
+    ((filename)->len >= FILE_RESOURCE_TAG_LEN &&     \
+     memcmp((filename)->str, FILE_RESOURCE_TAG_STR,  \
+         FILE_RESOURCE_TAG_LEN) == 0)
+
 #ifndef byte
 #define byte signed char
 #endif
@@ -119,6 +161,10 @@ extern int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind);
 #define ECANCELED 125
 #endif
 
+#ifndef ENODATA
+#define ENODATA         61      /* No data available */
+#endif
+
 #ifndef ENONET
 #define ENONET          64      /* Machine is not on the network */
 #endif
@@ -131,8 +177,34 @@ extern int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind);
 #define FC_IS_LETTER(ch)  ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z'))
 #define FC_IS_UPPER_LETTER(ch)  (ch >= 'A' && ch <= 'Z')
 #define FC_IS_LOWER_LETTER(ch)  (ch >= 'a' && ch <= 'z')
-#define FC_MIN(v1, v2) (v1 < v2 ? v1 : v2)
-#define FC_MAX(v1, v2) (v1 > v2 ? v1 : v2)
+#define FC_MIN(v1, v2) ((v1) < (v2) ? (v1) : (v2))
+#define FC_MAX(v1, v2) ((v1) > (v2) ? (v1) : (v2))
+#define FC_ABS(n) ((n) >= 0 ? (n) : -1 * (n))
+#define FC_NEGATIVE(n) ((n) <= 0 ? (n) : -1 * (n))
+
+#define FC_TIME_UNIT_SECOND   's'  //second
+#define FC_TIME_UNIT_MSECOND  'm'  //millisecond
+#define FC_TIME_UNIT_USECOND  'u'  //microsecond
+#define FC_TIME_UNIT_NSECOND  'n'  //nanosecond
+
+#define FC_1E01                     10LL
+#define FC_1E02                    100LL
+#define FC_1E03                   1000LL
+#define FC_1E04                  10000LL
+#define FC_1E05                 100000LL
+#define FC_1E06                1000000LL
+#define FC_1E07               10000000LL
+#define FC_1E08              100000000LL
+#define FC_1E09             1000000000LL
+#define FC_1E10            10000000000LL
+#define FC_1E11           100000000000LL
+#define FC_1E12          1000000000000LL
+#define FC_1E13         10000000000000LL
+#define FC_1E14        100000000000000LL
+#define FC_1E15       1000000000000000LL
+#define FC_1E16      10000000000000000LL
+#define FC_1E17     100000000000000000LL
+#define FC_1E18    1000000000000000000LL
 
 #define STRERROR(no) (strerror(no) != NULL ? strerror(no) : "Unkown error")
 
@@ -143,10 +215,12 @@ extern int pthread_mutexattr_settype(pthread_mutexattr_t *attr, int kind);
 #define st_ctimensec st_ctim.tv_nsec
 #endif
 #elif defined(OS_FREEBSD)
+#ifndef st_atimensec
 #define st_atimensec st_atimespec.tv_nsec
 #define st_mtimensec st_mtimespec.tv_nsec
 #define st_ctimensec st_ctimespec.tv_nsec
 #endif
+#endif
 
 #ifdef __cplusplus
 extern "C" {
@@ -166,6 +240,12 @@ typedef struct
     char patch;
 } Version;
 
+typedef struct
+{
+    char **strs;
+    int count;
+} str_ptr_array_t;
+
 typedef struct
 {
 	char *key;
@@ -199,6 +279,12 @@ typedef struct
     int count;
 } string_array_t;
 
+typedef struct
+{
+    int64_t id;
+    string_t name;
+} id_name_pair_t;
+
 typedef struct
 {
     string_t key;
@@ -211,18 +297,80 @@ typedef struct
     int count;
 } key_value_array_t;
 
+typedef struct
+{
+    int32_t *elts;
+    int count;
+} int32_array_t;
+
+typedef struct
+{
+    int64_t *elts;
+    int count;
+} int64_array_t;
+
+typedef struct
+{
+    id_name_pair_t *elts;
+    int count;
+} id_name_array_t;
+
+typedef struct
+{
+    void *elts;
+    int count;
+} void_array_t;
+
 typedef struct
 {
     pthread_mutex_t lock;
     pthread_cond_t cond;
 } pthread_lock_cond_pair_t;
 
+typedef struct
+{
+    int alloc;
+    int count;
+    struct iovec *iovs;
+} iovec_array_t;
+
+typedef struct
+{
+    char buff[PATH_MAX];
+    string_t s;
+} FilenameString;
+
+typedef struct {
+    char *filename;
+    char *tmp_filename;
+    int fd;
+} SafeWriteFileInfo;
+
+typedef struct {
+    char filename[PATH_MAX];
+    int fd;
+} FilenameFDPair;
+
 typedef void (*FreeDataFunc)(void *ptr);
 typedef int (*CompareFunc)(void *p1, void *p2);
 typedef void* (*MallocFunc)(size_t size);
 
 #define TO_UPPERCASE(c)  (((c) >= 'a' && (c) <= 'z') ? (c) - 32 : c)
-#define MEM_ALIGN(x)  (((x) + 7) & (~7))
+
+#define MEM_ALIGN_FLOOR(x, align_size)  ((x) & (~(align_size - 1)))
+#define MEM_ALIGN_CEIL(x, align_size) \
+    (((x) + (align_size - 1)) & (~(align_size - 1)))
+#define MEM_ALIGN(x)  MEM_ALIGN_CEIL(x, 8)
+
+#define MEM_ALIGN_FLOOR_BY_MASK(x, align_mask)  ((x) & (~align_mask))
+#define MEM_ALIGN_CEIL_BY_MASK(x, align_mask)  \
+    (((x) + align_mask) & (~align_mask))
+
+#define FC_INIT_CHAIN(chain) (chain).head = (chain).tail = NULL
+#define FC_IS_CHAIN_EMPTY(chain) ((chain).head == NULL)
+
+#define FC_SET_CHAIN_TAIL_NEXT(chain, type, ptr) \
+    ((type *)(chain).tail)->next = ptr
 
 #ifdef WIN32
 #define strcasecmp	_stricmp
@@ -255,6 +403,12 @@ typedef void* (*MallocFunc)(size_t size);
 //for printf format %.*s
 #define FC_PRINTF_STAR_STRING_PARAMS(s)  (s).len, (s).str
 
+#define FC_SET_IOVEC(iovec, buff, len) \
+    do {  \
+        (iovec).iov_base = buff; \
+        (iovec).iov_len = len;   \
+    } while (0)
+
 #define FC_SET_STRING(dest, src)  \
     do {  \
         (dest).str = src;         \
@@ -267,6 +421,8 @@ typedef void* (*MallocFunc)(size_t size);
         (dest).len = l;   \
     } while (0)
 
+#define FC_SET_STRING_EMPTY(dest, s) FC_SET_STRING_EX(dest, s, 0)
+
 #define FC_SET_STRING_NULL(dest)  \
     do {  \
         (dest).str = NULL;   \
@@ -276,6 +432,13 @@ typedef void* (*MallocFunc)(size_t size);
 #define FC_IS_NULL_STRING(s)  ((s)->str == NULL)
 #define FC_IS_EMPTY_STRING(s)  ((s)->len == 0)
 
+#define FC_INIT_FILENAME_STRING(filename)  \
+    FC_SET_STRING_EX((filename).s, (filename).buff, 0)
+
+#define FC_FILENAME_STRING_OBJ(filename)  ((filename).s)
+#define FC_FILENAME_STRING_PTR(filename)  ((filename).buff)
+#define FC_FILENAME_BUFFER_SIZE(filename)  sizeof((filename).buff)
+
 #define fc_compare_string(s1, s2) fc_string_compare(s1, s2)
 
 static inline int fc_string_compare(const string_t *s1, const string_t *s2)
@@ -292,6 +455,14 @@ static inline int fc_string_compare(const string_t *s1, const string_t *s2)
     }
 }
 
+static inline bool fc_string_equal_ex(const char *str1,
+        const int len1, const char *str2, const int len2)
+{
+    return (len1 == len2) && (memcmp(str1, str2, len1) == 0);
+}
+#define fc_string_equals_ex(str1, len1, str2, len2) \
+    fc_string_equal_ex(str1, len1, str2, len2)
+
 static inline bool fc_string_equal(const string_t *s1, const string_t *s2)
 {
     return (s1->len == s2->len) && (memcmp(s1->str, s2->str, s1->len) == 0);
@@ -306,6 +477,39 @@ static inline bool fc_string_equal2(const string_t *s1,
 #define fc_string_equals(s1, s2) fc_string_equal(s1, s2)
 #define fc_string_equals2(s1, str2, len2) fc_string_equal2(s1, str2, len2)
 
+
+#define fc_case_compare_string(s1, s2) fc_string_case_compare(s1, s2)
+
+static inline int fc_string_case_compare(const string_t *s1, const string_t *s2)
+{
+    int result;
+    if (s1->len == s2->len) {
+        return strncasecmp(s1->str, s2->str, s1->len);
+    } else if (s1->len < s2->len) {
+        result = strncasecmp(s1->str, s2->str, s1->len);
+        return result == 0 ? -1 : result;
+    } else {
+        result = strncasecmp(s1->str, s2->str, s2->len);
+        return result == 0 ? 1 : result;
+    }
+}
+
+static inline bool fc_string_case_equal(const string_t *s1, const string_t *s2)
+{
+    return (s1->len == s2->len) && (strncasecmp(s1->str, s2->str, s1->len) == 0);
+}
+
+static inline bool fc_string_case_equal2(const string_t *s1,
+        const char *str2, const int len2)
+{
+    return (s1->len == len2) && (strncasecmp(s1->str, str2, s1->len) == 0);
+}
+
+#define fc_string_case_equals(s1, s2) fc_string_case_equal(s1, s2)
+#define fc_string_case_equals2(s1, str2, len2) \
+    fc_string_case_equal2(s1, str2, len2)
+
+
 static inline int fc_compare_int64(const int64_t n1, const int64_t n2)
 {
     int64_t sub;
@@ -319,6 +523,42 @@ static inline int fc_compare_int64(const int64_t n1, const int64_t n2)
     }
 }
 
+#ifdef OS_LINUX
+static inline int fc_fallocate(int fd, const int64_t size)
+{
+    if (fallocate(fd, 0, 0, size) < 0) {
+        if (errno == EOPNOTSUPP) {
+            return ftruncate(fd, size);
+        }
+        return -1;
+    }
+
+    return 0;
+}
+
+#else
+#define fc_fallocate(fd, size)  ftruncate(fd, size)
+#define posix_fadvise(fd, offset, len, advice)  0
+
+#ifndef POSIX_FADV_NORMAL
+#define POSIX_FADV_NORMAL     0 /* No further special treatment.  */
+#define POSIX_FADV_RANDOM     1 /* Expect random page references.  */
+#define POSIX_FADV_SEQUENTIAL 2 /* Expect sequential page references.  */
+#define POSIX_FADV_WILLNEED   3 /* Will need these pages.  */
+#define POSIX_FADV_DONTNEED   4 /* Don't need these pages.  */
+#define POSIX_FADV_NOREUSE    5 /* Data will be accessed once.  */
+#endif
+
+#ifdef OS_FREEBSD
+//#define fdatasync(fd) syscall(SYS_fdatasync, fd)
+#define fdatasync(fd) fsync(fd)
+#endif
+
+#endif
+
+#define FC_MACRO_STRINGIFY(x) #x
+#define FC_MACRO_TOSTRING(x)  FC_MACRO_STRINGIFY(x)
+
 #ifdef __cplusplus
 }
 #endif

src/connection_pool.h

@@ -26,6 +26,7 @@
 #include "fast_mblock.h"
 #include "ini_file_reader.h"
 #include "pthread_func.h"
+#include "sockopt.h"
 #include "hash.h"
 
 #ifdef __cplusplus
@@ -40,16 +41,105 @@ extern "C" {
     (strcmp((conn1).ip_addr, (conn2).ip_addr) == 0 && \
      (conn1).port == (conn2).port)
 
-typedef struct
-{
-	int sock;
-	uint16_t port;
-    short socket_domain;  //socket domain, AF_INET, AF_INET6 or AF_UNSPEC for auto dedect
+typedef enum {
+    fc_comm_type_sock = 0,
+    fc_comm_type_rdma,
+    fc_comm_type_both
+} FCCommunicationType;
+
+typedef struct {
+    int sock;
+    uint16_t port;
+    uint8_t af;  //address family, AF_INET, AF_INET6 or AF_UNSPEC for auto dedect
+    bool shared; //for connection pool
+    FCCommunicationType comm_type;
     bool validate_flag;   //for connection pool
-	char ip_addr[INET6_ADDRSTRLEN];
+    char ip_addr[IP_ADDRESS_SIZE];
+    void *arg1;     //for RDMA
     char args[0];   //for extra data
 } ConnectionInfo;
 
+struct fc_server_config;
+struct ibv_pd;
+typedef void (*fc_set_busy_polling_callback)(const bool busy_polling);
+typedef struct ibv_pd *(*fc_alloc_pd_callback)(const char **ip_addrs,
+        const int count, const int port);
+typedef int (*fc_get_connection_size_callback)();
+typedef int (*fc_init_connection_callback)(ConnectionInfo *conn,
+        const bool double_buffers, const int buffer_size, void *arg);
+typedef int (*fc_make_connection_callback)(ConnectionInfo *conn,
+        const char *service_name, const int timeout_ms,
+        const char *bind_ipaddr, const bool log_connect_error);
+typedef bool (*fc_is_connected_callback)(ConnectionInfo *conn);
+typedef bool (*fc_send_done_callback)(ConnectionInfo *conn);
+typedef void (*fc_close_connection_callback)(ConnectionInfo *conn);
+typedef void (*fc_destroy_connection_callback)(ConnectionInfo *conn);
+
+typedef BufferInfo *(*fc_rdma_get_recv_buffer_callback)(ConnectionInfo *conn);
+typedef int (*fc_rdma_request_by_buf1_callback)(ConnectionInfo *conn,
+        const char *data, const int length, const int timeout_ms);
+typedef int (*fc_rdma_request_by_buf2_callback)(ConnectionInfo *conn,
+        const char *data1, const int length1, const char *data2,
+        const int length2, const int timeout_ms);
+typedef int (*fc_rdma_request_by_iov_callback)(ConnectionInfo *conn,
+        const struct iovec *iov, const int iovcnt,
+        const int timeout_ms);
+typedef int (*fc_rdma_request_by_mix_callback)(ConnectionInfo *conn,
+        const char *data, const int length, const struct iovec *iov,
+        const int iovcnt, const int timeout_ms);
+typedef int (*fc_rdma_send_by_buf1_callback)(ConnectionInfo *conn,
+        const char *data, const int length);
+typedef int (*fc_rdma_recv_data_callback)(ConnectionInfo *conn,
+        const bool call_post_recv, const int timeout_ms);
+typedef int (*fc_rdma_post_recv_callback)(ConnectionInfo *conn);
+
+typedef struct {
+    fc_make_connection_callback make_connection;
+    fc_close_connection_callback close_connection;
+    fc_is_connected_callback is_connected;
+} CommonConnectionCallbacks;
+
+typedef struct {
+    fc_set_busy_polling_callback set_busy_polling;
+    fc_alloc_pd_callback alloc_pd;
+    fc_get_connection_size_callback get_connection_size;
+    fc_init_connection_callback init_connection;
+    fc_make_connection_callback make_connection;
+    fc_close_connection_callback close_connection;
+    fc_destroy_connection_callback destroy_connection;
+    fc_is_connected_callback is_connected;
+    fc_send_done_callback send_done;
+
+    fc_rdma_get_recv_buffer_callback get_recv_buffer;
+    fc_rdma_request_by_buf1_callback request_by_buf1;
+    fc_rdma_request_by_buf2_callback request_by_buf2;
+    fc_rdma_request_by_iov_callback request_by_iov;
+    fc_rdma_request_by_mix_callback request_by_mix;
+
+    fc_rdma_send_by_buf1_callback send_by_buf1;
+    fc_rdma_recv_data_callback recv_data;
+    fc_rdma_post_recv_callback post_recv;
+} RDMAConnectionCallbacks;
+
+typedef struct {
+    bool inited;
+    CommonConnectionCallbacks common_callbacks[2];
+    RDMAConnectionCallbacks rdma_callbacks;
+} ConnectionCallbacks;
+
+typedef struct {
+    struct {
+        bool enabled;
+        int htable_capacity;
+    } tls;  //for thread local
+
+    struct {
+        bool double_buffers;
+        int buffer_size;
+        struct ibv_pd *pd;
+    } rdma;
+} ConnectionExtraParams;
+
 typedef int (*fc_connection_callback_func)(ConnectionInfo *conn, void *args);
 
 struct tagConnectionManager;
@@ -62,24 +152,39 @@ typedef struct tagConnectionNode {
 } ConnectionNode;
 
 typedef struct tagConnectionManager {
-	ConnectionNode *head;
-	int total_count;  //total connections
-	int free_count;   //free connections
-	pthread_mutex_t lock;
+    string_t key;
+    ConnectionNode *head;
+    int total_count;  //total connections
+    int free_count;   //free connections
+    struct tagConnectionManager *next;
 } ConnectionManager;
 
+typedef struct tagConnectionBucket {
+    ConnectionManager *head;
+    pthread_mutex_t lock;
+} ConnectionBucket;
+
+struct tagConnectionPool;
+
+typedef struct {
+    ConnectionNode **buckets;
+    struct tagConnectionPool *cp;
+} ConnectionThreadHashTable;
+
 typedef struct tagConnectionPool {
-	HashArray hash_array;  //key is ip:port, value is ConnectionManager
-	pthread_mutex_t lock;
-	int connect_timeout;
+    struct {
+        ConnectionBucket *buckets;
+        uint32_t capacity;
+    } hashtable;
+
+	int connect_timeout_ms;
 	int max_count_per_entry;  //0 means no limit
 
 	/*
-	connections whose the idle time exceeds this time will be closed
+	connections whose idle time exceeds this time will be closed
     unit: second
 	*/
 	int max_idle_time;
-    int socket_domain;  //socket domain
 
     struct fast_mblock_man manager_allocator;
     struct fast_mblock_man node_allocator;
@@ -93,8 +198,29 @@ typedef struct tagConnectionPool {
         fc_connection_callback_func func;
         void *args;
     } validate_callback;
+
+    int extra_data_size;
+    ConnectionExtraParams extra_params;
+    pthread_key_t tls_key;  //for ConnectionThreadHashTable
 } ConnectionPool;
 
+typedef struct {
+    int htable_capacity;
+    int bucket_used;
+    int server_count;
+    struct {
+        int total_count;
+        int free_count;
+    } connection;
+} ConnectionPoolStat;
+
+extern ConnectionCallbacks g_connection_callbacks;
+
+int conn_pool_global_init_for_rdma();
+
+#define G_COMMON_CONNECTION_CALLBACKS g_connection_callbacks.common_callbacks
+#define G_RDMA_CONNECTION_CALLBACKS   g_connection_callbacks.rdma_callbacks
+
 /**
 *   init ex function
 *   parameters:
@@ -102,21 +228,22 @@ typedef struct tagConnectionPool {
 *      connect_timeout: the connect timeout in seconds
 *      max_count_per_entry: max connection count per host:port
 *      max_idle_time: reconnect the server after max idle time in seconds
-*      socket_domain: the socket domain
-*      htable_init_capacity: the init capacity of connection hash table
+*      af: the socket domain
+*      htable_capacity: the capacity of connection hash table
 *      connect_done_func: the connect done connection callback
 *      connect_done_args: the args for connect done connection callback
 *      validate_func: the validate connection callback
 *      validate_args: the args for validate connection callback
 *      extra_data_size: the extra data size of connection
+*      extra_params: for RDMA
 *   return 0 for success, != 0 for error
 */
-int conn_pool_init_ex1(ConnectionPool *cp, int connect_timeout,
+int conn_pool_init_ex1(ConnectionPool *cp, const int connect_timeout,
 	const int max_count_per_entry, const int max_idle_time,
-    const int socket_domain, const int htable_init_capacity,
-    fc_connection_callback_func connect_done_func, void *connect_done_args,
-    fc_connection_callback_func validate_func, void *validate_args,
-    const int extra_data_size);
+    const int htable_capacity, fc_connection_callback_func connect_done_func,
+    void *connect_done_args, fc_connection_callback_func validate_func,
+    void *validate_args, const int extra_data_size,
+    const ConnectionExtraParams *extra_params);
 
 /**
 *   init ex function
@@ -125,18 +252,18 @@ int conn_pool_init_ex1(ConnectionPool *cp, int connect_timeout,
 *      connect_timeout: the connect timeout in seconds
 *      max_count_per_entry: max connection count per host:port
 *      max_idle_time: reconnect the server after max idle time in seconds
-*      socket_domain: the socket domain
 *   return 0 for success, != 0 for error
 */
-static inline int conn_pool_init_ex(ConnectionPool *cp, int connect_timeout,
-	const int max_count_per_entry, const int max_idle_time,
-    const int socket_domain)
+static inline int conn_pool_init_ex(ConnectionPool *cp,
+        const int connect_timeout, const int max_count_per_entry,
+        const int max_idle_time)
 {
-    const int htable_init_capacity = 0;
+    const int htable_capacity = 0;
     const int extra_data_size = 0;
+    const ConnectionExtraParams *extra_params = NULL;
     return conn_pool_init_ex1(cp, connect_timeout, max_count_per_entry,
-            max_idle_time, socket_domain, htable_init_capacity,
-            NULL, NULL, NULL, NULL, extra_data_size);
+            max_idle_time, htable_capacity, NULL, NULL, NULL, NULL,
+            extra_data_size, extra_params);
 }
 
 /**
@@ -148,15 +275,15 @@ static inline int conn_pool_init_ex(ConnectionPool *cp, int connect_timeout,
 *      max_idle_time: reconnect the server after max idle time in seconds
 *   return 0 for success, != 0 for error
 */
-static inline int conn_pool_init(ConnectionPool *cp, int connect_timeout,
+static inline int conn_pool_init(ConnectionPool *cp, const int connect_timeout,
 	const int max_count_per_entry, const int max_idle_time)
 {
-    const int socket_domain = AF_INET;
-    const int htable_init_capacity = 0;
+    const int htable_capacity = 0;
     const int extra_data_size = 0;
+    const ConnectionExtraParams *extra_params = NULL;
     return conn_pool_init_ex1(cp, connect_timeout, max_count_per_entry,
-            max_idle_time, socket_domain, htable_init_capacity,
-            NULL, NULL, NULL, NULL, extra_data_size);
+            max_idle_time, htable_capacity, NULL, NULL, NULL, NULL,
+            extra_data_size, extra_params);
 }
 
 /**
@@ -172,11 +299,17 @@ void conn_pool_destroy(ConnectionPool *cp);
 *   parameters:
 *      cp: the ConnectionPool
 *      conn: the connection
+*      service_name: the service name to log
+*      shared: if the connection shared
 *      err_no: return the the errno, 0 for success
 *   return != NULL for success, NULL for error
 */
-ConnectionInfo *conn_pool_get_connection(ConnectionPool *cp, 
-	const ConnectionInfo *conn, int *err_no);
+ConnectionInfo *conn_pool_get_connection_ex(ConnectionPool *cp,
+	const ConnectionInfo *conn, const char *service_name,
+    const bool shared, int *err_no);
+
+#define conn_pool_get_connection(cp, conn, err_no) \
+    conn_pool_get_connection_ex(cp, conn, NULL, false, err_no)
 
 #define conn_pool_close_connection(cp, conn) \
 	conn_pool_close_connection_ex(cp, conn, false)
@@ -189,61 +322,94 @@ ConnectionInfo *conn_pool_get_connection(ConnectionPool *cp,
 *      bForce: set true to close the socket, else only push back to connection pool
 *   return 0 for success, != 0 for error
 */
-int conn_pool_close_connection_ex(ConnectionPool *cp, ConnectionInfo *conn, 
-	const bool bForce);
+int conn_pool_close_connection_ex(ConnectionPool *cp,
+        ConnectionInfo *conn, const bool bForce);
 
 /**
 *   disconnect from the server
 *   parameters:
-*      pConnection: the connection
+*      conn: the connection
 *   return 0 for success, != 0 for error
 */
-void conn_pool_disconnect_server(ConnectionInfo *pConnection);
-
-/**
-*   connect to the server
-*   parameters:
-*      pConnection: the connection
-*      connect_timeout: the connect timeout in seconds
-*      bind_ipaddr: the ip address to bind, NULL or empty for any
-*      log_connect_error: if log error info when connect fail
-*   NOTE: pConnection->sock will be closed when it >= 0 before connect
-*   return 0 for success, != 0 for error
-*/
-int conn_pool_connect_server_ex(ConnectionInfo *pConnection,
-		const int connect_timeout, const char *bind_ipaddr,
-        const bool log_connect_error);
-
-/**
-*   connect to the server
-*   parameters:
-*      pConnection: the connection
-*      connect_timeout: the connect timeout in seconds
-*   NOTE: pConnection->sock will be closed when it >= 0 before connect
-*   return 0 for success, != 0 for error
-*/
-static inline int conn_pool_connect_server(ConnectionInfo *pConnection,
-		const int connect_timeout)
+static inline void conn_pool_disconnect_server(ConnectionInfo *conn)
 {
-    const char *bind_ipaddr = NULL;
-    return conn_pool_connect_server_ex(pConnection,
-            connect_timeout, bind_ipaddr, true);
+    if (conn->sock >= 0)
+    {
+        close(conn->sock);
+        conn->sock = -1;
+    }
+}
+
+static inline bool conn_pool_is_connected(ConnectionInfo *conn)
+{
+    return (conn->sock >= 0);
 }
 
 /**
 *   connect to the server
 *   parameters:
 *      pConnection: the connection
-*      connect_timeout: the connect timeout in seconds
+*      service_name: the service name to log
+*      connect_timeout_ms: the connect timeout in milliseconds
+*      bind_ipaddr: the ip address to bind, NULL or empty for any
+*      log_connect_error: if log error info when connect fail
+*   NOTE: pConnection->sock will be closed when it >= 0 before connect
+*   return 0 for success, != 0 for error
+*/
+int conn_pool_connect_server_ex1(ConnectionInfo *conn,
+        const char *service_name, const int connect_timeout_ms,
+        const char *bind_ipaddr, const bool log_connect_error);
+/**
+*   connect to the server
+*   parameters:
+*      pConnection: the connection
+*      connect_timeout_ms: the connect timeout in milliseconds
+*      bind_ipaddr: the ip address to bind, NULL or empty for any
+*      log_connect_error: if log error info when connect fail
+*   NOTE: pConnection->sock will be closed when it >= 0 before connect
+*   return 0 for success, != 0 for error
+*/
+static inline int conn_pool_connect_server_ex(ConnectionInfo *pConnection,
+		const int connect_timeout_ms, const char *bind_ipaddr,
+        const bool log_connect_error)
+{
+    const char *service_name = NULL;
+    return conn_pool_connect_server_ex1(pConnection, service_name,
+            connect_timeout_ms, bind_ipaddr, log_connect_error);
+}
+
+/**
+*   connect to the server
+*   parameters:
+*      pConnection: the connection
+*      connect_timeout_ms: the connect timeout in seconds
+*   NOTE: pConnection->sock will be closed when it >= 0 before connect
+*   return 0 for success, != 0 for error
+*/
+static inline int conn_pool_connect_server(ConnectionInfo *pConnection,
+		const int connect_timeout_ms)
+{
+    const char *service_name = NULL;
+    const char *bind_ipaddr = NULL;
+    return conn_pool_connect_server_ex1(pConnection, service_name,
+            connect_timeout_ms, bind_ipaddr, true);
+}
+
+/**
+*   connect to the server
+*   parameters:
+*      pConnection: the connection
+*      connect_timeout_ms: the connect timeout in seconds
 *   return 0 for success, != 0 for error
 */
 static inline int conn_pool_connect_server_anyway(ConnectionInfo *pConnection,
-		const int connect_timeout)
+		const int connect_timeout_ms)
 {
+    const char *service_name = NULL;
     const char *bind_ipaddr = NULL;
     pConnection->sock = -1;
-    return conn_pool_connect_server_ex(pConnection,
-            connect_timeout, bind_ipaddr, true);
+    return conn_pool_connect_server_ex1(pConnection, service_name,
+            connect_timeout_ms, bind_ipaddr, true);
 }
 
 /**
@@ -262,12 +428,13 @@ int conn_pool_async_connect_server_ex(ConnectionInfo *conn,
 
 
 /**
-*   get connection count of the pool
+*   connection pool stat
 *   parameters:
 *      cp: the ConnectionPool
-*   return current connection count
+*      stat: the output stat
+*   return none
 */
-int conn_pool_get_connection_count(ConnectionPool *cp);
+void conn_pool_stat(ConnectionPool *cp, ConnectionPoolStat *stat);
 
 /**
 *   load server info from config file
@@ -305,10 +472,9 @@ int conn_pool_parse_server_info(const char *pServerStr,
 static inline void conn_pool_set_server_info(ConnectionInfo *pServerInfo,
         const char *ip_addr, const int port)
 {
-    snprintf(pServerInfo->ip_addr, sizeof(pServerInfo->ip_addr),
-            "%s", ip_addr);
+    fc_safe_strcpy(pServerInfo->ip_addr, ip_addr);
     pServerInfo->port = port;
-    pServerInfo->socket_domain = AF_UNSPEC;
+    pServerInfo->af = is_ipv6_addr(ip_addr) ? AF_INET6 : AF_INET;
     pServerInfo->sock = -1;
 }
 
@@ -322,6 +488,55 @@ static inline int conn_pool_compare_ip_and_port(const char *ip1,
     return port1 - port2;
 }
 
+ConnectionInfo *conn_pool_alloc_connection_ex(
+        const FCCommunicationType comm_type,
+        const int extra_data_size,
+        const ConnectionExtraParams *extra_params,
+        int *err_no);
+
+static inline ConnectionInfo *conn_pool_alloc_connection(
+        const FCCommunicationType comm_type,
+        const ConnectionExtraParams *extra_params,
+        int *err_no)
+{
+    const int extra_data_size = 0;
+    return conn_pool_alloc_connection_ex(comm_type,
+            extra_data_size, extra_params, err_no);
+}
+
+static inline void conn_pool_free_connection(ConnectionInfo *conn)
+{
+    free(conn);
+}
+
+int conn_pool_set_rdma_extra_params_ex(ConnectionExtraParams *extra_params,
+        struct fc_server_config *server_cfg, const int server_group_index,
+        const bool double_buffers);
+
+static inline int conn_pool_set_rdma_extra_params(
+        ConnectionExtraParams *extra_params,
+        struct fc_server_config *server_cfg,
+        const int server_group_index)
+{
+    const bool double_buffers = false;
+    return conn_pool_set_rdma_extra_params_ex(extra_params,
+            server_cfg, server_group_index, double_buffers);
+}
+
+static inline const char *fc_comm_type_str(const FCCommunicationType type)
+{
+    switch (type) {
+        case fc_comm_type_sock:
+            return "socket";
+        case fc_comm_type_rdma:
+            return "rdma";
+        case fc_comm_type_both:
+            return "both";
+        default:
+            return "unkown";
+    }
+}
+
 #ifdef __cplusplus
 }
 #endif

src/fast_allocator.c

@@ -25,14 +25,6 @@
 
 #define BYTES_ALIGN(x, pad_mask)  (((x) + pad_mask) & (~pad_mask))
 
-struct allocator_wrapper {
-	int alloc_bytes;
-	short allocator_index;
-	short magic_number;
-};
-
-static struct fast_allocator_info malloc_allocator;
-
 #define ADD_ALLOCATOR_TO_ARRAY(acontext, allocator, _pooled) \
 	do { \
 		(allocator)->index = acontext->allocator_array.count; \
@@ -63,17 +55,19 @@ static int fast_allocator_malloc_trunk_check(const int alloc_bytes, void *args)
 		acontext->allocator_array.malloc_bytes_limit ? 0 : EOVERFLOW;
 }
 
-static void fast_allocator_malloc_trunk_notify_func(const int alloc_bytes, void *args)
+static void fast_allocator_malloc_trunk_notify_func(
+        const enum fast_mblock_notify_type type,
+        const struct fast_mblock_malloc *node, void *args)
 {
-	if (alloc_bytes > 0)
+	if (type == fast_mblock_notify_type_alloc)
 	{
 		__sync_add_and_fetch(&((struct fast_allocator_context *)args)->
-			allocator_array.malloc_bytes, alloc_bytes);
+			allocator_array.malloc_bytes, node->trunk_size);
 	}
 	else
 	{
 		__sync_sub_and_fetch(&((struct fast_allocator_context *)args)->
-			allocator_array.malloc_bytes, -1 * alloc_bytes);
+			allocator_array.malloc_bytes, node->trunk_size);
 	}
 }
 
@@ -142,20 +136,22 @@ static int allocator_array_check_capacity(struct fast_allocator_context *acontex
 }
 
 static int region_init(struct fast_allocator_context *acontext,
-        const char *mblock_name_prefix, struct fast_region_info *region)
+        const char *mblock_name_prefix, struct fast_mblock_object_callbacks
+        *object_callbacks, struct fast_region_info *region)
 {
     const int64_t alloc_elements_limit = 0;
+    const int prealloc_trunk_count = 0;
 	int result;
 	int bytes;
 	int element_size;
-	int allocator_count;
+    struct fast_mblock_trunk_callbacks trunk_callbacks;
 	struct fast_allocator_info *allocator;
     char *name;
     char name_buff[FAST_MBLOCK_NAME_SIZE];
 
 	region->pad_mask = region->step - 1;
-	allocator_count = (region->end - region->start) / region->step;
-	bytes = sizeof(struct fast_allocator_info) * allocator_count;
+	region->count = (region->end - region->start) / region->step;
+	bytes = sizeof(struct fast_allocator_info) * region->count;
 	region->allocators = (struct fast_allocator_info *)fc_malloc(bytes);
 	if (region->allocators == NULL)
 	{
@@ -163,17 +159,29 @@ static int region_init(struct fast_allocator_context *acontext,
 	}
 	memset(region->allocators, 0, bytes);
 
-	if ((result=allocator_array_check_capacity(acontext, allocator_count)) != 0)
+	if ((result=allocator_array_check_capacity(acontext, region->count)) != 0)
 	{
 		return result;
 	}
 
+    if (region->count == 1) {
+        if (region->start == 0) {
+            region->step += acontext->extra_size;
+        } else {
+            region->start += acontext->extra_size;
+        }
+        region->end += acontext->extra_size;
+    }
+
+    trunk_callbacks.check_func = fast_allocator_malloc_trunk_check;
+    trunk_callbacks.notify_func = fast_allocator_malloc_trunk_notify_func;
     name = name_buff;
 	result = 0;
  	allocator = region->allocators;
-	for (element_size=region->start+region->step; element_size<=region->end;
-		element_size+=region->step,allocator++)
-	{
+	for (element_size = region->start + region->step;
+         element_size <= region->end;
+         element_size += region->step, allocator++)
+    {
         if (mblock_name_prefix != NULL)
         {
             snprintf(name, FAST_MBLOCK_NAME_SIZE, "%s-%d",
@@ -183,10 +191,12 @@ static int region_init(struct fast_allocator_context *acontext,
         {
             name = NULL;
         }
+
+        trunk_callbacks.args = acontext;
 		result = fast_mblock_init_ex2(&allocator->mblock, name, element_size,
-			region->alloc_elements_once, alloc_elements_limit, NULL, NULL,
-            acontext->need_lock, fast_allocator_malloc_trunk_check,
-			fast_allocator_malloc_trunk_notify_func, acontext);
+                region->alloc_elements_once, alloc_elements_limit,
+                prealloc_trunk_count, object_callbacks,
+                acontext->need_lock, &trunk_callbacks);
 		if (result != 0)
 		{
 			break;
@@ -216,10 +226,11 @@ static void region_destroy(struct fast_allocator_context *acontext,
 }
 
 int fast_allocator_init_ex(struct fast_allocator_context *acontext,
-        const char *mblock_name_prefix, struct fast_region_info *regions,
-        const int region_count, const int64_t alloc_bytes_limit,
-        const double expect_usage_ratio, const int reclaim_interval,
-        const bool need_lock)
+        const char *mblock_name_prefix, const int obj_size,
+        struct fast_mblock_object_callbacks *object_callbacks,
+        struct fast_region_info *regions, const int region_count,
+        const int64_t alloc_bytes_limit, const double expect_usage_ratio,
+        const int reclaim_interval, const bool need_lock)
 {
 	int result;
 	int bytes;
@@ -254,6 +265,7 @@ int fast_allocator_init_ex(struct fast_allocator_context *acontext,
 	acontext->allocator_array.malloc_bytes_limit = alloc_bytes_limit /
 		acontext->allocator_array.expect_usage_ratio;
 	acontext->allocator_array.reclaim_interval = reclaim_interval;
+	acontext->extra_size = sizeof(struct fast_allocator_wrapper) + obj_size;
 	acontext->need_lock = need_lock;
 	result = 0;
 	previous_end = 0;
@@ -276,33 +288,46 @@ int fast_allocator_init_ex(struct fast_allocator_context *acontext,
 			result = EINVAL;
 			break;
 		}
-		if (pRegion->step <= 0 || !is_power2(pRegion->step))
+		if (pRegion->step <= 0)
 		{
 			logError("file: "__FILE__", line: %d, "
-				"invalid step: %d",
+				"invalid step: %d <= 0",
 				__LINE__, pRegion->step);
 			result = EINVAL;
 			break;
 		}
-		if (pRegion->start % pRegion->step != 0)
-		{
-			logError("file: "__FILE__", line: %d, "
-				"invalid start: %d, must multiple of step: %d",
-				__LINE__, pRegion->start, pRegion->step);
-			result = EINVAL;
-			break;
-		}
-		if (pRegion->end % pRegion->step != 0)
-		{
-			logError("file: "__FILE__", line: %d, "
-				"invalid end: %d, must multiple of step: %d",
-				__LINE__, pRegion->end, pRegion->step);
-			result = EINVAL;
-			break;
-		}
+
+        if ((pRegion->end - pRegion->start) / pRegion->step > 1)
+        {
+            if (!is_power2(pRegion->step))
+            {
+                logError("file: "__FILE__", line: %d, "
+                        "invalid step: %d, expect power of 2",
+                        __LINE__, pRegion->step);
+                result = EINVAL;
+                break;
+            }
+            if (pRegion->start % pRegion->step != 0)
+            {
+                logError("file: "__FILE__", line: %d, "
+                        "invalid start: %d, must multiple of step: %d",
+                        __LINE__, pRegion->start, pRegion->step);
+                result = EINVAL;
+                break;
+            }
+            if (pRegion->end % pRegion->step != 0)
+            {
+                logError("file: "__FILE__", line: %d, "
+                        "invalid end: %d, must multiple of step: %d",
+                        __LINE__, pRegion->end, pRegion->step);
+                result = EINVAL;
+                break;
+            }
+        }
 		previous_end = pRegion->end;
 
-		if ((result=region_init(acontext, mblock_name_prefix, pRegion)) != 0)
+		if ((result=region_init(acontext, mblock_name_prefix,
+                        object_callbacks, pRegion)) != 0)
 		{
 			break;
 		}
@@ -318,10 +343,12 @@ int fast_allocator_init_ex(struct fast_allocator_context *acontext,
 		return result;
 	}
 
-	ADD_ALLOCATOR_TO_ARRAY(acontext, &malloc_allocator, false);
+	ADD_ALLOCATOR_TO_ARRAY(acontext, &acontext->
+            allocator_array.malloc_allocator, false);
+
 	/*
-	logInfo("sizeof(struct allocator_wrapper): %d, allocator_array count: %d",
-		(int)sizeof(struct allocator_wrapper), acontext->allocator_array.count);
+	logInfo("sizeof(struct fast_allocator_wrapper): %d, allocator_array count: %d",
+		(int)sizeof(struct fast_allocator_wrapper), acontext->allocator_array.count);
 	*/
 	return result;
 }
@@ -333,6 +360,7 @@ int fast_allocator_init(struct fast_allocator_context *acontext,
 {
 #define DEFAULT_REGION_COUNT 5
 
+    const int obj_size = 0;
     struct fast_region_info regions[DEFAULT_REGION_COUNT];
 
     FAST_ALLOCATOR_INIT_REGION(regions[0],     0,   256,    8, 4096);
@@ -341,9 +369,9 @@ int fast_allocator_init(struct fast_allocator_context *acontext,
     FAST_ALLOCATOR_INIT_REGION(regions[3],  4096, 16384,  256,   64);
     FAST_ALLOCATOR_INIT_REGION(regions[4], 16384, 65536, 1024,   16);
 
-    return fast_allocator_init_ex(acontext, mblock_name_prefix, regions,
-            DEFAULT_REGION_COUNT, alloc_bytes_limit, expect_usage_ratio,
-            reclaim_interval, need_lock);
+    return fast_allocator_init_ex(acontext, mblock_name_prefix, obj_size,
+            NULL, regions, DEFAULT_REGION_COUNT, alloc_bytes_limit,
+            expect_usage_ratio, reclaim_interval, need_lock);
 }
 
 void fast_allocator_destroy(struct fast_allocator_context *acontext)
@@ -368,8 +396,8 @@ void fast_allocator_destroy(struct fast_allocator_context *acontext)
 	memset(acontext, 0, sizeof(*acontext));
 }
 
-static struct fast_allocator_info *get_allocator(struct fast_allocator_context *acontext,
-	int *alloc_bytes)
+static struct fast_allocator_info *get_allocator(struct fast_allocator_context
+        *acontext, int *alloc_bytes)
 {
 	struct fast_region_info *pRegion;
 	struct fast_region_info *region_end;
@@ -378,14 +406,19 @@ static struct fast_allocator_info *get_allocator(struct fast_allocator_context *
 	for (pRegion=acontext->regions; pRegion<region_end; pRegion++)
 	{
 		if (*alloc_bytes <= pRegion->end)
-		{
-			*alloc_bytes = BYTES_ALIGN(*alloc_bytes, pRegion->pad_mask);
-			return pRegion->allocators + ((*alloc_bytes -
-				pRegion->start) / pRegion->step) - 1;
-		}
+        {
+            if (pRegion->count == 1) {
+                *alloc_bytes = pRegion->allocators[0].mblock.info.element_size;
+                return pRegion->allocators + 0;
+            } else {
+                *alloc_bytes = BYTES_ALIGN(*alloc_bytes, pRegion->pad_mask);
+                return pRegion->allocators + ((*alloc_bytes -
+                            pRegion->start) / pRegion->step) - 1;
+            }
+        }
 	}
 
-	return &malloc_allocator;
+	return &acontext->allocator_array.malloc_allocator;
 }
 
 int fast_allocator_retry_reclaim(struct fast_allocator_context *acontext,
@@ -415,7 +448,7 @@ int fast_allocator_retry_reclaim(struct fast_allocator_context *acontext,
 		return EAGAIN;
 	}
 
-	for (i=0; i< acontext->allocator_array.count; i++)
+	for (i=0; i<acontext->allocator_array.count; i++)
 	{
 		if (fast_mblock_reclaim(&acontext->allocator_array.
 			allocators[i]->mblock, 0, &reclaim_count, NULL) == 0)
@@ -430,6 +463,15 @@ int fast_allocator_retry_reclaim(struct fast_allocator_context *acontext,
 	return *total_reclaim_bytes > 0 ? 0 : EAGAIN;
 }
 
+static inline void malloc_trunk_notify(
+        const enum fast_mblock_notify_type type,
+        const int alloc_bytes, void *args)
+{
+    struct fast_mblock_malloc node;
+    node.trunk_size = alloc_bytes;
+    fast_allocator_malloc_trunk_notify_func(type, &node, args);
+}
+
 void *fast_allocator_alloc(struct fast_allocator_context *acontext,
 	const int bytes)
 {
@@ -437,20 +479,21 @@ void *fast_allocator_alloc(struct fast_allocator_context *acontext,
 	int64_t total_reclaim_bytes;
 	struct fast_allocator_info *allocator_info;
 	void *ptr;
+	void *obj;
 
 	if (bytes < 0)
 	{
 		return NULL;
 	}
 
-	alloc_bytes = sizeof(struct allocator_wrapper) + bytes;
+	alloc_bytes = acontext->extra_size + bytes;
 	allocator_info = get_allocator(acontext, &alloc_bytes);
 	if (allocator_info->pooled)
 	{
 		ptr = fast_mblock_alloc_object(&allocator_info->mblock);
 		if (ptr == NULL)
 		{
-			if (acontext->allocator_array.reclaim_interval <= 0)
+			if (acontext->allocator_array.reclaim_interval < 0)
 			{
 				return NULL;
 			}
@@ -469,6 +512,7 @@ void *fast_allocator_alloc(struct fast_allocator_context *acontext,
 				return NULL;
 			}
 		}
+        obj = (char *)ptr + sizeof(struct fast_allocator_wrapper);
 	}
 	else
 	{
@@ -481,29 +525,42 @@ void *fast_allocator_alloc(struct fast_allocator_context *acontext,
 		{
 			return NULL;
 		}
-		fast_allocator_malloc_trunk_notify_func(alloc_bytes, acontext);
+		malloc_trunk_notify(fast_mblock_notify_type_alloc,
+                alloc_bytes, acontext);
+
+        obj = (char *)ptr + sizeof(struct fast_allocator_wrapper);
+        if (acontext->allocator_array.allocators[0]->mblock.
+                object_callbacks.init_func != NULL)
+        {
+            struct fast_mblock_man *mblock;
+            mblock = &acontext->allocator_array.allocators[0]->mblock;
+            mblock->object_callbacks.init_func(obj,
+                    mblock->object_callbacks.args);
+        }
 	}
 
-	((struct allocator_wrapper *)ptr)->allocator_index = allocator_info->index;
-	((struct allocator_wrapper *)ptr)->magic_number = allocator_info->magic_number;
-	((struct allocator_wrapper *)ptr)->alloc_bytes = alloc_bytes;
-
+	((struct fast_allocator_wrapper *)ptr)->allocator_index =
+        allocator_info->index;
+	((struct fast_allocator_wrapper *)ptr)->magic_number =
+        allocator_info->magic_number;
+	((struct fast_allocator_wrapper *)ptr)->alloc_bytes = alloc_bytes;
 	__sync_add_and_fetch(&acontext->alloc_bytes, alloc_bytes);
-	return (char *)ptr + sizeof(struct allocator_wrapper);
+	return obj;
 }
 
-void fast_allocator_free(struct fast_allocator_context *acontext, void *ptr)
+void fast_allocator_free(struct fast_allocator_context *acontext, void *obj)
 {
-	struct allocator_wrapper *pWrapper;
+	struct fast_allocator_wrapper *pWrapper;
 	struct fast_allocator_info *allocator_info;
-	void *obj;
-	if (ptr == NULL)
+	void *ptr;
+
+	if (obj == NULL)
 	{
 		return;
 	}
 
-	obj = (char *)ptr - sizeof(struct allocator_wrapper);
-	pWrapper = (struct allocator_wrapper *)obj;
+	ptr = (char *)obj - sizeof(struct fast_allocator_wrapper);
+	pWrapper = (struct fast_allocator_wrapper *)ptr;
 	if (pWrapper->allocator_index < 0 || pWrapper->allocator_index >=
 		acontext->allocator_array.count)
 	{
@@ -513,7 +570,8 @@ void fast_allocator_free(struct fast_allocator_context *acontext, void *ptr)
 		return;
 	}
 
-	allocator_info = acontext->allocator_array.allocators[pWrapper->allocator_index];
+	allocator_info = acontext->allocator_array.
+        allocators[pWrapper->allocator_index];
 	if (pWrapper->magic_number != allocator_info->magic_number)
 	{
 		logError("file: "__FILE__", line: %d, "
@@ -528,13 +586,23 @@ void fast_allocator_free(struct fast_allocator_context *acontext, void *ptr)
 	pWrapper->magic_number = 0;
 	if (allocator_info->pooled)
 	{
-		fast_mblock_free_object(&allocator_info->mblock, obj);
+		fast_mblock_free_object(&allocator_info->mblock, ptr);
 	}
 	else
-	{
-		fast_allocator_malloc_trunk_notify_func(-1 * pWrapper->alloc_bytes, acontext);
-		free(obj);
-	}
+    {
+        malloc_trunk_notify(fast_mblock_notify_type_reclaim,
+                pWrapper->alloc_bytes, acontext);
+
+        if (acontext->allocator_array.allocators[0]->mblock.
+                object_callbacks.destroy_func != NULL)
+        {
+            struct fast_mblock_man *mblock;
+            mblock = &acontext->allocator_array.allocators[0]->mblock;
+            mblock->object_callbacks.destroy_func(obj,
+                    mblock->object_callbacks.args);
+        }
+        free(ptr);
+    }
 }
 
 char *fast_allocator_memdup(struct fast_allocator_context *acontext,

src/fast_allocator.h

@@ -40,39 +40,48 @@ struct fast_region_info
 	int step;
 	int alloc_elements_once;
 	int pad_mask;  //for internal use
+    int count;
 	struct fast_allocator_info *allocators;
 };
 
 struct fast_allocator_array
 {
-	int count;
-	int alloc;
-	int reclaim_interval;   //<= 0 for never reclaim
-	int last_reclaim_time;
-	volatile int64_t malloc_bytes;   //total alloc bytes
-	int64_t malloc_bytes_limit;       //water mark bytes for malloc
-	double expect_usage_ratio;
-	struct fast_allocator_info **allocators;
+    int count;
+    int alloc;
+    int reclaim_interval;   //< 0 for never reclaim
+    int last_reclaim_time;
+    volatile int64_t malloc_bytes;   //total alloc bytes
+    int64_t malloc_bytes_limit;      //water mark bytes for malloc
+    double expect_usage_ratio;
+    struct fast_allocator_info malloc_allocator;
+    struct fast_allocator_info **allocators;
+};
+
+struct fast_allocator_wrapper {
+	int alloc_bytes;
+	short allocator_index;
+	short magic_number;
 };
 
 struct fast_allocator_context
 {
 	struct fast_region_info *regions;
 	int region_count;
+    int extra_size;
 
 	struct fast_allocator_array allocator_array;
 
-	int64_t alloc_bytes_limit;       //mater mark bytes for alloc
+	int64_t alloc_bytes_limit;       //water mark bytes for alloc
 	volatile int64_t alloc_bytes;    //total alloc bytes
 	bool need_lock;     //if need mutex lock for acontext
 };
 
 #define FAST_ALLOCATOR_INIT_REGION(region, _start, _end, _step, _alloc_once) \
 	do { \
-		region.start = _start; \
-		region.end = _end;     \
-		region.step = _step;   \
-		region.alloc_elements_once = _alloc_once;   \
+		(region).start = _start; \
+		(region).end = _end;     \
+		(region).step = _step;   \
+		(region).alloc_elements_once = _alloc_once;   \
 	} while(0)
 
 #ifdef __cplusplus
@@ -86,7 +95,7 @@ parameters:
     mblock_name_prefix: the name prefix of mblock
     alloc_bytes_limit: the alloc limit, 0 for no limit
 	expect_usage_ratio: the trunk usage ratio
-	reclaim_interval: reclaim interval in second, 0 for never reclaim
+	reclaim_interval: reclaim interval in second, < 0 for never reclaim
 	need_lock: if need lock
 return error no, 0 for success, != 0 fail
 */
@@ -99,19 +108,23 @@ int fast_allocator_init(struct fast_allocator_context *acontext,
 allocator init
 parameters:
 	acontext: the context pointer
+    mblock_name_prefix: name prefix of object alloctors
+    obj_size: element size of object as sizeof(obj)
+    object_callbacks: object init and destroy callbacks
 	regions: the region array
 	region_count: the region count
-        alloc_bytes_limit: the alloc limit, 0 for no limit
+    alloc_bytes_limit: the alloc limit, 0 for no limit
 	expect_usage_ratio: the trunk usage ratio
-	reclaim_interval: reclaim interval in second, 0 for never reclaim
+	reclaim_interval: reclaim interval in second, < 0 for never reclaim
 	need_lock: if need lock
 return error no, 0 for success, != 0 fail
 */
 int fast_allocator_init_ex(struct fast_allocator_context *acontext,
-        const char *mblock_name_prefix, struct fast_region_info *regions,
-        const int region_count, const int64_t alloc_bytes_limit,
-        const double expect_usage_ratio, const int reclaim_interval,
-        const bool need_lock);
+        const char *mblock_name_prefix, const int obj_size,
+        struct fast_mblock_object_callbacks *object_callbacks,
+        struct fast_region_info *regions, const int region_count,
+        const int64_t alloc_bytes_limit, const double expect_usage_ratio,
+        const int reclaim_interval, const bool need_lock);
 
 /**
 allocator destroy
@@ -134,10 +147,10 @@ void* fast_allocator_alloc(struct fast_allocator_context *acontext,
 free a node (put a node to the context)
 parameters:
 	acontext: the context pointer
-	ptr: the pointer to free
+	obj: the object ptr to free
 return none
 */
-void fast_allocator_free(struct fast_allocator_context *acontext, void *ptr);
+void fast_allocator_free(struct fast_allocator_context *acontext, void *obj);
 
 /**
 retry reclaim free trunks
@@ -178,9 +191,19 @@ static inline int fast_allocator_alloc_string(struct fast_allocator_context
     return fast_allocator_alloc_string_ex(acontext, dest, src->str, src->len);
 }
 
+static inline int64_t fast_allocator_avail_memory(
+        struct fast_allocator_context *acontext)
+{
+    if (acontext->alloc_bytes_limit == 0) {
+        return INT64_MIN;
+    }
+
+    return acontext->alloc_bytes_limit - __sync_add_and_fetch(
+            &acontext->allocator_array.malloc_bytes, 0);
+}
+
 #ifdef __cplusplus
 }
 #endif
 
 #endif
-

src/fast_buffer.c

@@ -26,23 +26,28 @@
 #include "fc_memory.h"
 #include "fast_buffer.h"
 
-int fast_buffer_init_ex(FastBuffer *buffer, const int init_capacity)
+int fast_buffer_init_ex(FastBuffer *buffer, const int init_capacity,
+        const bool binary_mode, const bool check_capacity)
 {
     buffer->length = 0;
+    buffer->binary_mode = binary_mode;
     if (init_capacity > 0)
     {
         buffer->alloc_size = init_capacity;
+        buffer->check_capacity = check_capacity;
     }
     else
     {
         buffer->alloc_size = 256;
+        buffer->check_capacity = true;
     }
     buffer->data = (char *)fc_malloc(buffer->alloc_size);
     if (buffer->data == NULL)
     {
         return ENOMEM;
     }
-    *(buffer->data) = '\0';
+
+    fast_buffer_set_null_terminator(buffer);
     return 0;
 }
 
@@ -62,8 +67,7 @@ int fast_buffer_set_capacity(FastBuffer *buffer, const int capacity)
     int new_capacity;
     char *buff;
 
-    new_capacity = (capacity > buffer->length) ?
-        capacity : (buffer->length + 1);
+    new_capacity = FC_MAX(capacity, buffer->length + 1);
     if (buffer->alloc_size >= new_capacity) {
         if (new_capacity > 1024) {
             alloc_size = 2048;
@@ -89,7 +93,9 @@ int fast_buffer_set_capacity(FastBuffer *buffer, const int capacity)
 
     if (buffer->length > 0) {
         memcpy(buff, buffer->data, buffer->length);
-        *(buff + buffer->length) = '\0';
+        if (!buffer->binary_mode) {
+            *(buff + buffer->length) = '\0';
+        }
     }
 
     free(buffer->data);
@@ -128,7 +134,7 @@ int fast_buffer_append(FastBuffer *buffer, const char *format, ...)
         }
         else
         {
-            *(buffer->data + buffer->length) = '\0';  //restore
+            fast_buffer_set_null_terminator(buffer);  //restore
         }
     }
     return result;
@@ -149,33 +155,26 @@ int fast_buffer_append_buff(FastBuffer *buffer, const char *data, const int len)
 
     memcpy(buffer->data + buffer->length, data, len);
     buffer->length += len;
-    *(buffer->data + buffer->length) = '\0';
+    fast_buffer_set_null_terminator(buffer);
     return 0;
 }
 
-int fast_buffer_append_int(FastBuffer *buffer, const int n)
+int fast_buffer_append_binary(FastBuffer *buffer,
+        const void *data, const int len)
 {
     int result;
 
-    if ((result=fast_buffer_check(buffer, 16)) != 0)
+    if (len <= 0)
+    {
+        return 0;
+    }
+    if ((result=fast_buffer_check(buffer, len)) != 0)
     {
         return result;
     }
 
-    buffer->length += sprintf(buffer->data + buffer->length, "%d", n);
-    return 0;
-}
-
-int fast_buffer_append_int64(FastBuffer *buffer, const int64_t n)
-{
-    int result;
-
-    if ((result=fast_buffer_check(buffer, 32)) != 0)
-    {
-        return result;
-    }
-
-    buffer->length += sprintf(buffer->data + buffer->length, "%"PRId64, n);
+    memcpy(buffer->data + buffer->length, data, len);
+    buffer->length += len;
     return 0;
 }
 

src/fast_buffer.h

@@ -17,12 +17,14 @@
 #define __FAST_BUFFER_H__
 
 #include <stdint.h>
-#include "common_define.h"
+#include "shared_func.h"
 
 typedef struct fast_buffer {
-	char *data;
-	int alloc_size;
-	int length;
+    char *data;
+    int alloc_size;
+    int length;
+    bool binary_mode;
+    bool check_capacity;
 } FastBuffer;
 
 #ifdef __cplusplus
@@ -39,26 +41,39 @@ static inline char *fast_buffer_data(FastBuffer *buffer)
     return buffer->data;
 }
 
-int fast_buffer_init_ex(FastBuffer *buffer, const int init_capacity);
+int fast_buffer_init_ex(FastBuffer *buffer, const int init_capacity,
+        const bool binary_mode, const bool check_capacity);
+
+static inline int fast_buffer_init1(FastBuffer *buffer, const int init_capacity)
+{
+    const bool binary_mode = false;
+    const bool check_capacity = true;
+    return fast_buffer_init_ex(buffer, init_capacity,
+            binary_mode, check_capacity);
+}
 
 static inline int fast_buffer_init(FastBuffer *buffer)
 {
-    return fast_buffer_init_ex(buffer, 0);
+    const int init_capacity = 0;
+    return fast_buffer_init1(buffer, init_capacity);
 }
 
+#define fast_buffer_set_null_terminator(buffer)  \
+    if (!buffer->binary_mode) *(buffer->data + buffer->length) = '\0'
+
+#define fast_buffer_check(buffer, inc_len)   \
+    ((buffer)->check_capacity ? fast_buffer_check_inc_size(buffer, inc_len) : 0)
+
 #define fast_buffer_clear(buffer) fast_buffer_reset(buffer)
 
 static inline void fast_buffer_reset(FastBuffer *buffer)
 {
     buffer->length = 0;
-    *buffer->data = '\0';
+    fast_buffer_set_null_terminator(buffer);
 }
 
 void fast_buffer_destroy(FastBuffer *buffer);
 
-#define fast_buffer_check(buffer, inc_len) \
-    fast_buffer_check_inc_size(buffer, inc_len)
-
 int fast_buffer_set_capacity(FastBuffer *buffer, const int capacity);
 
 static inline int fast_buffer_check_capacity(FastBuffer *buffer,
@@ -80,11 +95,56 @@ static inline int fast_buffer_check_inc_size(FastBuffer *buffer,
 
 int fast_buffer_append(FastBuffer *buffer, const char *format, ...);
 
-int fast_buffer_append_buff(FastBuffer *buffer, const char *data, const int len);
+int fast_buffer_append_buff(FastBuffer *buffer,
+        const char *data, const int len);
 
-int fast_buffer_append_int(FastBuffer *buffer, const int n);
+int fast_buffer_append_binary(FastBuffer *buffer,
+        const void *data, const int len);
 
-int fast_buffer_append_int64(FastBuffer *buffer, const int64_t n);
+static inline int fast_buffer_append_char(FastBuffer *buffer, const char ch)
+{
+    int result;
+
+    if ((result=fast_buffer_check(buffer, 1)) != 0)
+    {
+        return result;
+    }
+
+    *(buffer->data + buffer->length++) = ch;
+    fast_buffer_set_null_terminator(buffer);
+    return 0;
+}
+
+static inline int fast_buffer_append_int32(FastBuffer *buffer, const int n)
+{
+    int result;
+
+    if ((result=fast_buffer_check(buffer, 16)) != 0)
+    {
+        return result;
+    }
+
+    buffer->length += fc_itoa(n, buffer->data + buffer->length);
+    fast_buffer_set_null_terminator(buffer);
+    return 0;
+}
+
+static inline int fast_buffer_append_int64(FastBuffer *buffer, const int64_t n)
+{
+    int result;
+
+    if ((result=fast_buffer_check(buffer, 32)) != 0)
+    {
+        return result;
+    }
+
+    buffer->length += fc_itoa(n, buffer->data + buffer->length);
+    fast_buffer_set_null_terminator(buffer);
+    return 0;
+}
+
+#define fast_buffer_append_int(buffer, n)  \
+    fast_buffer_append_int64(buffer, n)
 
 int fast_buffer_append_file(FastBuffer *buffer, const char *filename);
 

src/fast_mblock.h

@@ -24,13 +24,25 @@
 #include <pthread.h>
 #include "common_define.h"
 #include "fc_memory.h"
-#include "chain.h"
 #include "logger.h"
 
+/* following two macros for debug only */
+/*
+#define FAST_MBLOCK_MAGIC_CHECK    1
+#define FAST_MBLOCK_MAGIC_NUMBER   1234567890
+*/
+
+
 #define FAST_MBLOCK_NAME_SIZE 32
 
 #define FAST_MBLOCK_ORDER_BY_ALLOC_BYTES    1
 #define FAST_MBLOCK_ORDER_BY_ELEMENT_SIZE   2
+#define FAST_MBLOCK_ORDER_BY_USED_RATIO     3
+
+enum fast_mblock_notify_type {
+    fast_mblock_notify_type_alloc,
+    fast_mblock_notify_type_reclaim,
+};
 
 /* free node chain */ 
 struct fast_mblock_node
@@ -38,6 +50,10 @@ struct fast_mblock_node
     struct fast_mblock_node *next;
     int offset;    //trunk offset
     int recycle_timestamp;
+#ifdef FAST_MBLOCK_MAGIC_CHECK
+    int index;
+    int magic;   //magic number
+#endif
     char data[0];   //the data buffer
 };
 
@@ -56,13 +72,18 @@ struct fast_mblock_chain {
 	struct fast_mblock_node *tail;
 };
 
-typedef int (*fast_mblock_alloc_init_func)(void *element, void *args);
+/* call by alloc trunk */
+typedef int (*fast_mblock_object_init_func)(void *element, void *args);
+
+/* call by free trunk */
+typedef void (*fast_mblock_object_destroy_func)(void *element, void *args);
 
 typedef int (*fast_mblock_malloc_trunk_check_func)(
 	const int alloc_bytes, void *args);
 
 typedef void (*fast_mblock_malloc_trunk_notify_func)(
-	const int alloc_bytes, void *args);
+	const enum fast_mblock_notify_type type,
+    const struct fast_mblock_malloc *node, void *args);
 
 struct fast_mblock_info
 {
@@ -70,6 +91,7 @@ struct fast_mblock_info
     int element_size;         //element size
     int trunk_size;           //trunk size
     int instance_count;       //instance count
+    int block_size;
     int64_t element_total_count;  //total element count
     int64_t element_used_count;   //used element count
     int64_t delay_free_elements;  //delay free element count
@@ -82,7 +104,13 @@ struct fast_mblock_trunks
 	struct fast_mblock_malloc head; //malloc chain to be freed
 };
 
-struct fast_mblock_malloc_trunk_callback
+struct fast_mblock_object_callbacks {
+    fast_mblock_object_init_func init_func;
+    fast_mblock_object_destroy_func destroy_func;
+    void *args;
+};
+
+struct fast_mblock_trunk_callbacks
 {
     fast_mblock_malloc_trunk_check_func check_func;
     fast_mblock_malloc_trunk_notify_func notify_func;
@@ -99,24 +127,28 @@ struct fast_mblock_man
         int64_t limit;         //<= 0 for no limit
         bool *pcontinue_flag;
     } alloc_elements;
-    struct fast_mblock_node *free_chain_head;    //free node chain
+
+    struct {
+        struct fast_mblock_node *head;
+    } freelist;    //free node chain
+
     struct fast_mblock_trunks trunks;
     struct fast_mblock_chain delay_free_chain;   //delay free node chain
 
-    fast_mblock_alloc_init_func alloc_init_func;
-    struct fast_mblock_malloc_trunk_callback malloc_trunk_callback;
+    struct fast_mblock_object_callbacks object_callbacks;
+    struct fast_mblock_trunk_callbacks trunk_callbacks;
 
     bool need_lock;         //if need mutex lock
     pthread_lock_cond_pair_t lcp;  //for read / write free node chain
     struct fast_mblock_man *prev;  //for stat manager
     struct fast_mblock_man *next;  //for stat manager
-    void *init_args;          //args for alloc_init_func
 };
 
-#define  GET_BLOCK_SIZE(info) \
-	(MEM_ALIGN(sizeof(struct fast_mblock_node) + (info).element_size))
+#define  fast_mblock_get_block_size(element_size) \
+	(MEM_ALIGN(sizeof(struct fast_mblock_node) + element_size))
 
-#define fast_mblock_get_block_size(mblock) GET_BLOCK_SIZE(mblock->info)
+#define fast_mblock_get_trunk_size(block_size, element_count) \
+    (sizeof(struct fast_mblock_malloc) + block_size * element_count)
 
 #define fast_mblock_to_node_ptr(data_ptr) \
         (struct fast_mblock_node *)((char *)data_ptr - ((size_t)(char *) \
@@ -127,27 +159,9 @@ extern "C" {
 #endif
 
 #define fast_mblock_init(mblock, element_size, alloc_elements_once) \
-    fast_mblock_init_ex(mblock, element_size, alloc_elements_once,  \
+    fast_mblock_init_ex(mblock, element_size, alloc_elements_once, \
             0, NULL, NULL, true)
 
-/**
-mblock init
-parameters:
-    mblock: the mblock pointer
-    element_size: element size, such as sizeof(struct xxx)
-    alloc_elements_once: malloc elements once, 0 for malloc 1MB memory once
-    alloc_elements_limit: malloc elements limit, <= 0 for no limit
-    init_func: the init function
-    init_args: the args for init_func
-    need_lock: if need lock
-return error no, 0 for success, != 0 fail
-*/
-int fast_mblock_init_ex(struct fast_mblock_man *mblock,
-        const int element_size, const int alloc_elements_once,
-        const int64_t alloc_elements_limit,
-        fast_mblock_alloc_init_func init_func, void *init_args,
-        const bool need_lock);
-
 /**
 mblock init
 parameters:
@@ -156,22 +170,18 @@ parameters:
     element_size: element size, such as sizeof(struct xxx)
     alloc_elements_once: malloc elements once, 0 for malloc 1MB memory once
     alloc_elements_limit: malloc elements limit, <= 0 for no limit
-    init_func: the init function
-    init_args: the args for init_func
+    prealloc_trunk_count: prealloc trunk node count
+    object_callbacks: the object callback functions and args
     need_lock: if need lock
-    malloc_trunk_check: the malloc trunk check function pointor
-    malloc_trunk_notify: the malloc trunk notify function pointor
-    malloc_trunk_args: the malloc trunk args
+    trunk_callbacks: the trunk callback functions and args
 return error no, 0 for success, != 0 fail
 */
 int fast_mblock_init_ex2(struct fast_mblock_man *mblock, const char *name,
         const int element_size, const int alloc_elements_once,
-        const int64_t alloc_elements_limit,
-        fast_mblock_alloc_init_func init_func,
-        void *init_args, const bool need_lock,
-        fast_mblock_malloc_trunk_check_func malloc_trunk_check,
-        fast_mblock_malloc_trunk_notify_func malloc_trunk_notify,
-        void *malloc_trunk_args);
+        const int64_t alloc_elements_limit, const int prealloc_trunk_count,
+        struct fast_mblock_object_callbacks *object_callbacks,
+        const bool need_lock, struct fast_mblock_trunk_callbacks
+        *trunk_callbacks);
 
 /**
 mblock init
@@ -181,23 +191,51 @@ parameters:
     element_size: element size, such as sizeof(struct xxx)
     alloc_elements_once: malloc elements once, 0 for malloc 1MB memory once
     alloc_elements_limit: malloc elements limit, <= 0 for no limit
-    init_func: the init function
-    init_args: the args for init_func
+    init_func: the object init function
+    init_args: the args for object init function
     need_lock: if need lock
 return error no, 0 for success, != 0 fail
 */
 static inline int fast_mblock_init_ex1(struct fast_mblock_man *mblock,
         const char *name, const int element_size,
-        const int alloc_elements_once,
-        const int64_t alloc_elements_limit,
-        fast_mblock_alloc_init_func init_func,
-        void *init_args, const bool need_lock)
+        const int alloc_elements_once, const int64_t alloc_elements_limit,
+        fast_mblock_object_init_func init_func, void *init_args,
+        const bool need_lock)
 {
+    const int prealloc_trunk_count = 0;
+    struct fast_mblock_object_callbacks object_callbacks;
+
+    object_callbacks.init_func = init_func;
+    object_callbacks.destroy_func = NULL;
+    object_callbacks.args = init_args;
     return fast_mblock_init_ex2(mblock, name, element_size,
-            alloc_elements_once, alloc_elements_limit, init_func,
-            init_args, need_lock, NULL, NULL, NULL);
+            alloc_elements_once, alloc_elements_limit,
+            prealloc_trunk_count, &object_callbacks,
+            need_lock, NULL);
 }
 
+/**
+mblock init
+parameters:
+    mblock: the mblock pointer
+    element_size: element size, such as sizeof(struct xxx)
+    alloc_elements_once: malloc elements once, 0 for malloc 1MB memory once
+    alloc_elements_limit: malloc elements limit, <= 0 for no limit
+    object_callbacks: the object callback functions and args
+    need_lock: if need lock
+return error no, 0 for success, != 0 fail
+*/
+static inline int fast_mblock_init_ex(struct fast_mblock_man *mblock,
+        const int element_size, const int alloc_elements_once,
+        const int64_t alloc_elements_limit, fast_mblock_object_init_func
+        init_func, void *init_args, const bool need_lock)
+{
+    return fast_mblock_init_ex1(mblock, NULL, element_size,
+            alloc_elements_once, alloc_elements_limit,
+            init_func, init_args, need_lock);
+}
+
+
 /**
 mblock destroy
 parameters:
@@ -225,6 +263,15 @@ static inline int fast_mblock_set_need_wait(struct fast_mblock_man *mblock,
     return 0;
 }
 
+static inline void fast_mblock_set_exceed_log_level(
+        struct fast_mblock_man *mblock, const int log_level)
+{
+    mblock->alloc_elements.exceed_log_level = log_level;
+}
+
+#define fast_mblock_set_exceed_silence(mblock)  \
+    fast_mblock_set_exceed_log_level(mblock, LOG_NOTHING)
+
 /**
 alloc a node from the mblock
 parameters:
@@ -243,6 +290,45 @@ return 0 for success, return none zero if fail
 int fast_mblock_free(struct fast_mblock_man *mblock,
 		     struct fast_mblock_node *pNode);
 
+/**
+batch alloc nodes from the mblock
+parameters:
+	mblock: the mblock pointer
+    count: alloc count
+    chain: return the mblock node chain
+return 0 for success, return none zero if fail
+*/
+int fast_mblock_batch_alloc(struct fast_mblock_man *mblock,
+        const int count, struct fast_mblock_chain *chain);
+
+/**
+batch alloc nodes from the mblock
+parameters:
+	mblock: the mblock pointer
+    count: alloc count
+return the alloced node head, return NULL if fail
+*/
+static inline struct fast_mblock_node *fast_mblock_batch_alloc1(
+        struct fast_mblock_man *mblock, const int count)
+{
+    struct fast_mblock_chain chain;
+    if (fast_mblock_batch_alloc(mblock, count, &chain) == 0) {
+        return chain.head;
+    } else {
+        return NULL;
+    }
+}
+
+/**
+batch free nodes
+parameters:
+	mblock: the mblock pointer
+	chain: the node chain to free
+return 0 for success, return none zero if fail
+*/
+int fast_mblock_batch_free(struct fast_mblock_man *mblock,
+        struct fast_mblock_chain *chain);
+
 /**
 delay free a node (put a node to the mblock)
 parameters:
@@ -284,6 +370,17 @@ static inline int fast_mblock_free_object(struct fast_mblock_man *mblock,
     return fast_mblock_free(mblock, fast_mblock_to_node_ptr(object));
 }
 
+/**
+free objects (put objects to the mblock)
+parameters:
+	mblock: the mblock pointer
+	objs:  the object array to free
+    count: the count of the object array
+return none
+*/
+void fast_mblock_free_objects(struct fast_mblock_man *mblock,
+        void **objs, const int count);
+
 /**
 delay free a object (put a node to the mblock)
 parameters:
@@ -314,7 +411,7 @@ return the delay free node count of the mblock, return -1 if fail
 */
 int fast_mblock_delay_free_count(struct fast_mblock_man *mblock);
 
-#define fast_mblock_total_count(mblock) (mblock)->total_count
+#define fast_mblock_total_count(mblock) (mblock)->info.element_total_count
 
 /**
 init mblock manager

src/fast_mpool.c

@@ -48,6 +48,10 @@ int fast_mpool_init(struct fast_mpool_man *mpool,
 
 	mpool->malloc_chain_head = NULL;
 	mpool->free_chain_head = NULL;
+	mpool->alloc_count = 0;
+	mpool->alloc_bytes = 0;
+	mpool->reset.count = 0;
+	mpool->reset.last_alloc_count = 0;
 
 	return 0;
 }
@@ -138,6 +142,8 @@ static inline void *fast_mpool_do_alloc(struct fast_mpool_man *mpool,
             fast_mpool_remove_free_node(mpool, pMallocNode);
         }
 
+        mpool->alloc_count++;
+        mpool->alloc_bytes += size;
         return ptr;
     }
     return NULL;
@@ -196,19 +202,26 @@ void *fast_mpool_memdup(struct fast_mpool_man *mpool,
 
 void fast_mpool_reset(struct fast_mpool_man *mpool)
 {
-	struct fast_mpool_malloc *pMallocNode;
+    struct fast_mpool_malloc *pMallocNode;
 
-	mpool->free_chain_head = NULL;
-	pMallocNode = mpool->malloc_chain_head;
-	while (pMallocNode != NULL)
-	{
+    mpool->reset.count++;
+	if (mpool->reset.last_alloc_count == mpool->alloc_count)
+    {
+        return;
+    }
+
+    mpool->reset.last_alloc_count = mpool->alloc_count;
+    mpool->free_chain_head = NULL;
+    pMallocNode = mpool->malloc_chain_head;
+    while (pMallocNode != NULL)
+    {
         pMallocNode->free_ptr = pMallocNode->base_ptr;
 
         pMallocNode->free_next = mpool->free_chain_head;
         mpool->free_chain_head = pMallocNode;
 
-		pMallocNode = pMallocNode->malloc_next;
-	}
+        pMallocNode = pMallocNode->malloc_next;
+    }
 }
 
 void fast_mpool_stats(struct fast_mpool_man *mpool,
@@ -243,12 +256,22 @@ void fast_mpool_stats(struct fast_mpool_man *mpool,
 void fast_mpool_log_stats(struct fast_mpool_man *mpool)
 {
     struct fast_mpool_stats stats;
+    char sz_total_bytes[32];
+    char sz_free_bytes[32];
+    char sz_alloc_bytes[32];
 
     fast_mpool_stats(mpool, &stats);
+
+    long_to_comma_str(stats.total_bytes, sz_total_bytes);
+    long_to_comma_str(stats.free_bytes, sz_free_bytes);
+    long_to_comma_str(mpool->alloc_bytes, sz_alloc_bytes);
     logInfo("alloc_size_once: %d, discard_size: %d, "
-            "bytes: {total: %"PRId64", free: %"PRId64"}, "
-            "trunk_count: {total: %d, free: %d}",
-            mpool->alloc_size_once, mpool->discard_size,
-            stats.total_bytes, stats.free_bytes,
-            stats.total_trunk_count, stats.free_trunk_count);
+            "bytes: {total: %s, free: %s}, "
+            "trunk_count: {total: %d, free: %d}, "
+            "alloc_count: %"PRId64", alloc_bytes: %s, "
+            "reset_count: %"PRId64, mpool->alloc_size_once,
+            mpool->discard_size, sz_total_bytes,
+            sz_free_bytes, stats.total_trunk_count,
+            stats.free_trunk_count, mpool->alloc_count,
+            sz_alloc_bytes, mpool->reset.count);
 }

src/fast_mpool.h

@@ -37,10 +37,16 @@ struct fast_mpool_malloc
 
 struct fast_mpool_man
 {
-	struct fast_mpool_malloc *malloc_chain_head; //malloc chain to be freed
-	struct fast_mpool_malloc *free_chain_head;   //free node chain
-	int alloc_size_once;  //alloc size once, default: 1MB
-	int discard_size;     //discard size, default: 64 bytes
+    struct fast_mpool_malloc *malloc_chain_head; //malloc chain to be freed
+    struct fast_mpool_malloc *free_chain_head;   //free node chain
+    int alloc_size_once;  //alloc size once, default: 1MB
+    int discard_size;     //discard size, default: 64 bytes
+    int64_t alloc_count;
+    int64_t alloc_bytes;
+    struct {
+        int64_t count;
+        int64_t last_alloc_count;
+    } reset;
 };
 
 struct fast_mpool_stats

src/fast_task_queue.c

@@ -25,667 +25,214 @@
 #include "fc_memory.h"
 #include "fast_task_queue.h"
 
-static struct fast_task_queue g_free_queue;
-
-struct mpool_node {
-	struct fast_task_info *blocks;
-	struct fast_task_info *last_block;   //last block
-	struct mpool_node *next;
-};
-
-struct mpool_chain {
-    struct mpool_node *head;
-    struct mpool_node *tail;
-};
-
-static struct mpool_chain g_mpool = {NULL, NULL};
-
-int task_queue_init(struct fast_task_queue *pQueue)
+static int task_alloc_init(struct fast_task_info *task,
+        struct fast_task_queue *queue)
 {
-	int result;
-
-	if ((result=init_pthread_lock(&(pQueue->lock))) != 0)
-	{
-		logError("file: "__FILE__", line: %d, " \
-			"init_pthread_lock fail, errno: %d, error info: %s", \
-			__LINE__, result, STRERROR(result));
-		return result;
-	}
-
-	pQueue->head = NULL;
-	pQueue->tail = NULL;
-
-	return 0;
-}
-
-static void free_mpool(struct mpool_node *mpool, char *end)
-{
-    char *pt;
-    for (pt=(char *)mpool->blocks; pt < end; pt += g_free_queue.block_size)
-    {
-        free(((struct fast_task_info *)pt)->data);
-    }
-
-    free(mpool->blocks);
-    free(mpool);
-}
-
-static struct mpool_node *malloc_mpool(const int total_alloc_size)
-{
-	struct fast_task_info *pTask;
-	char *p;
-	char *pCharEnd;
-	struct mpool_node *mpool;
-
-	mpool = (struct mpool_node *)fc_malloc(sizeof(struct mpool_node));
-	if (mpool == NULL)
-	{
-		return NULL;
-	}
-
-	mpool->next = NULL;
-	mpool->blocks = (struct fast_task_info *)fc_malloc(total_alloc_size);
-	if (mpool->blocks == NULL)
-	{
-		free(mpool);
-		return NULL;
-	}
-	memset(mpool->blocks, 0, total_alloc_size);
-
-	pCharEnd = ((char *)mpool->blocks) + total_alloc_size;
-	for (p=(char *)mpool->blocks; p<pCharEnd; p += g_free_queue.block_size)
-	{
-		pTask = (struct fast_task_info *)p;
-		pTask->size = g_free_queue.min_buff_size;
-
-		pTask->arg = p + ALIGNED_TASK_INFO_SIZE;
-		if (g_free_queue.malloc_whole_block)
-		{
-			pTask->data = (char *)pTask->arg + \
-					g_free_queue.arg_size;
-		}
-		else
-		{
-			pTask->data = (char *)fc_malloc(pTask->size);
-			if (pTask->data == NULL)
-			{
-                free_mpool(mpool, p);
-				return NULL;
-			}
-		}
-
-        if (g_free_queue.init_callback != NULL)
-        {
-            if (g_free_queue.init_callback(pTask) != 0)
-            {
-                free_mpool(mpool, p);
-                return NULL;
-            }
-        }
-	}
-
-	mpool->last_block = (struct fast_task_info *)
-        (pCharEnd - g_free_queue.block_size);
-	for (p=(char *)mpool->blocks; p<(char *)mpool->last_block;
-            p += g_free_queue.block_size)
-	{
-		pTask = (struct fast_task_info *)p;
-		pTask->next = (struct fast_task_info *)(p + g_free_queue.block_size);
-	}
-	mpool->last_block->next = NULL;
-
-	return mpool;
-}
-
-int free_queue_init_ex2(const int max_connections, const int init_connections,
-        const int alloc_task_once, const int min_buff_size,
-        const int max_buff_size, const int arg_size,
-        TaskInitCallback init_callback)
-{
-#define MAX_DATA_SIZE  (256 * 1024 * 1024)
-	int64_t total_size;
-	struct mpool_node *mpool;
-	int alloc_size;
-    int alloc_once;
-	int result;
-	int loop_count;
-	int aligned_min_size;
-	int aligned_max_size;
-	int aligned_arg_size;
-	rlim_t max_data_size;
-
-	if ((result=init_pthread_lock(&(g_free_queue.lock))) != 0)
-	{
-		logError("file: "__FILE__", line: %d, " \
-			"init_pthread_lock fail, errno: %d, error info: %s", \
-			__LINE__, result, STRERROR(result));
-		return result;
-	}
-
-	aligned_min_size = MEM_ALIGN(min_buff_size);
-	aligned_max_size = MEM_ALIGN(max_buff_size);
-	aligned_arg_size = MEM_ALIGN(arg_size);
-	g_free_queue.block_size = ALIGNED_TASK_INFO_SIZE + aligned_arg_size;
-	alloc_size = g_free_queue.block_size * init_connections;
-	if (aligned_max_size > aligned_min_size)
-	{
-		total_size = alloc_size;
-		g_free_queue.malloc_whole_block = false;
-		max_data_size = 0;
-	}
-	else
-	{
-		struct rlimit rlimit_data;
-
-		if (getrlimit(RLIMIT_DATA, &rlimit_data) < 0)
-		{
-			logError("file: "__FILE__", line: %d, " \
-				"call getrlimit fail, " \
-				"errno: %d, error info: %s", \
-				__LINE__, errno, STRERROR(errno));
-			return errno != 0 ? errno : EPERM;
-		}
-		if (rlimit_data.rlim_cur == RLIM_INFINITY)
-		{
-			max_data_size = MAX_DATA_SIZE;
-		}
-		else
-		{
-			max_data_size = rlimit_data.rlim_cur;
-			if (max_data_size > MAX_DATA_SIZE)
-			{
-				max_data_size = MAX_DATA_SIZE;
-			}
-		}
-
-		if (max_data_size >= (int64_t)(g_free_queue.block_size +
-                    aligned_min_size) * (int64_t)init_connections)
-		{
-			total_size = alloc_size + (int64_t)aligned_min_size *
-					init_connections;
-			g_free_queue.malloc_whole_block = true;
-			g_free_queue.block_size += aligned_min_size;
-		}
-		else
-		{
-			total_size = alloc_size;
-			g_free_queue.malloc_whole_block = false;
-			max_data_size = 0;
-		}
-	}
-
-	g_free_queue.max_connections = max_connections;
-	g_free_queue.alloc_connections = init_connections;
-    if (alloc_task_once <= 0)
-    {
-        g_free_queue.alloc_task_once = 256;
-		alloc_once = MAX_DATA_SIZE / g_free_queue.block_size;
-        if (g_free_queue.alloc_task_once > alloc_once)
-        {
-            g_free_queue.alloc_task_once = alloc_once > 0 ? alloc_once : 1;
-        }
-    }
-    else
-    {
-        g_free_queue.alloc_task_once = alloc_task_once;
-    }
-	g_free_queue.min_buff_size = aligned_min_size;
-	g_free_queue.max_buff_size = aligned_max_size;
-	g_free_queue.arg_size = aligned_arg_size;
-	g_free_queue.init_callback = init_callback;
-
-	logDebug("file: "__FILE__", line: %d, "
-		"max_connections: %d, init_connections: %d, alloc_task_once: %d, "
-        "min_buff_size: %d, max_buff_size: %d, block_size: %d, "
-        "arg_size: %d, max_data_size: %d, total_size: %"PRId64,
-        __LINE__, max_connections, init_connections,
-        g_free_queue.alloc_task_once, aligned_min_size, aligned_max_size,
-        g_free_queue.block_size, aligned_arg_size, (int)max_data_size, total_size);
-
-	if ((!g_free_queue.malloc_whole_block) || (total_size <= max_data_size))
-	{
-		loop_count = 1;
-		mpool = malloc_mpool(total_size);
-		if (mpool == NULL)
-		{
-			return errno != 0 ? errno : ENOMEM;
-		}
-		g_mpool.head = mpool;
-		g_mpool.tail = mpool;
-	}
-	else
-	{
-		int remain_count;
-		int alloc_count;
-		int current_alloc_size;
-
-		loop_count = 0;
-		remain_count = init_connections;
-		alloc_once = max_data_size / g_free_queue.block_size;
-		while (remain_count > 0)
-		{
-			alloc_count = (remain_count > alloc_once) ?
-					alloc_once : remain_count;
-			current_alloc_size = g_free_queue.block_size * alloc_count;
-			mpool = malloc_mpool(current_alloc_size);
-			if (mpool == NULL)
-			{
-				free_queue_destroy();
-				return errno != 0 ? errno : ENOMEM;
-			}
-
-			if (g_mpool.tail == NULL)
-			{
-				g_mpool.head = mpool;
-			}
-			else
-			{
-				g_mpool.tail->next = mpool;
-				g_mpool.tail->last_block->next = mpool->blocks;  //link previous mpool to current
-			}
-            g_mpool.tail = mpool;
-
-			remain_count -= alloc_count;
-			loop_count++;
-		}
-
-		logDebug("file: "__FILE__", line: %d, " \
-			"alloc_once: %d", __LINE__, alloc_once);
-	}
-
-	logDebug("file: "__FILE__", line: %d, " \
-		"malloc task info as whole: %d, malloc loop count: %d", \
-		__LINE__, g_free_queue.malloc_whole_block, loop_count);
-
-	if (g_mpool.head != NULL)
-	{
-		g_free_queue.head = g_mpool.head->blocks;
-		g_free_queue.tail = g_mpool.tail->last_block;
-	}
-
-	return 0;
-}
-
-void free_queue_destroy()
-{
-	struct mpool_node *mpool;
-	struct mpool_node *mp;
-
-	if (g_mpool.head == NULL)
-	{
-		return;
-	}
-
-	if (!g_free_queue.malloc_whole_block)
-	{
-		char *p;
-		char *pCharEnd;
-		struct fast_task_info *pTask;
-
-        mpool = g_mpool.head;
-        while (mpool != NULL)
-        {
-            pCharEnd = (char *)mpool->last_block + g_free_queue.block_size;
-            for (p=(char *)mpool->blocks; p<pCharEnd; p += g_free_queue.block_size)
-            {
-                pTask = (struct fast_task_info *)p;
-                if (pTask->data != NULL)
-                {
-                    free(pTask->data);
-                    pTask->data = NULL;
-                }
-            }
-            mpool = mpool->next;
-        }
-	}
-
-	mpool = g_mpool.head;
-	while (mpool != NULL)
-	{
-		mp = mpool;
-		mpool = mpool->next;
-
-		free(mp->blocks);
-		free(mp);
-	}
-	g_mpool.head = g_mpool.tail = NULL;
-
-	pthread_mutex_destroy(&(g_free_queue.lock));
-}
-
-static int free_queue_realloc()
-{
-	struct mpool_node *mpool;
-	struct fast_task_info *head;
-	struct fast_task_info *tail;
-	int remain_count;
-	int alloc_count;
-	int current_alloc_size;
-
-    head = tail = NULL;
-	remain_count = g_free_queue.max_connections -
-        g_free_queue.alloc_connections;
-    alloc_count = (remain_count > g_free_queue.alloc_task_once) ?
-        g_free_queue.alloc_task_once : remain_count;
-    if (alloc_count > 0)
-	{
-		current_alloc_size = g_free_queue.block_size * alloc_count;
-		mpool = malloc_mpool(current_alloc_size);
-		if (mpool == NULL)
-		{
+    task->arg = (char *)task + ALIGNED_TASK_INFO_SIZE + queue->padding_size;
+    task->send.ptr = &task->send.holder;
+    task->send.ptr->size = queue->min_buff_size;
+    if (queue->malloc_whole_block) {
+        task->send.ptr->data = (char *)task->arg + queue->arg_size;
+    } else {
+        task->send.ptr->data = (char *)fc_malloc(task->send.ptr->size);
+        if (task->send.ptr->data == NULL) {
             return ENOMEM;
-		}
-
-		if (g_mpool.tail == NULL)
-		{
-			g_mpool.head = mpool;
-		}
-		else
-		{
-			g_mpool.tail->next = mpool;
-		}
-        g_mpool.tail = mpool;
-
-        head = mpool->blocks;
-        tail = mpool->last_block;
-
-		remain_count -= alloc_count;
-	}
-    else {
-        return ENOSPC;
+        }
     }
 
-    if (g_free_queue.head == NULL)
-    {
-        g_free_queue.head = head;
+    if (queue->double_buffers) {
+        task->recv.ptr = &task->recv.holder;
+        task->recv.ptr->size = queue->min_buff_size;
+        task->recv.ptr->data = (char *)fc_malloc(task->recv.ptr->size);
+        if (task->recv.ptr->data == NULL) {
+            return ENOMEM;
+        }
+    } else {
+        task->recv.ptr = &task->send.holder;
     }
-    if (g_free_queue.tail != NULL)
-    {
-        g_free_queue.tail->next = head;
+
+    task->free_queue = queue;
+    if (queue->init_callback != NULL) {
+        return queue->init_callback(task, queue->init_arg);
     }
-    g_free_queue.tail = tail;
-
-    g_free_queue.alloc_connections += alloc_count;
-
-	logDebug("file: "__FILE__", line: %d, "
-		"alloc_connections: %d, realloc %d elements", __LINE__,
-        g_free_queue.alloc_connections, alloc_count);
-
     return 0;
 }
 
-struct fast_task_info *free_queue_pop()
+int free_queue_init_ex2(struct fast_task_queue *queue, const char *name,
+        const bool double_buffers, const bool need_shrink,
+        const int max_connections, const int alloc_task_once,
+        const int min_buff_size, const int max_buff_size,
+        const int padding_size, const int arg_size,
+        TaskInitCallback init_callback, void *init_arg)
 {
-    struct fast_task_info *pTask;
-    int i;
+#define MAX_DATA_SIZE  (256 * 1024 * 1024)
+    int alloc_once;
+	int aligned_min_size;
+	int aligned_max_size;
+	int aligned_padding_size;
+	int aligned_arg_size;
+	rlim_t max_data_size;
+    char aname[64];
 
-	if ((pTask=task_queue_pop(&g_free_queue)) != NULL)
-    {
-        return pTask;
+	aligned_min_size = MEM_ALIGN(min_buff_size);
+	aligned_max_size = MEM_ALIGN(max_buff_size);
+    aligned_padding_size = MEM_ALIGN(padding_size);
+	aligned_arg_size = MEM_ALIGN(arg_size);
+	queue->block_size = ALIGNED_TASK_INFO_SIZE +
+        aligned_padding_size + aligned_arg_size;
+    if (alloc_task_once <= 0) {
+        alloc_once = FC_MIN(MAX_DATA_SIZE / queue->block_size, 256);
+        if (alloc_once == 0) {
+            alloc_once = 1;
+        }
+    } else {
+        alloc_once = alloc_task_once;
     }
 
-    if (g_free_queue.alloc_connections >= g_free_queue.max_connections)
-    {
-        return NULL;
-    }
+	if (aligned_max_size > aligned_min_size) {
+		queue->malloc_whole_block = false;
+		max_data_size = 0;
+    } else {
+        struct rlimit rlimit_data;
 
-    for (i=0; i<10; i++)
-    {
-        pthread_mutex_lock(&g_free_queue.lock);
-        if (g_free_queue.alloc_connections >= g_free_queue.max_connections)
-        {
-            if (g_free_queue.head == NULL)
-            {
-                pthread_mutex_unlock(&g_free_queue.lock);
-                return NULL;
+        if (getrlimit(RLIMIT_DATA, &rlimit_data) < 0) {
+            logError("file: "__FILE__", line: %d, "
+                    "call getrlimit fail, "
+                    "errno: %d, error info: %s",
+                    __LINE__, errno, STRERROR(errno));
+            return errno != 0 ? errno : EPERM;
+        }
+        if (rlimit_data.rlim_cur == RLIM_INFINITY) {
+            max_data_size = MAX_DATA_SIZE;
+        } else {
+            max_data_size = rlimit_data.rlim_cur;
+            if (max_data_size > MAX_DATA_SIZE) {
+                max_data_size = MAX_DATA_SIZE;
             }
         }
-        else
-        {
-            if (g_free_queue.head == NULL && free_queue_realloc() != 0)
-            {
-                pthread_mutex_unlock(&g_free_queue.lock);
-                return NULL;
-            }
-        }
-        pthread_mutex_unlock(&g_free_queue.lock);
 
-        if ((pTask=task_queue_pop(&g_free_queue)) != NULL)
+        if (max_data_size >= (int64_t)(queue->block_size +
+                    aligned_min_size) * (int64_t)alloc_once)
         {
-            return pTask;
+            queue->malloc_whole_block = true;
+            queue->block_size += aligned_min_size;
+        } else {
+            queue->malloc_whole_block = false;
+            max_data_size = 0;
         }
     }
 
-    return NULL;
+    queue->double_buffers = double_buffers;
+    queue->need_shrink = need_shrink;
+	queue->min_buff_size = aligned_min_size;
+	queue->max_buff_size = aligned_max_size;
+	queue->padding_size = aligned_padding_size;
+	queue->arg_size = aligned_arg_size;
+	queue->init_callback = init_callback;
+	queue->init_arg = init_arg;
+    queue->release_callback = NULL;
+
+    /*
+	logInfo("file: "__FILE__", line: %d, [%s] double_buffers: %d, "
+		"max_connections: %d, alloc_once: %d, malloc_whole_block: %d, "
+        "min_buff_size: %d, max_buff_size: %d, block_size: %d, "
+        "padding_size: %d, arg_size: %d, max_data_size: %"PRId64,
+        __LINE__, name, double_buffers, max_connections, alloc_once,
+        queue->malloc_whole_block, aligned_min_size, aligned_max_size,
+        queue->block_size, aligned_padding_size, aligned_arg_size,
+        (int64_t)max_data_size);
+        */
+
+    fc_combine_two_strings(name, "task", '-', aname);
+	return fast_mblock_init_ex1(&queue->allocator, aname,
+            queue->block_size, alloc_once, max_connections,
+            (fast_mblock_object_init_func)task_alloc_init,
+            queue, true);
 }
 
-static int _realloc_buffer(struct fast_task_info *pTask, const int new_size,
-        const bool copy_data)
+void free_queue_destroy(struct fast_task_queue *queue)
+{
+    fast_mblock_destroy(&queue->allocator);
+}
+
+static int _realloc_buffer(struct fast_net_buffer *buffer,
+        const int new_size, const bool copy_data)
 {
 	char *new_buff;
+
     new_buff = (char *)fc_malloc(new_size);
-    if (new_buff == NULL)
-    {
+    if (new_buff == NULL) {
         return ENOMEM;
     }
-    else
-    {
-        if (copy_data && pTask->offset > 0) {
-            memcpy(new_buff, pTask->data, pTask->offset);
-        }
-        free(pTask->data);
-        pTask->size = new_size;
-        pTask->data = new_buff;
-        return 0;
+
+    if (copy_data && buffer->offset > 0) {
+        memcpy(new_buff, buffer->data, buffer->offset);
     }
+    free(buffer->data);
+    buffer->size = new_size;
+    buffer->data = new_buff;
+    return 0;
 }
 
-int free_queue_push(struct fast_task_info *pTask)
+void free_queue_push(struct fast_task_info *task)
 {
-	int result;
+    if (task->free_queue->release_callback != NULL) {
+        task->free_queue->release_callback(task);
+    }
 
-	*(pTask->client_ip) = '\0';
-	pTask->length = 0;
-	pTask->offset = 0;
-	pTask->req_count = 0;
+    *(task->client_ip) = '\0';
+    task->send.ptr->length = 0;
+    task->send.ptr->offset = 0;
+    task->req_count = 0;
+    if (task->free_queue->need_shrink && task->send.
+            ptr->size > task->free_queue->min_buff_size)
+    {   //need thrink
+        _realloc_buffer(task->send.ptr, task->free_queue->
+                min_buff_size, false);
+        task->shrinked = true;
+    }
 
-	if (pTask->size > g_free_queue.min_buff_size) //need thrink
-	{
-        _realloc_buffer(pTask, g_free_queue.min_buff_size, false);
-	}
+    if (task->free_queue->double_buffers) {
+        task->recv.ptr->length = 0;
+        task->recv.ptr->offset = 0;
+        if (task->free_queue->need_shrink && task->recv.
+                ptr->size > task->free_queue->min_buff_size)
+        {
+            _realloc_buffer(task->recv.ptr, task->free_queue->
+                    min_buff_size, false);
+            task->shrinked = true;
+        }
+    }
 
-	if ((result=pthread_mutex_lock(&g_free_queue.lock)) != 0)
-	{
-		logError("file: "__FILE__", line: %d, " \
-			"call pthread_mutex_lock fail, " \
-			"errno: %d, error info: %s", \
-			__LINE__, result, STRERROR(result));
-	}
-
-	pTask->next = g_free_queue.head;
-	g_free_queue.head = pTask;
-	if (g_free_queue.tail == NULL)
-	{
-		g_free_queue.tail = pTask;
-	}
-
-	if ((result=pthread_mutex_unlock(&g_free_queue.lock)) != 0)
-	{
-		logError("file: "__FILE__", line: %d, " \
-			"call pthread_mutex_unlock fail, " \
-			"errno: %d, error info: %s", \
-			__LINE__, result, STRERROR(result));
-	}
-
-	return result;
+    fast_mblock_free_object(&task->free_queue->allocator, task);
 }
 
-int free_queue_count()
-{
-	return task_queue_count(&g_free_queue);
-}
-
-int free_queue_alloc_connections()
-{
-    return g_free_queue.alloc_connections;
-}
-
-int free_queue_set_buffer_size(struct fast_task_info *pTask,
-        const int expect_size)
-{
-    return task_queue_set_buffer_size(&g_free_queue, pTask, expect_size);
-}
-
-int free_queue_realloc_buffer(struct fast_task_info *pTask,
-        const int expect_size)
-{
-    return task_queue_realloc_buffer(&g_free_queue, pTask, expect_size);
-}
-
-int free_queue_set_max_buffer_size(struct fast_task_info *pTask)
-{
-    return task_queue_set_buffer_size(&g_free_queue, pTask,
-            g_free_queue.max_buff_size);
-}
-
-int free_queue_realloc_max_buffer(struct fast_task_info *pTask)
-{
-    return task_queue_realloc_buffer(&g_free_queue, pTask,
-            g_free_queue.max_buff_size);
-}
-int task_queue_push(struct fast_task_queue *pQueue, \
-		struct fast_task_info *pTask)
-{
-	int result;
-
-	if ((result=pthread_mutex_lock(&(pQueue->lock))) != 0)
-	{
-		logError("file: "__FILE__", line: %d, " \
-			"call pthread_mutex_lock fail, " \
-			"errno: %d, error info: %s", \
-			__LINE__, result, STRERROR(result));
-		return result;
-	}
-
-	pTask->next = NULL;
-	if (pQueue->tail == NULL)
-	{
-		pQueue->head = pTask;
-	}
-	else
-	{
-		pQueue->tail->next = pTask;
-	}
-	pQueue->tail = pTask;
-
-	if ((result=pthread_mutex_unlock(&(pQueue->lock))) != 0)
-	{
-		logError("file: "__FILE__", line: %d, " \
-			"call pthread_mutex_unlock fail, " \
-			"errno: %d, error info: %s", \
-			__LINE__, result, STRERROR(result));
-	}
-
-	return 0;
-}
-
-struct fast_task_info *task_queue_pop(struct fast_task_queue *pQueue)
-{
-	struct fast_task_info *pTask;
-	int result;
-
-	if ((result=pthread_mutex_lock(&(pQueue->lock))) != 0)
-	{
-		logError("file: "__FILE__", line: %d, " \
-			"call pthread_mutex_lock fail, " \
-			"errno: %d, error info: %s", \
-			__LINE__, result, STRERROR(result));
-		return NULL;
-	}
-
-	pTask = pQueue->head;
-	if (pTask != NULL)
-	{
-		pQueue->head = pTask->next;
-		if (pQueue->head == NULL)
-		{
-			pQueue->tail = NULL;
-		}
-	}
-
-	if ((result=pthread_mutex_unlock(&(pQueue->lock))) != 0)
-	{
-		logError("file: "__FILE__", line: %d, " \
-			"call pthread_mutex_unlock fail, " \
-			"errno: %d, error info: %s", \
-			__LINE__, result, STRERROR(result));
-	}
-
-	return pTask;
-}
-
-int task_queue_count(struct fast_task_queue *pQueue)
-{
-	struct fast_task_info *pTask;
-	int count;
-	int result;
-
-	if ((result=pthread_mutex_lock(&(pQueue->lock))) != 0)
-	{
-		logError("file: "__FILE__", line: %d, " \
-			"call pthread_mutex_lock fail, " \
-			"errno: %d, error info: %s", \
-			__LINE__, result, STRERROR(result));
-		return 0;
-	}
-
-	count = 0;
-	pTask = pQueue->head;
-	while (pTask != NULL)
-	{
-		pTask = pTask->next;
-		count++;
-	}
-
-	if ((result=pthread_mutex_unlock(&(pQueue->lock))) != 0)
-	{
-		logError("file: "__FILE__", line: %d, " \
-			"call pthread_mutex_unlock fail, " \
-			"errno: %d, error info: %s", \
-			__LINE__, result, STRERROR(result));
-	}
-
-	return count;
-}
-
-int task_queue_get_new_buffer_size(const int min_buff_size,
+int free_queue_get_new_buffer_size(const int min_buff_size,
         const int max_buff_size, const int expect_size, int *new_size)
 {
-    if (min_buff_size == max_buff_size)
-    {
+    if (min_buff_size == max_buff_size) {
         logError("file: "__FILE__", line: %d, "
                 "can't change buffer size because NOT supported", __LINE__);
         return EOPNOTSUPP;
     }
 
-    if (expect_size > max_buff_size)
-    {
+    if (expect_size > max_buff_size) {
         logError("file: "__FILE__", line: %d, "
                 "can't change buffer size because expect buffer size: %d "
                 "exceeds max buffer size: %d", __LINE__, expect_size,
                 max_buff_size);
         return EOVERFLOW;
+    } else if (expect_size == max_buff_size) {
+        *new_size = max_buff_size;
+        return 0;
     }
 
     *new_size = min_buff_size;
-    if (expect_size > min_buff_size)
-    {
-        while (*new_size < expect_size)
-        {
+    if (expect_size > min_buff_size) {
+        while (*new_size < expect_size) {
             *new_size *= 2;
         }
-        if (*new_size > max_buff_size)
-        {
+        if (*new_size > max_buff_size) {
             *new_size = max_buff_size;
         }
     }
@@ -693,41 +240,43 @@ int task_queue_get_new_buffer_size(const int min_buff_size,
     return 0;
 }
 
-#define  _get_new_buffer_size(pQueue, expect_size, new_size) \
-    task_queue_get_new_buffer_size(pQueue->min_buff_size, \
-            pQueue->max_buff_size, expect_size, new_size)
+#define  _get_new_buffer_size(queue, expect_size, new_size) \
+    free_queue_get_new_buffer_size(queue->min_buff_size, \
+            queue->max_buff_size, expect_size, new_size)
 
-int task_queue_set_buffer_size(struct fast_task_queue *pQueue,
-        struct fast_task_info *pTask, const int expect_size)
+int free_queue_set_buffer_size(struct fast_task_info *task,
+        struct fast_net_buffer *buffer, const int expect_size)
 {
     int result;
     int new_size;
 
-    if ((result=_get_new_buffer_size(pQueue, expect_size, &new_size)) != 0) {
+    if ((result=_get_new_buffer_size(task->free_queue,
+                    expect_size, &new_size)) != 0)
+    {
         return result;
     }
-    if (pTask->size == new_size)  //do NOT need change buffer size
-    {
+    if (buffer->size == new_size) { //do NOT need change buffer size
         return 0;
     }
 
-    return _realloc_buffer(pTask, new_size, false);
+    return _realloc_buffer(buffer, new_size, false);
 }
 
-int task_queue_realloc_buffer(struct fast_task_queue *pQueue,
-        struct fast_task_info *pTask, const int expect_size)
+int free_queue_realloc_buffer(struct fast_task_info *task,
+        struct fast_net_buffer *buffer, const int expect_size)
 {
     int result;
     int new_size;
 
-    if (pTask->size >= expect_size)  //do NOT need change buffer size
-    {
+    if (buffer->size >= expect_size) {  //do NOT need change buffer size
         return 0;
     }
 
-    if ((result=_get_new_buffer_size(pQueue, expect_size, &new_size)) != 0) {
+    if ((result=_get_new_buffer_size(task->free_queue,
+                    expect_size, &new_size)) != 0)
+    {
         return result;
     }
 
-    return _realloc_buffer(pTask, new_size, true);
+    return _realloc_buffer(buffer, new_size, true);
 }

src/fast_task_queue.h

@@ -23,8 +23,10 @@
 #include <string.h>
 #include <pthread.h>
 #include "common_define.h"
+#include "fc_list.h"
 #include "ioevent.h"
 #include "fast_timer.h"
+#include "fast_mblock.h"
 
 #define FC_NOTIFY_READ_FD(tdata)  (tdata)->pipe_fds[0]
 #define FC_NOTIFY_WRITE_FD(tdata) (tdata)->pipe_fds[1]
@@ -35,18 +37,27 @@ struct nio_thread_data;
 struct fast_task_info;
 
 typedef int (*ThreadLoopCallback) (struct nio_thread_data *pThreadData);
-typedef int (*TaskFinishCallback) (struct fast_task_info *pTask);
-typedef void (*TaskCleanUpCallback) (struct fast_task_info *pTask);
-typedef int (*TaskInitCallback)(struct fast_task_info *pTask);
+typedef void (*TaskCleanUpCallback) (struct fast_task_info *task);
+typedef int (*TaskInitCallback)(struct fast_task_info *task, void *arg);
+typedef void (*TaskReleaseCallback)(struct fast_task_info *task);
 
-typedef void (*IOEventCallback) (int sock, short event, void *arg);
+typedef void (*IOEventCallback) (int sock, const int event, void *arg);
+typedef int (*TaskContinueCallback)(struct fast_task_info *task);
 
+struct sf_network_handler;
 struct fast_task_info;
 
+#if IOEVENT_USE_URING
+#define FC_URING_OP_TYPE(task)     (task)->uring.op_type
+#define FC_URING_IS_CLIENT(task)   (task)->uring.is_client
+#define FC_URING_IS_SEND_ZC(task)  ((task)->uring.op_type == IORING_OP_SEND_ZC)
+#endif
+
 typedef struct ioevent_entry
 {
     FastTimerEntry timer; //must first
     int fd;
+    int res;  //just for io_uring, since v1.0.81
     IOEventCallback callback;
 } IOEventEntry;
 
@@ -57,6 +68,7 @@ struct nio_thread_data
 	int pipe_fds[2];   //for notify
 	struct fast_task_info *deleted_list;   //tasks for cleanup
 	ThreadLoopCallback thread_loop_callback;
+	ThreadLoopCallback busy_polling_callback;
 	void *arg;   //extra argument pointer
     struct {
         struct fast_task_info *head;
@@ -68,6 +80,9 @@ struct nio_thread_data
         bool enabled;
         volatile int64_t counter;
     } notify;  //for thread notify
+
+    int timeout_ms;   //for restore
+    struct fc_list_head polling_queue;  //for RDMA busy polling
 };
 
 struct ioevent_notify_entry
@@ -76,103 +91,225 @@ struct ioevent_notify_entry
     struct nio_thread_data *thread_data;
 };
 
+struct fast_net_buffer
+{
+    int size;      //alloc size
+    int length;    //data length
+    int offset;    //current offset
+    char *data;    //buffer for write or read
+};
+
+struct fast_net_buffer_wrapper
+{
+    struct fast_net_buffer holder;
+    struct fast_net_buffer *ptr;
+};
+
+struct fast_task_queue;
 struct fast_task_info
 {
-	IOEventEntry event;  //must first
+    IOEventEntry event;  //must first
     union {
         char server_ip[IP_ADDRESS_SIZE];
         char client_ip[IP_ADDRESS_SIZE];
     };
-	void *arg;  //extra argument pointer
-	char *data; //buffer for write or recv
-	int size;   //alloc size
-	int length; //data length
-	int offset; //current offset
+    void *arg;        //extra argument pointer
+    char *recv_body;  //for extra (dynamic) recv buffer
+
+    struct {
+        struct iovec *iovs;
+        int count;
+    } iovec_array; //for writev
+
+    struct fast_net_buffer_wrapper send;  //send buffer
+    struct fast_net_buffer_wrapper recv;  //recv buffer
+
     uint16_t port; //peer port
+
+    struct {
+        int8_t  is_client;
+        uint8_t op_type;
+    } uring;  //just for io_uring, since v1.0.81
+
     struct {
         uint8_t current;
         volatile uint8_t notify;
     } nio_stages; //stages for network IO
-    int (*continue_callback)(struct fast_task_info *task);  //for continue stage
-    volatile int8_t reffer_count;
-    volatile int8_t canceled;   //if task canceled
-    int connect_timeout; //for client side
-    int network_timeout;
-	int64_t req_count; //request count
-	TaskFinishCallback finish_callback;
-	struct nio_thread_data *thread_data;
-	void *ctx;  //context pointer for libserverframe nio
-	struct fast_task_info *next;
+    volatile int8_t canceled;  //if task canceled
+    volatile int8_t shrinked;  //if task shrinked, since V1.0.81
+    volatile int reffer_count;
+    int pending_send_count;
+    int64_t req_count; //request count
+    struct {
+        int64_t  last_req_count;
+        uint32_t last_calc_time;
+        uint16_t continuous_count;
+        bool in_queue;
+        struct fc_list_head dlink;  //for polling queue
+    } polling;  //for RDMA busy polling
+    TaskContinueCallback continue_callback; //for continue stage
+    struct nio_thread_data *thread_data;
+    struct sf_network_handler *handler; //network handler for libserverframe nio
+    struct fast_task_info *next;        //for free queue and deleted list
+    struct fast_task_info *notify_next; //for nio notify queue
+    struct fast_task_queue *free_queue; //task allocator
+    char conn[0];    //for RDMA connection
 };
 
 struct fast_task_queue
 {
-	struct fast_task_info *head;
-	struct fast_task_info *tail;
-	pthread_mutex_t lock;
-	int max_connections;
-	int alloc_connections;
-	int alloc_task_once;
-	int min_buff_size;
-	int max_buff_size;
-	int arg_size;
-	int block_size;
-	bool malloc_whole_block;
+    int min_buff_size;
+    int max_buff_size;
+    int padding_size;   //for last field: conn[0]
+    int arg_size;       //for arg pointer
+    int block_size;
+    bool malloc_whole_block;
+    bool double_buffers;  //if send buffer and recv buffer are independent
+    bool need_shrink;
+    struct fast_mblock_man allocator;
     TaskInitCallback init_callback;
+    void *init_arg;
+    TaskReleaseCallback release_callback;
 };
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-int free_queue_init_ex2(const int max_connections, const int init_connections,
+int free_queue_init_ex2(struct fast_task_queue *queue, const char *name,
+        const bool double_buffers, const bool need_shrink,
+        const int max_connections, const int alloc_task_once,
+        const int min_buff_size, const int max_buff_size,
+        const int padding_size, const int arg_size,
+        TaskInitCallback init_callback, void *init_arg);
+
+static inline int free_queue_init_ex(struct fast_task_queue *queue,
+        const char *name, const bool double_buffers,
+        const bool need_shrink, const int max_connections,
         const int alloc_task_once, const int min_buff_size,
-        const int max_buff_size, const int arg_size,
-        TaskInitCallback init_callback);
-
-static inline int free_queue_init_ex(const int max_connections,
-        const int init_connections, const int alloc_task_once,
-        const int min_buff_size, const int max_buff_size, const int arg_size)
+        const int max_buff_size, const int arg_size)
 {
-    return free_queue_init_ex2(max_connections, init_connections,
-            alloc_task_once, min_buff_size, max_buff_size, arg_size, NULL);
+    const int padding_size = 0;
+    return free_queue_init_ex2(queue, name, double_buffers, need_shrink,
+            max_connections, alloc_task_once, min_buff_size, max_buff_size,
+            padding_size, arg_size, NULL, NULL);
 }
 
-static inline int free_queue_init(const int max_connections,
-        const int min_buff_size, const int max_buff_size, const int arg_size)
+static inline int free_queue_init(struct fast_task_queue *queue,
+        const int max_connections, const int alloc_task_once,
+        const int min_buff_size, const int max_buff_size)
 {
-    return free_queue_init_ex2(max_connections, max_connections,
-            0, min_buff_size, max_buff_size, arg_size, NULL);
+    const char *name = "";
+    const bool double_buffers = false;
+    const bool need_shrink = true;
+    const int arg_size = 0;
+    return free_queue_init_ex(queue, name, double_buffers,
+            need_shrink, max_connections, alloc_task_once,
+            min_buff_size, max_buff_size, arg_size);
 }
 
-void free_queue_destroy();
+static inline void free_queue_set_release_callback(
+        struct fast_task_queue *queue,
+        TaskReleaseCallback callback)
+{
+    queue->release_callback = callback;
+}
 
-int free_queue_push(struct fast_task_info *pTask);
-struct fast_task_info *free_queue_pop();
-int free_queue_count();
-int free_queue_alloc_connections();
-int free_queue_set_buffer_size(struct fast_task_info *pTask,
-        const int expect_size);
-int free_queue_realloc_buffer(struct fast_task_info *pTask,
-        const int expect_size);
+void free_queue_destroy(struct fast_task_queue *queue);
 
-int free_queue_set_max_buffer_size(struct fast_task_info *pTask);
+static inline struct fast_task_info *free_queue_pop(
+        struct fast_task_queue *queue)
+{
+    return (struct fast_task_info *)fast_mblock_alloc_object(&queue->allocator);
+}
 
-int free_queue_realloc_max_buffer(struct fast_task_info *pTask);
+void free_queue_push(struct fast_task_info *task);
 
-int task_queue_init(struct fast_task_queue *pQueue);
-int task_queue_push(struct fast_task_queue *pQueue, \
-		struct fast_task_info *pTask);
-struct fast_task_info *task_queue_pop(struct fast_task_queue *pQueue);
-int task_queue_count(struct fast_task_queue *pQueue);
-int task_queue_set_buffer_size(struct fast_task_queue *pQueue,
-        struct fast_task_info *pTask, const int expect_size);
-int task_queue_realloc_buffer(struct fast_task_queue *pQueue,
-        struct fast_task_info *pTask, const int expect_size);
+static inline int free_queue_count(struct fast_task_queue *queue)
+{
+    return queue->allocator.info.element_total_count -
+        queue->allocator.info.element_used_count;
+}
 
-int task_queue_get_new_buffer_size(const int min_buff_size,
+static inline int free_queue_alloc_connections(struct fast_task_queue *queue)
+{
+    return queue->allocator.info.element_total_count;
+}
+
+int free_queue_get_new_buffer_size(const int min_buff_size,
         const int max_buff_size, const int expect_size, int *new_size);
 
+int free_queue_set_buffer_size(struct fast_task_info *task,
+        struct fast_net_buffer *buffer, const int expect_size);
+
+static inline int free_queue_set_max_buffer_size(
+        struct fast_task_info *task,
+        struct fast_net_buffer *buffer)
+{
+    return free_queue_set_buffer_size(task, buffer,
+            task->free_queue->max_buff_size);
+}
+
+int free_queue_realloc_buffer(struct fast_task_info *task,
+        struct fast_net_buffer *buffer, const int expect_size);
+
+static inline int free_queue_realloc_max_buffer(
+        struct fast_task_info *task,
+        struct fast_net_buffer *buffer)
+{
+    return free_queue_realloc_buffer(task, buffer,
+            task->free_queue->max_buff_size);
+}
+
+/* send and recv buffer operations */
+static inline int free_queue_set_send_buffer_size(
+        struct fast_task_info *task, const int expect_size)
+{
+    return free_queue_set_buffer_size(task, task->send.ptr, expect_size);
+}
+
+static inline int free_queue_set_recv_buffer_size(
+        struct fast_task_info *task, const int expect_size)
+{
+    return free_queue_set_buffer_size(task, task->recv.ptr, expect_size);
+}
+
+static inline int free_queue_set_send_max_buffer_size(
+        struct fast_task_info *task)
+{
+    return free_queue_set_max_buffer_size(task, task->send.ptr);
+}
+
+static inline int free_queue_set_recv_max_buffer_size(
+        struct fast_task_info *task)
+{
+    return free_queue_set_max_buffer_size(task, task->recv.ptr);
+}
+
+static inline int free_queue_realloc_send_buffer(
+        struct fast_task_info *task, const int expect_size)
+{
+    return free_queue_realloc_buffer(task, task->send.ptr, expect_size);
+}
+
+static inline int free_queue_realloc_recv_buffer(
+        struct fast_task_info *task, const int expect_size)
+{
+    return free_queue_realloc_buffer(task, task->recv.ptr, expect_size);
+}
+
+static inline int free_queue_realloc_send_max_buffer(
+        struct fast_task_info *task)
+{
+    return free_queue_realloc_max_buffer(task, task->send.ptr);
+}
+
+static inline int free_queue_realloc_recv_max_buffer(
+        struct fast_task_info *task)
+{
+    return free_queue_realloc_max_buffer(task, task->recv.ptr);
+}
+
 #ifdef __cplusplus
 }
 #endif

src/fast_timer.c

@@ -105,6 +105,7 @@ int fast_timer_modify(FastTimer *timer, FastTimerEntry *entry,
         if ((result=fast_timer_remove(timer, entry)) == 0) {
             fast_timer_add_ex(timer, entry, new_expires, true);
         }
+
         return result;
     }
     return 0;
@@ -185,6 +186,7 @@ int fast_timer_timeouts_get(FastTimer *timer, const int64_t current_time,
                     } else {
                         last->rehash = false;
                     }
+
                     continue;
                 }
             } else {  //expired

src/fc_atomic.h

@@ -36,6 +36,7 @@ extern "C" {
         old_value = __sync_add_and_fetch(&var, 0); \
     } while (new_value != old_value)
 
+
 #define FC_ATOMIC_SET(var, new_value) \
     do { \
         typeof(var) _old_value;  \
@@ -48,6 +49,27 @@ extern "C" {
         } while (new_value != _old_value);  \
     } while (0)
 
+
+#define FC_ATOMIC_SET_BY_CONDITION(var, value, skip_operator) \
+    do { \
+        typeof(var) old;  \
+        old = __sync_add_and_fetch(&var, 0); \
+        if (value skip_operator old) { \
+            break; \
+        } \
+        if (__sync_bool_compare_and_swap(&var, old, value)) { \
+            break; \
+        } \
+    } while (1)
+
+
+#define FC_ATOMIC_SET_LARGER(var, value) \
+    FC_ATOMIC_SET_BY_CONDITION(var, value, <=)
+
+#define FC_ATOMIC_SET_SMALLER(var, value) \
+    FC_ATOMIC_SET_BY_CONDITION(var, value, >=)
+
+
 #ifdef __cplusplus
 }
 #endif

src/fc_list.h

@@ -45,6 +45,16 @@ fc_list_add_before (struct fc_list_head *_new, struct fc_list_head *current)
 	_new->next->prev = _new;
 }
 
+static inline void
+fc_list_add_after (struct fc_list_head *_new, struct fc_list_head *current)
+{
+    _new->prev = current;
+    _new->next = current->next;
+
+    current->next->prev = _new;
+    current->next = _new;
+}
+
 static inline void
 fc_list_add_internal (struct fc_list_head *_new, struct fc_list_head *prev,
         struct fc_list_head *next)

src/fc_queue.c

@@ -15,22 +15,14 @@
 
 //fc_queue.c
 
-#include <errno.h>
-#include <pthread.h>
-#include <inttypes.h>
-#include "logger.h"
-#include "shared_func.h"
 #include "pthread_func.h"
 #include "fc_queue.h"
 
-#define FC_QUEUE_NEXT_PTR(queue, data) \
-    *((void **)(((char *)data) + queue->next_ptr_offset))
-
 int fc_queue_init(struct fc_queue *queue, const int next_ptr_offset)
 {
 	int result;
 
-	if ((result=init_pthread_lock_cond_pair(&queue->lc_pair)) != 0)
+	if ((result=init_pthread_lock_cond_pair(&queue->lcp)) != 0)
 	{
 		return result;
 	}
@@ -43,12 +35,12 @@ int fc_queue_init(struct fc_queue *queue, const int next_ptr_offset)
 
 void fc_queue_destroy(struct fc_queue *queue)
 {
-    destroy_pthread_lock_cond_pair(&queue->lc_pair);
+    destroy_pthread_lock_cond_pair(&queue->lcp);
 }
 
 void fc_queue_push_ex(struct fc_queue *queue, void *data, bool *notify)
 {
-    PTHREAD_MUTEX_LOCK(&queue->lc_pair.lock);
+    PTHREAD_MUTEX_LOCK(&queue->lcp.lock);
 	FC_QUEUE_NEXT_PTR(queue, data) = NULL;
 	if (queue->tail == NULL) {
 		queue->head = data;
@@ -58,15 +50,58 @@ void fc_queue_push_ex(struct fc_queue *queue, void *data, bool *notify)
         *notify = false;
 	}
 	queue->tail = data;
+    PTHREAD_MUTEX_UNLOCK(&queue->lcp.lock);
+}
 
-    PTHREAD_MUTEX_UNLOCK(&queue->lc_pair.lock);
+static inline bool fc_queue_exists(struct fc_queue *queue, void *data)
+{
+    void *current;
+    if (queue->head == NULL) {
+        return false;
+    }
+
+    current = queue->head;
+    do {
+        if (current == data) {
+            return true;
+        }
+        current = FC_QUEUE_NEXT_PTR(queue, current);
+    } while (current != NULL);
+
+    return false;
+}
+
+int fc_queue_push_with_check_ex(struct fc_queue *queue,
+        void *data, bool *notify)
+{
+    int result;
+
+    PTHREAD_MUTEX_LOCK(&queue->lcp.lock);
+    if (fc_queue_exists(queue, data)) {
+        result = EEXIST;
+        *notify = false;
+    } else {
+        result = 0;
+        FC_QUEUE_NEXT_PTR(queue, data) = NULL;
+        if (queue->tail == NULL) {
+            queue->head = data;
+            *notify = true;
+        } else {
+            FC_QUEUE_NEXT_PTR(queue, queue->tail) = data;
+            *notify = false;
+        }
+        queue->tail = data;
+    }
+    PTHREAD_MUTEX_UNLOCK(&queue->lcp.lock);
+
+    return result;
 }
 
 void *fc_queue_pop_ex(struct fc_queue *queue, const bool blocked)
 {
 	void *data;
 
-    PTHREAD_MUTEX_LOCK(&queue->lc_pair.lock);
+    PTHREAD_MUTEX_LOCK(&queue->lcp.lock);
     do {
         data = queue->head;
         if (data == NULL) {
@@ -74,7 +109,7 @@ void *fc_queue_pop_ex(struct fc_queue *queue, const bool blocked)
                 break;
             }
 
-            pthread_cond_wait(&queue->lc_pair.cond, &queue->lc_pair.lock);
+            pthread_cond_wait(&queue->lcp.cond, &queue->lcp.lock);
             data = queue->head;
         }
 
@@ -86,7 +121,7 @@ void *fc_queue_pop_ex(struct fc_queue *queue, const bool blocked)
         }
     } while (0);
 
-    PTHREAD_MUTEX_UNLOCK(&queue->lc_pair.lock);
+    PTHREAD_MUTEX_UNLOCK(&queue->lcp.lock);
 	return data;
 }
 
@@ -94,7 +129,7 @@ void *fc_queue_pop_all_ex(struct fc_queue *queue, const bool blocked)
 {
 	void *data;
 
-    PTHREAD_MUTEX_LOCK(&queue->lc_pair.lock);
+    PTHREAD_MUTEX_LOCK(&queue->lcp.lock);
     do {
         data = queue->head;
         if (data == NULL) {
@@ -102,7 +137,7 @@ void *fc_queue_pop_all_ex(struct fc_queue *queue, const bool blocked)
                 break;
             }
 
-            pthread_cond_wait(&queue->lc_pair.cond, &queue->lc_pair.lock);
+            pthread_cond_wait(&queue->lcp.cond, &queue->lcp.lock);
             data = queue->head;
         }
 
@@ -111,7 +146,7 @@ void *fc_queue_pop_all_ex(struct fc_queue *queue, const bool blocked)
         }
     } while (0);
 
-    PTHREAD_MUTEX_UNLOCK(&queue->lc_pair.lock);
+    PTHREAD_MUTEX_UNLOCK(&queue->lcp.lock);
 	return data;
 }
 
@@ -123,7 +158,7 @@ void fc_queue_push_queue_to_head_ex(struct fc_queue *queue,
         return;
     }
 
-    PTHREAD_MUTEX_LOCK(&queue->lc_pair.lock);
+    PTHREAD_MUTEX_LOCK(&queue->lcp.lock);
     FC_QUEUE_NEXT_PTR(queue, qinfo->tail) = queue->head;
     queue->head = qinfo->head;
     if (queue->tail == NULL) {
@@ -132,13 +167,39 @@ void fc_queue_push_queue_to_head_ex(struct fc_queue *queue,
     } else {
         *notify = false;
     }
-    PTHREAD_MUTEX_UNLOCK(&queue->lc_pair.lock);
+    PTHREAD_MUTEX_UNLOCK(&queue->lcp.lock);
 }
 
-void fc_queue_pop_to_queue(struct fc_queue *queue,
-        struct fc_queue_info *qinfo)
+void fc_queue_push_queue_to_tail_ex(struct fc_queue *queue,
+        struct fc_queue_info *qinfo, bool *notify)
 {
-    PTHREAD_MUTEX_LOCK(&queue->lc_pair.lock);
+    if (qinfo->head == NULL) {
+        *notify = false;
+        return;
+    }
+
+    PTHREAD_MUTEX_LOCK(&queue->lcp.lock);
+    if (queue->head == NULL) {
+        queue->head = qinfo->head;
+        *notify = true;
+    } else {
+        FC_QUEUE_NEXT_PTR(queue, queue->tail) = qinfo->head;
+        *notify = false;
+    }
+    queue->tail = qinfo->tail;
+    PTHREAD_MUTEX_UNLOCK(&queue->lcp.lock);
+}
+
+void fc_queue_pop_to_queue_ex(struct fc_queue *queue,
+        struct fc_queue_info *qinfo, const bool blocked)
+{
+    PTHREAD_MUTEX_LOCK(&queue->lcp.lock);
+    if (queue->head == NULL) {
+        if (blocked) {
+            pthread_cond_wait(&queue->lcp.cond, &queue->lcp.lock);
+        }
+    }
+
     if (queue->head != NULL) {
         qinfo->head = queue->head;
         qinfo->tail = queue->tail;
@@ -146,5 +207,137 @@ void fc_queue_pop_to_queue(struct fc_queue *queue,
     } else {
         qinfo->head = qinfo->tail = NULL;
     }
-    PTHREAD_MUTEX_UNLOCK(&queue->lc_pair.lock);
+    PTHREAD_MUTEX_UNLOCK(&queue->lcp.lock);
+}
+
+void *fc_queue_timedpop(struct fc_queue *queue,
+        const int timeout, const int time_unit)
+{
+	void *data;
+
+    PTHREAD_MUTEX_LOCK(&queue->lcp.lock);
+    data = queue->head;
+    if (data == NULL) {
+        fc_cond_timedwait(&queue->lcp, timeout, time_unit);
+        data = queue->head;
+    }
+
+    if (data != NULL) {
+        queue->head = FC_QUEUE_NEXT_PTR(queue, data);
+        if (queue->head == NULL) {
+            queue->tail = NULL;
+        }
+    }
+    PTHREAD_MUTEX_UNLOCK(&queue->lcp.lock);
+
+	return data;
+}
+
+void *fc_queue_timedpeek(struct fc_queue *queue,
+        const int timeout, const int time_unit)
+{
+    void *data;
+
+    PTHREAD_MUTEX_LOCK(&queue->lcp.lock);
+    data = queue->head;
+    if (data == NULL) {
+        fc_cond_timedwait(&queue->lcp, timeout, time_unit);
+        data = queue->head;
+    }
+    PTHREAD_MUTEX_UNLOCK(&queue->lcp.lock);
+
+    return data;
+}
+
+int fc_queue_alloc_chain(struct fc_queue *queue, struct fast_mblock_man
+        *mblock, const int count, struct fc_queue_info *chain)
+{
+    struct fast_mblock_node *node;
+
+    if ((node=fast_mblock_batch_alloc1(mblock, count)) == NULL) {
+        chain->head = chain->tail = NULL;
+        return ENOMEM;
+    }
+
+    chain->head = chain->tail = node->data;
+    while ((node=node->next) != NULL) {
+        FC_QUEUE_NEXT_PTR(queue, chain->tail) = node->data;
+        chain->tail = node->data;
+    }
+    FC_QUEUE_NEXT_PTR(queue, chain->tail) = NULL;
+
+    return 0;
+}
+
+int fc_queue_free_chain(struct fc_queue *queue, struct fast_mblock_man
+        *mblock, struct fc_queue_info *qinfo)
+{
+    struct fast_mblock_node *previous;
+    struct fast_mblock_node *current;
+    struct fast_mblock_chain chain;
+    void *data;
+
+    if (qinfo->head == NULL) {
+        return 0;
+    }
+
+    chain.head = previous = fast_mblock_to_node_ptr(qinfo->head);
+    data = FC_QUEUE_NEXT_PTR(queue, qinfo->head);
+    while (data != NULL) {
+        current = fast_mblock_to_node_ptr(data);
+        previous->next = current;
+
+        previous = current;
+        data = FC_QUEUE_NEXT_PTR(queue, data);
+    }
+
+    previous->next = NULL;
+    chain.tail = previous;
+    return fast_mblock_batch_free(mblock, &chain);
+}
+
+int fc_queue_remove(struct fc_queue *queue, void *data)
+{
+    void *previous;
+    void *current;
+    int result;
+
+    pthread_mutex_lock(&queue->lcp.lock);
+    if (queue->head == NULL)
+    {
+        result = ENOENT;
+    }
+    else if (queue->head == data)
+    {
+        queue->head = FC_QUEUE_NEXT_PTR(queue, queue->head);
+        if (queue->head == NULL)
+        {
+            queue->tail = NULL;
+        }
+        result = 0;
+    }
+    else
+    {
+        result = ENOENT;
+        previous = queue->head;
+        while ((current=FC_QUEUE_NEXT_PTR(queue, previous)) != NULL)
+        {
+            if (current == data)
+            {
+                FC_QUEUE_NEXT_PTR(queue, previous) =
+                    FC_QUEUE_NEXT_PTR(queue, current);
+                if (queue->tail == current)
+                {
+                    queue->tail = previous;
+                }
+                result = 0;
+                break;
+            }
+
+            previous = current;
+        }
+    }
+    pthread_mutex_unlock(&queue->lcp.lock);
+
+    return result;
 }

src/fc_queue.h

@@ -18,11 +18,8 @@
 #ifndef _FC_QUEUE_H
 #define _FC_QUEUE_H
 
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <pthread.h>
 #include "common_define.h"
+#include "fast_mblock.h"
 
 struct fc_queue_info
 {
@@ -34,10 +31,14 @@ struct fc_queue
 {
 	void *head;
 	void *tail;
-    pthread_lock_cond_pair_t lc_pair;
+    pthread_lock_cond_pair_t lcp;
     int next_ptr_offset;
 };
 
+
+#define FC_QUEUE_NEXT_PTR(queue, data) \
+    *((void **)(((char *)data) + (queue)->next_ptr_offset))
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -48,7 +49,7 @@ void fc_queue_destroy(struct fc_queue *queue);
 
 static inline void fc_queue_terminate(struct fc_queue *queue)
 {
-    pthread_cond_signal(&queue->lc_pair.cond);
+    pthread_cond_signal(&queue->lcp.cond);
 }
 
 static inline void fc_queue_terminate_all(
@@ -56,12 +57,19 @@ static inline void fc_queue_terminate_all(
 {
     int i;
     for (i=0; i<count; i++) {
-        pthread_cond_signal(&(queue->lc_pair.cond));
+        pthread_cond_signal(&(queue->lcp.cond));
     }
 }
 
+#define fc_queue_notify(queue) fc_queue_terminate(queue)
+
+#define fc_queue_notify_all(queue, count) \
+    fc_queue_terminate_all(queue, count)
+
 //notify by the caller
 void fc_queue_push_ex(struct fc_queue *queue, void *data, bool *notify);
+int fc_queue_push_with_check_ex(struct fc_queue *queue,
+        void *data, bool *notify);
 
 static inline void fc_queue_push(struct fc_queue *queue, void *data)
 {
@@ -69,10 +77,23 @@ static inline void fc_queue_push(struct fc_queue *queue, void *data)
 
     fc_queue_push_ex(queue, data, &notify);
     if (notify) {
-        pthread_cond_signal(&(queue->lc_pair.cond));
+        pthread_cond_signal(&(queue->lcp.cond));
     }
 }
 
+static inline int fc_queue_push_with_check(struct fc_queue *queue, void *data)
+{
+    int result;
+    bool notify;
+
+    result = fc_queue_push_with_check_ex(queue, data, &notify);
+    if (notify) {
+        pthread_cond_signal(&(queue->lcp.cond));
+    }
+
+    return result;
+}
+
 static inline void fc_queue_push_silence(struct fc_queue *queue, void *data)
 {
     bool notify;
@@ -89,10 +110,38 @@ static inline void fc_queue_push_queue_to_head(struct fc_queue *queue,
 
     fc_queue_push_queue_to_head_ex(queue, qinfo, &notify);
     if (notify) {
-        pthread_cond_signal(&(queue->lc_pair.cond));
+        pthread_cond_signal(&(queue->lcp.cond));
     }
 }
 
+static inline void fc_queue_push_queue_to_head_silence(
+        struct fc_queue *queue, struct fc_queue_info *qinfo)
+{
+    bool notify;
+    fc_queue_push_queue_to_head_ex(queue, qinfo, &notify);
+}
+
+void fc_queue_push_queue_to_tail_ex(struct fc_queue *queue,
+        struct fc_queue_info *qinfo, bool *notify);
+
+static inline void fc_queue_push_queue_to_tail(struct fc_queue *queue,
+        struct fc_queue_info *qinfo)
+{
+    bool notify;
+
+    fc_queue_push_queue_to_tail_ex(queue, qinfo, &notify);
+    if (notify) {
+        pthread_cond_signal(&(queue->lcp.cond));
+    }
+}
+
+static inline void fc_queue_push_queue_to_tail_silence(
+        struct fc_queue *queue, struct fc_queue_info *qinfo)
+{
+    bool notify;
+    fc_queue_push_queue_to_tail_ex(queue, qinfo, &notify);
+}
+
 void *fc_queue_pop_ex(struct fc_queue *queue, const bool blocked);
 #define fc_queue_pop(queue) fc_queue_pop_ex(queue, true)
 #define fc_queue_try_pop(queue) fc_queue_pop_ex(queue, false)
@@ -101,19 +150,84 @@ void *fc_queue_pop_all_ex(struct fc_queue *queue, const bool blocked);
 #define fc_queue_pop_all(queue) fc_queue_pop_all_ex(queue, true)
 #define fc_queue_try_pop_all(queue) fc_queue_pop_all_ex(queue, false)
 
-void fc_queue_pop_to_queue(struct fc_queue *queue,
-        struct fc_queue_info *qinfo);
+void fc_queue_pop_to_queue_ex(struct fc_queue *queue,
+        struct fc_queue_info *qinfo, const bool blocked);
+
+#define fc_queue_pop_to_queue(queue, qinfo) \
+    fc_queue_pop_to_queue_ex(queue, qinfo, true)
+
+#define fc_queue_try_pop_to_queue(queue, qinfo) \
+    fc_queue_pop_to_queue_ex(queue, qinfo, false)
 
 static inline bool fc_queue_empty(struct fc_queue *queue)
 {
     bool empty;
 
-    pthread_mutex_lock(&queue->lc_pair.lock);
+    pthread_mutex_lock(&queue->lcp.lock);
     empty = (queue->head == NULL);
-    pthread_mutex_unlock(&queue->lc_pair.lock);
+    pthread_mutex_unlock(&queue->lcp.lock);
     return empty;
 }
 
+static inline int fc_queue_count(struct fc_queue *queue)
+{
+    int count;
+    void *data;
+
+    count = 0;
+    pthread_mutex_lock(&queue->lcp.lock);
+    data = queue->head;
+    while (data != NULL)
+    {
+        ++count;
+        data = FC_QUEUE_NEXT_PTR(queue, data);
+    }
+    pthread_mutex_unlock(&queue->lcp.lock);
+    return count;
+}
+
+static inline void *fc_queue_peek(struct fc_queue *queue)
+{
+    void *data;
+
+    pthread_mutex_lock(&queue->lcp.lock);
+    data = queue->head;
+    pthread_mutex_unlock(&queue->lcp.lock);
+    return data;
+}
+
+void *fc_queue_timedpop(struct fc_queue *queue,
+        const int timeout, const int time_unit);
+
+#define fc_queue_timedpop_sec(queue, timeout) \
+    fc_queue_timedpop(queue, timeout, FC_TIME_UNIT_SECOND)
+
+#define fc_queue_timedpop_ms(queue, timeout_ms) \
+    fc_queue_timedpop(queue, timeout_ms, FC_TIME_UNIT_MSECOND)
+
+#define fc_queue_timedpop_us(queue, timeout_us) \
+    fc_queue_timedpop(queue, timeout_us, FC_TIME_UNIT_USECOND)
+
+void *fc_queue_timedpeek(struct fc_queue *queue,
+        const int timeout, const int time_unit);
+
+#define fc_queue_timedpeek_sec(queue, timeout) \
+    fc_queue_timedpeek(queue, timeout, FC_TIME_UNIT_SECOND)
+
+#define fc_queue_timedpeek_ms(queue, timeout_ms) \
+    fc_queue_timedpeek(queue, timeout_ms, FC_TIME_UNIT_MSECOND)
+
+#define fc_queue_timedpeek_us(queue, timeout_us) \
+    fc_queue_timedpeek(queue, timeout_us, FC_TIME_UNIT_USECOND)
+
+int fc_queue_alloc_chain(struct fc_queue *queue, struct fast_mblock_man
+        *mblock, const int count, struct fc_queue_info *chain);
+
+int fc_queue_free_chain(struct fc_queue *queue, struct fast_mblock_man
+        *mblock, struct fc_queue_info *qinfo);
+
+int fc_queue_remove(struct fc_queue *queue, void *data);
+
 #ifdef __cplusplus
 }
 #endif

src/hash.c

@@ -79,7 +79,7 @@ static int _hash_alloc_buckets(HashArray *pHash, const unsigned int old_capacity
 	return 0;
 }
 
-unsigned int *hash_get_prime_capacity(const int capacity)
+unsigned int *fc_hash_get_prime_capacity(const int capacity)
 {
 	unsigned int *pprime;
 	unsigned int *prime_end;
@@ -95,14 +95,14 @@ unsigned int *hash_get_prime_capacity(const int capacity)
     return NULL;
 }
 
-int hash_init_ex(HashArray *pHash, HashFunc hash_func, \
+int fc_hash_init_ex(HashArray *pHash, HashFunc hash_func, \
 		const unsigned int capacity, const double load_factor, \
 		const int64_t max_bytes, const bool bMallocValue)
 {
 	int result;
 
 	memset(pHash, 0, sizeof(HashArray));
-    pHash->capacity = hash_get_prime_capacity(capacity);
+    pHash->capacity = fc_hash_get_prime_capacity(capacity);
 	if (pHash->capacity == NULL)
 	{
 		return EINVAL;
@@ -129,7 +129,7 @@ int hash_init_ex(HashArray *pHash, HashFunc hash_func, \
 	return 0;
 }
 
-int hash_set_locks(HashArray *pHash, const int lock_count)
+int fc_hash_set_locks(HashArray *pHash, const int lock_count)
 {
 	size_t bytes;
 	pthread_mutex_t *lock;
@@ -168,7 +168,7 @@ int hash_set_locks(HashArray *pHash, const int lock_count)
 	return 0;
 }
 
-void hash_destroy(HashArray *pHash)
+void fc_hash_destroy(HashArray *pHash)
 {
 	HashData **ppBucket;
 	HashData **bucket_end;
@@ -238,7 +238,7 @@ void hash_destroy(HashArray *pHash)
 	}
 
 
-int hash_stat(HashArray *pHash, HashStat *pStat, \
+int fc_hash_stat(HashArray *pHash, HashStat *pStat, \
 		int *stat_by_lens, const int stat_size)
 {
 	HashData **ppBucket;
@@ -299,13 +299,13 @@ int hash_stat(HashArray *pHash, HashStat *pStat, \
 	return 0;
 }
 
-void hash_stat_print(HashArray *pHash)
+void fc_hash_stat_print(HashArray *pHash)
 {
 #define STAT_MAX_NUM  64
 	HashStat hs;
 	int stats[STAT_MAX_NUM];
 
-	if (hash_stat(pHash, &hs, stats, STAT_MAX_NUM) != 0)
+	if (fc_hash_stat(pHash, &hs, stats, STAT_MAX_NUM) != 0)
 	{
 		printf("hash max length exceeds %d!\n", STAT_MAX_NUM);
 		return;
@@ -381,7 +381,7 @@ static int _rehash(HashArray *pHash)
 	pOldCapacity = pHash->capacity;
 	if (pHash->is_malloc_capacity)
 	{
-        pHash->capacity = hash_get_prime_capacity(*pOldCapacity);
+        pHash->capacity = fc_hash_get_prime_capacity(*pOldCapacity);
 	}
 	else
 	{
@@ -456,7 +456,7 @@ static int _hash_conflict_count(HashArray *pHash)
 	return conflict_count;
 }
 
-int hash_best_op(HashArray *pHash, const int suggest_capacity)
+int fc_hash_best_op(HashArray *pHash, const int suggest_capacity)
 {
 	int old_capacity;
 	int conflict_count;
@@ -513,7 +513,7 @@ int hash_best_op(HashArray *pHash, const int suggest_capacity)
 
 	pHash->is_malloc_capacity = true;
 
-	//hash_stat_print(pHash);
+	//fc_hash_stat_print(pHash);
 	return 1;
 }
 
@@ -537,7 +537,7 @@ static HashData *_chain_find_entry(HashData **ppBucket, const void *key, \
 	return NULL;
 }
 
-HashData *hash_find_ex(HashArray *pHash, const void *key, const int key_len)
+HashData *fc_hash_find_ex(HashArray *pHash, const void *key, const int key_len)
 {
 	unsigned int hash_code;
 	HashData **ppBucket;
@@ -553,7 +553,7 @@ HashData *hash_find_ex(HashArray *pHash, const void *key, const int key_len)
 	return hash_data;
 }
 
-void *hash_find(HashArray *pHash, const void *key, const int key_len)
+void *fc_hash_find(HashArray *pHash, const void *key, const int key_len)
 {
 	unsigned int hash_code;
 	HashData **ppBucket;
@@ -576,10 +576,10 @@ void *hash_find(HashArray *pHash, const void *key, const int key_len)
 	}
 }
 
-int hash_find2(HashArray *pHash, const string_t *key, string_t *value)
+int fc_hash_find2(HashArray *pHash, const string_t *key, string_t *value)
 {
     HashData *hdata;
-    if ((hdata=hash_find1_ex(pHash, key)) == NULL)
+    if ((hdata=fc_hash_find1_ex(pHash, key)) == NULL)
     {
         return ENOENT;
     }
@@ -589,12 +589,12 @@ int hash_find2(HashArray *pHash, const string_t *key, string_t *value)
     return 0;
 }
 
-HashData *hash_find1_ex(HashArray *pHash, const string_t *key)
+HashData *fc_hash_find1_ex(HashArray *pHash, const string_t *key)
 {
-    return hash_find_ex(pHash, key->str, key->len);
+    return fc_hash_find_ex(pHash, key->str, key->len);
 }
 
-int hash_get(HashArray *pHash, const void *key, const int key_len,
+int fc_hash_get(HashArray *pHash, const void *key, const int key_len,
 	void *value, int *value_len)
 {
 	unsigned int hash_code;
@@ -628,7 +628,7 @@ int hash_get(HashArray *pHash, const void *key, const int key_len,
 	return result;
 }
 
-int hash_insert_ex(HashArray *pHash, const void *key, const int key_len, \
+int fc_hash_insert_ex(HashArray *pHash, const void *key, const int key_len,
 		void *value, const int value_len, const bool needLock)
 {
 	unsigned int hash_code;
@@ -760,7 +760,7 @@ int hash_insert_ex(HashArray *pHash, const void *key, const int key_len, \
 	return 1;
 }
 
-int64_t hash_inc_value(const HashData *old_data, const int inc,
+int64_t fc_hash_inc_value(const HashData *old_data, const int inc,
 	char *new_value, int *new_value_len, void *arg)
 {
 	int64_t n;
@@ -768,27 +768,26 @@ int64_t hash_inc_value(const HashData *old_data, const int inc,
 	{
 		if (old_data->value_len < *new_value_len)
 		{
-			memcpy(new_value, old_data->value, old_data->value_len);
-                        new_value[old_data->value_len] = '\0';
-                        n = strtoll(new_value, NULL, 10);
-                        n += inc;
+            memcpy(new_value, old_data->value, old_data->value_len);
+            new_value[old_data->value_len] = '\0';
+            n = strtoll(new_value, NULL, 10);
+            n += inc;
 		}
 		else
 		{
 			n = inc;
 		}
-		*new_value_len = sprintf(new_value, "%"PRId64, n);
 	}
 	else
 	{
 		n = inc;
-		*new_value_len = sprintf(new_value, "%"PRId64, n);
 	}
 
+    *new_value_len = fc_itoa(n, new_value);
 	return n;
 }
 
-int hash_inc_ex(HashArray *pHash, const void *key, const int key_len,
+int fc_hash_inc_ex(HashArray *pHash, const void *key, const int key_len,
 		const int inc, char *value, int *value_len,
 		ConvertValueFunc convert_func, void *arg)
 {
@@ -823,7 +822,7 @@ int hash_inc_ex(HashArray *pHash, const void *key, const int key_len,
 			}
 		}
 	}
-	result = hash_insert_ex(pHash, key, key_len, value, *value_len, false);
+	result = fc_hash_insert_ex(pHash, key, key_len, value, *value_len, false);
 	if (result < 0)
 	{
 		*value = '\0';
@@ -839,7 +838,7 @@ int hash_inc_ex(HashArray *pHash, const void *key, const int key_len,
 	return result;
 }
 
-int hash_partial_set(HashArray *pHash, const void *key, const int key_len,
+int fc_hash_partial_set(HashArray *pHash, const void *key, const int key_len,
 		const char *value, const int offset, const int value_len)
 {
 	unsigned int hash_code;
@@ -881,7 +880,7 @@ int hash_partial_set(HashArray *pHash, const void *key, const int key_len,
 				memcpy(pNewBuff, hash_data->value, offset);
 			}
 			memcpy(pNewBuff + offset, value, value_len);
-			result = hash_insert_ex(pHash, key, key_len, pNewBuff,
+			result = fc_hash_insert_ex(pHash, key, key_len, pNewBuff,
 				offset + value_len, false);
 			free(pNewBuff);
 		}
@@ -892,8 +891,8 @@ int hash_partial_set(HashArray *pHash, const void *key, const int key_len,
 				result = ENOENT;
 				break;
 			}
-			result = hash_insert_ex(pHash, key, key_len, (void *)value,
-				value_len, false);
+			result = fc_hash_insert_ex(pHash, key, key_len,
+                    (void *)value, value_len, false);
 		}
 
 		if (result < 0)
@@ -910,7 +909,7 @@ int hash_partial_set(HashArray *pHash, const void *key, const int key_len,
 	return result;
 }
 
-int hash_delete(HashArray *pHash, const void *key, const int key_len)
+int fc_hash_delete(HashArray *pHash, const void *key, const int key_len)
 {
 	HashData **ppBucket;
 	HashData *hash_data;
@@ -943,7 +942,7 @@ int hash_delete(HashArray *pHash, const void *key, const int key_len)
 	return result;
 }
 
-int hash_walk(HashArray *pHash, HashWalkFunc walkFunc, void *args)
+int fc_hash_walk(HashArray *pHash, HashWalkFunc walkFunc, void *args)
 {
 	HashData **ppBucket;
 	HashData **bucket_end;
@@ -972,12 +971,12 @@ int hash_walk(HashArray *pHash, HashWalkFunc walkFunc, void *args)
 	return 0;
 }
 
-int hash_count(HashArray *pHash)
+int fc_hash_count(HashArray *pHash)
 {
 	return pHash->item_count;
 }
 
-int hash_bucket_lock(HashArray *pHash, const unsigned int bucket_index)
+int fc_hash_bucket_lock(HashArray *pHash, const unsigned int bucket_index)
 {
 	if (pHash->lock_count <= 0)
 	{
@@ -988,7 +987,7 @@ int hash_bucket_lock(HashArray *pHash, const unsigned int bucket_index)
 			pHash->lock_count);
 }
 
-int hash_bucket_unlock(HashArray *pHash, const unsigned int bucket_index)
+int fc_hash_bucket_unlock(HashArray *pHash, const unsigned int bucket_index)
 {
 	if (pHash->lock_count <= 0)
 	{
@@ -1315,12 +1314,12 @@ int calc_hashnr1_ex(const void* key, const int key_len, \
  \
   return h; \
 
-int simple_hash(const void* key, const int key_len)
+int fc_simple_hash(const void* key, const int key_len)
 {
 	SIMPLE_HASH_FUNC(0)
 }
 
-int simple_hash_ex(const void* key, const int key_len, \
+int fc_simple_hash_ex(const void* key, const int key_len, \
 	const int init_value)
 {
 	SIMPLE_HASH_FUNC(init_value)

src/hash.h

@@ -93,16 +93,16 @@ typedef struct tagHashStat
  * parameters:
  *         index: item index based 0
  *         data: hash data, including key and value
- *         args: passed by hash_walk function
+ *         args: passed by fc_hash_walk function
  * return 0 for success, != 0 for error
 */
 typedef int (*HashWalkFunc)(const int index, const HashData *data, void *args);
 
-#define hash_init(pHash, hash_func, capacity, load_factor) \
-	hash_init_ex(pHash, hash_func, capacity, load_factor, 0, false)
+#define fc_hash_init(pHash, hash_func, capacity, load_factor) \
+	fc_hash_init_ex(pHash, hash_func, capacity, load_factor, 0, false)
 
-#define hash_insert(pHash, key, key_len, value) \
-	hash_insert_ex(pHash, key, key_len, value, 0, true)
+#define fc_hash_insert(pHash, key, key_len, value) \
+	fc_hash_insert_ex(pHash, key, key_len, value, 0, true)
 
 /**
  * hash init function
@@ -115,7 +115,7 @@ typedef int (*HashWalkFunc)(const int index, const HashData *data, void *args);
  *         bMallocValue: if need malloc value buffer
  * return 0 for success, != 0 for error
 */
-int hash_init_ex(HashArray *pHash, HashFunc hash_func, \
+int fc_hash_init_ex(HashArray *pHash, HashFunc hash_func, \
 		const unsigned int capacity, const double load_factor, \
 		const int64_t max_bytes, const bool bMallocValue);
 
@@ -125,7 +125,7 @@ int hash_init_ex(HashArray *pHash, HashFunc hash_func, \
  *         lock_count: the lock count
  * return 0 for success, != 0 for error
 */
-int hash_set_locks(HashArray *pHash, const int lock_count);
+int fc_hash_set_locks(HashArray *pHash, const int lock_count);
 
 /**
  * convert the value
@@ -137,12 +137,12 @@ int hash_set_locks(HashArray *pHash, const int lock_count);
  *         arg: the user data
  * return the number after increasement
 */
-int64_t hash_inc_value(const HashData *old_data, const int inc,
+int64_t fc_hash_inc_value(const HashData *old_data, const int inc,
 	char *new_value, int *new_value_len, void *arg);
 
-#define hash_inc(pHash, key, key_len, inc, value, value_len) \
-	hash_inc_ex(pHash, key, key_len, inc, value, value_len, \
-		hash_inc_value, NULL)
+#define fc_hash_inc(pHash, key, key_len, inc, value, value_len) \
+	fc_hash_inc_ex(pHash, key, key_len, inc, value, value_len, \
+		fc_hash_inc_value, NULL)
 
 /**
  * atomic increase value
@@ -158,7 +158,7 @@ int64_t hash_inc_value(const HashData *old_data, const int inc,
  * return  0 for success, != 0 for error (errno)
  *
 */
-int  hash_inc_ex(HashArray *pHash, const void *key, const int key_len,
+int  fc_hash_inc_ex(HashArray *pHash, const void *key, const int key_len,
 		const int inc, char *value, int *value_len,
 		ConvertValueFunc convert_func, void *arg);
 
@@ -168,7 +168,7 @@ int  hash_inc_ex(HashArray *pHash, const void *key, const int key_len,
  *         pHash: the hash table
  * return none
 */
-void hash_destroy(HashArray *pHash);
+void fc_hash_destroy(HashArray *pHash);
 
 /**
  * hash insert key
@@ -182,7 +182,7 @@ void hash_destroy(HashArray *pHash);
  * return >= 0 for success, 0 for key already exist (update), 
  *        1 for new key (insert), < 0 for error
 */
-int hash_insert_ex(HashArray *pHash, const void *key, const int key_len, \
+int fc_hash_insert_ex(HashArray *pHash, const void *key, const int key_len, \
 		void *value, const int value_len, const bool needLock);
 
 /**
@@ -193,7 +193,7 @@ int hash_insert_ex(HashArray *pHash, const void *key, const int key_len, \
  *         key_len: length of th key 
  * return user data, return NULL when the key not exist
 */
-void *hash_find(HashArray *pHash, const void *key, const int key_len);
+void *fc_hash_find(HashArray *pHash, const void *key, const int key_len);
 
 /**
  * hash find key
@@ -203,7 +203,7 @@ void *hash_find(HashArray *pHash, const void *key, const int key_len);
  *         key_len: length of th key 
  * return hash data, return NULL when the key not exist
 */
-HashData *hash_find_ex(HashArray *pHash, const void *key, const int key_len);
+HashData *fc_hash_find_ex(HashArray *pHash, const void *key, const int key_len);
 
 /**
  * hash find key
@@ -212,9 +212,9 @@ HashData *hash_find_ex(HashArray *pHash, const void *key, const int key_len);
  *         key: the key to find
  * return user data, return NULL when the key not exist
 */
-static inline void *hash_find1(HashArray *pHash, const string_t *key)
+static inline void *fc_hash_find1(HashArray *pHash, const string_t *key)
 {
-    return hash_find(pHash, key->str, key->len);
+    return fc_hash_find(pHash, key->str, key->len);
 }
 
 /**
@@ -225,7 +225,7 @@ static inline void *hash_find1(HashArray *pHash, const string_t *key)
  *         value: store the value
  * return 0 for success, != 0 fail (errno)
 */
-int hash_find2(HashArray *pHash, const string_t *key, string_t *value);
+int fc_hash_find2(HashArray *pHash, const string_t *key, string_t *value);
 
 /**
  * hash find key
@@ -234,7 +234,7 @@ int hash_find2(HashArray *pHash, const string_t *key, string_t *value);
  *         key: the key to find
  * return hash data, return NULL when the key not exist
 */
-HashData *hash_find1_ex(HashArray *pHash, const string_t *key);
+HashData *fc_hash_find1_ex(HashArray *pHash, const string_t *key);
 
 /**
  * hash get the value of the key
@@ -247,7 +247,7 @@ HashData *hash_find1_ex(HashArray *pHash, const string_t *key);
  *                    output for the length fo the value
  * return 0 for success, != 0 fail (errno)
 */
-int hash_get(HashArray *pHash, const void *key, const int key_len,
+int fc_hash_get(HashArray *pHash, const void *key, const int key_len,
 	void *value, int *value_len);
 
 
@@ -262,7 +262,7 @@ int hash_get(HashArray *pHash, const void *key, const int key_len,
  *         value_len: length of the value
  * return 0 for success, != 0 fail (errno)
 */
-int hash_partial_set(HashArray *pHash, const void *key, const int key_len,
+int fc_hash_partial_set(HashArray *pHash, const void *key, const int key_len,
 		const char *value, const int offset, const int value_len);
 
 /**
@@ -273,7 +273,7 @@ int hash_partial_set(HashArray *pHash, const void *key, const int key_len,
  *         key_len: length of th key 
  * return 0 for success, != 0 fail (errno)
 */
-int hash_delete(HashArray *pHash, const void *key, const int key_len);
+int fc_hash_delete(HashArray *pHash, const void *key, const int key_len);
 
 /**
  * hash walk (iterator)
@@ -283,7 +283,7 @@ int hash_delete(HashArray *pHash, const void *key, const int key_len);
  *         args: extra args which will be passed to walkFunc
  * return 0 for success, != 0 fail (errno)
 */
-int hash_walk(HashArray *pHash, HashWalkFunc walkFunc, void *args);
+int fc_hash_walk(HashArray *pHash, HashWalkFunc walkFunc, void *args);
 
 /**
  * get hash item count
@@ -291,7 +291,7 @@ int hash_walk(HashArray *pHash, HashWalkFunc walkFunc, void *args);
  *         pHash: the hash table
  * return item count
 */
-int hash_count(HashArray *pHash);
+int fc_hash_count(HashArray *pHash);
 
 /**
  * hash best optimize
@@ -300,7 +300,7 @@ int hash_count(HashArray *pHash);
  *         suggest_capacity: suggest init capacity for speed
  * return >0 for success, < 0 fail (errno)
 */
-int hash_best_op(HashArray *pHash, const int suggest_capacity);
+int fc_hash_best_op(HashArray *pHash, const int suggest_capacity);
 
 /**
  * hash stat
@@ -314,7 +314,7 @@ int hash_best_op(HashArray *pHash, const int suggest_capacity);
  *         stat_size: stats array size (contain max elments)
  * return 0 for success, != 0 fail (errno)
 */
-int hash_stat(HashArray *pHash, HashStat *pStat, \
+int fc_hash_stat(HashArray *pHash, HashStat *pStat, \
 		int *stat_by_lens, const int stat_size);
 
 /**
@@ -323,7 +323,7 @@ int hash_stat(HashArray *pHash, HashStat *pStat, \
  *         pHash: the hash table
  * return none
 */
-void hash_stat_print(HashArray *pHash);
+void fc_hash_stat_print(HashArray *pHash);
 
 /**
  * lock the bucket of hash table
@@ -332,7 +332,7 @@ void hash_stat_print(HashArray *pHash);
  *         bucket_index: the index of bucket
  * return 0 for success, != 0 fail (errno)
 */
-int hash_bucket_lock(HashArray *pHash, const unsigned int bucket_index);
+int fc_hash_bucket_lock(HashArray *pHash, const unsigned int bucket_index);
 
 /**
  * unlock the bucket of hash table
@@ -341,7 +341,7 @@ int hash_bucket_lock(HashArray *pHash, const unsigned int bucket_index);
  *         bucket_index: the index of bucket
  * return 0 for success, != 0 fail (errno)
 */
-int hash_bucket_unlock(HashArray *pHash, const unsigned int bucket_index);
+int fc_hash_bucket_unlock(HashArray *pHash, const unsigned int bucket_index);
 
 int RSHash(const void *key, const int key_len);
 
@@ -383,8 +383,8 @@ int calc_hashnr1(const void* key, const int key_len);
 int calc_hashnr1_ex(const void* key, const int key_len, \
 	const int init_value);
 
-int simple_hash(const void* key, const int key_len);
-int simple_hash_ex(const void* key, const int key_len, \
+int fc_simple_hash(const void* key, const int key_len);
+int fc_simple_hash_ex(const void* key, const int key_len, \
 	const int init_value);
 
 int CRC32(const void *key, const int key_len);
@@ -402,7 +402,7 @@ int64_t CRC32_ex(const void *key, const int key_len, \
 #define CALC_HASH_CODES4(buff, buff_len, hash_codes) \
 	hash_codes[0] = CRC32_ex(buff, buff_len, hash_codes[0]); \
 	hash_codes[1] = ELFHash_ex(buff, buff_len, hash_codes[1]); \
-	hash_codes[2] = simple_hash_ex(buff, buff_len, hash_codes[2]); \
+	hash_codes[2] = fc_simple_hash_ex(buff, buff_len, hash_codes[2]); \
 	hash_codes[3] = Time33Hash_ex(buff, buff_len, hash_codes[3]); \
 
 
@@ -410,7 +410,7 @@ int64_t CRC32_ex(const void *key, const int key_len, \
 	hash_codes[0] = CRC32_FINAL(hash_codes[0]); \
 
 
-unsigned int *hash_get_prime_capacity(const int capacity);
+unsigned int *fc_hash_get_prime_capacity(const int capacity);
 
 #ifdef __cplusplus
 }

src/http_func.c

@@ -39,6 +39,131 @@
 #include "fc_memory.h"
 #include "http_func.h"
 
+#ifdef USE_LIBCURL
+#include <curl/curl.h>
+
+static bool curl_inited = false;
+
+typedef struct {
+    char *buff;
+    int length;
+    int alloc_size;
+    bool dynamic_alloc;
+} CurlCallbackArg;
+
+static size_t curl_write_data(void *ptr, size_t size,
+        size_t nmemb, void *userdata)
+{
+    size_t len;
+    int alloc_size;
+    char *new_buff;
+    CurlCallbackArg *cbarg;
+
+    cbarg = (CurlCallbackArg *)userdata;
+    len = size * nmemb;
+    if ((cbarg->alloc_size - cbarg->length) < len) {
+        if (!cbarg->dynamic_alloc) {
+            return 0;
+        }
+
+        alloc_size = 2 * cbarg->alloc_size;
+        while ((alloc_size - cbarg->length) < len) {
+            alloc_size *= 2;
+        }
+
+        new_buff = (char *)fc_malloc(alloc_size);
+        if (new_buff == NULL) {
+            return 0;
+        }
+
+        if (cbarg->length > 0) {
+            memcpy(new_buff, cbarg->buff, cbarg->length);
+        }
+        free(cbarg->buff);
+
+        cbarg->buff = new_buff;
+        cbarg->alloc_size = alloc_size;
+    }
+
+    memcpy(cbarg->buff + cbarg->length, ptr, len);
+    cbarg->length += len;
+    return len;
+}
+
+int get_url_content_ex(const char *url, const int url_len,
+        const int connect_timeout, const int network_timeout,
+        int *http_status, char **content, int *content_len,
+        char *error_info)
+{
+    CURLcode result;
+    long response_code;
+    CURL *curl;
+    CurlCallbackArg cbarg;
+
+    *error_info = '\0';
+	*http_status = 0;
+    if (!curl_inited) {
+        if ((result=curl_global_init(CURL_GLOBAL_ALL)) != 0) {
+            sprintf(error_info, "curl_global_init fail "
+                    "with code: %d", result);
+            return errno != 0 ? errno : EBUSY;
+        }
+        curl_inited = true;
+    }
+
+    if ((curl=curl_easy_init()) == NULL) {
+        sprintf(error_info, "curl_easy_init fail");
+        return errno != 0 ? errno : EBUSY;
+    }
+
+    if (*content == NULL) {
+        cbarg.dynamic_alloc = true;
+        cbarg.alloc_size = 16 * 1024;
+        cbarg.buff = (char *)fc_malloc(cbarg.alloc_size);
+        if (cbarg.buff == NULL) {
+            return ENOMEM;
+        }
+    } else {
+        cbarg.dynamic_alloc = false;
+        cbarg.alloc_size = *content_len;
+        cbarg.buff = *content;
+    }
+    cbarg.length = 0;
+
+    curl_easy_setopt(curl, CURLOPT_URL, url);
+    curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT, connect_timeout);
+    curl_easy_setopt(curl, CURLOPT_TIMEOUT, connect_timeout + network_timeout);
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_write_data);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &cbarg);
+    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1);
+    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
+    curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
+
+    result = curl_easy_perform(curl);
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &response_code);
+    curl_easy_cleanup(curl);
+
+    *http_status = response_code;
+    if (result == CURLE_OK) {
+        if (cbarg.dynamic_alloc) {
+            *content = cbarg.buff;
+        }
+        *content_len = cbarg.length;
+        *(*content + *content_len) = '\0';
+        return 0;
+    } else {
+        sprintf(error_info, "curl_easy_perform fail with code: %d, %s",
+                result, curl_easy_strerror(result));
+        if (cbarg.dynamic_alloc && cbarg.buff != NULL) {
+            free(cbarg.buff);
+        }
+        *content_len = 0;
+        return EACCES;
+    }
+}
+
+#else
+
 int get_url_content_ex(const char *url, const int url_len,
         const int connect_timeout, const int network_timeout,
         int *http_status, char **content, int *content_len, char *error_info)
@@ -60,6 +185,7 @@ int get_url_content_ex(const char *url, const int url_len,
 	char *pPort;
 	char *pSpace;
 
+    *error_info = '\0';
 	*http_status = 0;
     if (*content == NULL)
     {
@@ -254,9 +380,8 @@ int get_url_content_ex(const char *url, const int url_len,
 
         *http_status = atoi(pSpace + 1);
         *content_len -= pContent - *content;
-        memcpy(*content, pContent, *content_len);
+        memmove(*content, pContent, *content_len);
         *(*content + *content_len) = '\0';
-        *error_info = '\0';
     } while (0);
 
 	close(sock);
@@ -270,6 +395,8 @@ int get_url_content_ex(const char *url, const int url_len,
 	return result;
 }
 
+#endif
+
 int get_url_content(const char *url, const int connect_timeout, \
 	const int network_timeout, int *http_status, \
 	char **content, int *content_len, char *error_info)

src/http_func.h

@@ -23,6 +23,14 @@
 #include <ctype.h>
 #include "common_define.h"
 
+#define IS_URL_RESOURCE(str)  \
+    ((strncasecmp(str, "http://", 7) == 0) || \
+     (strncasecmp(str, "https://", 8) == 0))
+
+#define IS_URL_RESOURCE_EX(s)  \
+    ((s)->len >= 8 && ((memcmp((s)->str, "http://", 7) == 0) || \
+        (memcmp((s)->str, "https://", 8) == 0)))
+
 #ifdef __cplusplus
 extern "C" {
 #endif

src/id_generator.c

@@ -84,6 +84,7 @@ int id_generator_init_extra_ex(struct idg_context *context, const char *filename
 		const char *local_ip;
 		const char *private_ip;
 		struct in_addr ip_addr;
+		struct in6_addr ip6_addr;
 
 		private_ip = get_first_local_private_ip();
 		if (private_ip != NULL)
@@ -100,16 +101,28 @@ int id_generator_init_extra_ex(struct idg_context *context, const char *filename
 				context->fd = -1;
 				return ENOENT;
 			}
-			else if (strcmp(local_ip, LOCAL_LOOPBACK_IP) == 0)
+			else if (strcmp(local_ip, LOCAL_LOOPBACK_IPv4) == 0)
 			{
+				/* 注意，当系统存在IPv6回环地址时，为了简化系统的改动，
+                   会将IPv6回环地址修改成IPv4回环地址返回
+                   此处错误打印时，需要带上IPv6回环地址
+                   */
 				logWarning("file: "__FILE__", line: %d, "
-					"can't get local ip address, set to %s",
-					__LINE__, LOCAL_LOOPBACK_IP);
+					"can't get local ip address, set to %s or %s",
+					__LINE__, LOCAL_LOOPBACK_IPv4, LOCAL_LOOPBACK_IPv6);
 			}
 		}
 
-		if (inet_pton(AF_INET, local_ip, &ip_addr) != 1)
-		{
+		if (inet_pton(AF_INET, local_ip, &ip_addr) == 1)
+        {
+            //do nothing
+        }
+        else if(inet_pton(AF_INET6, local_ip, &ip6_addr) == 1)
+        {
+            ip_addr.s_addr = *((in_addr_64_t *)&ip6_addr);
+        }
+        else
+        {
 			logError("file: "__FILE__", line: %d, "
 				"invalid local ip address: %s",
 				__LINE__, local_ip);
@@ -123,13 +136,14 @@ int id_generator_init_extra_ex(struct idg_context *context, const char *filename
 		mid = ntohl(ip_addr.s_addr) & ((1 << mid_bits) - 1);
 	}
 
-	if ((context->fd = open(filename, O_RDWR)) < 0)
+	if ((context->fd = open(filename, O_RDWR | O_CLOEXEC)) < 0)
 	{
         if (errno == ENOENT)
         {
             mode_t old_mode;
             old_mode = umask(0);
-            if ((context->fd=open(filename, O_RDWR | O_CREAT, mode)) < 0)
+            if ((context->fd=open(filename, O_RDWR | O_CREAT |
+                            O_CLOEXEC, mode)) < 0)
             {
 		        result = errno != 0 ? errno : EACCES;
             }

src/id_generator.h

@@ -26,7 +26,6 @@
 #include <stdlib.h>
 #include <time.h>
 #include <sys/types.h>
-#include <sys/stat.h>
 #include <inttypes.h>
 #include <fcntl.h>
 #include "common_define.h"

src/ini_file_reader.c

@@ -115,13 +115,6 @@ static DynamicAnnotations *iniAllocAnnotations(IniContext *pContext,
 static AnnotationEntry *iniGetAnnotations(IniContext *pContext);
 static SetDirectiveVars *iniGetVars(IniContext *pContext);
 
-#define STR_TRIM(pStr) \
-    do { \
-        trim_right(pStr); \
-        trim_left(pStr);  \
-    } while (0)
-
-
 #define RETRY_FETCH_GLOBAL(szSectionName, bRetryGlobal) \
         ((szSectionName != NULL && *szSectionName != '\0') && bRetryGlobal)
 
@@ -205,7 +198,7 @@ static int iniAnnotationFuncLocalIpGet(IniContext *context,
                 (int)(square_start - param), param);
         index = atoi(square_start + 1);
     } else {
-        snprintf(name_part, sizeof(name_part) - 1, "%s", param);
+        fc_safe_strcpy(name_part, param);
         index = -2;
     }
 
@@ -329,7 +322,7 @@ static char *doReplaceVars(IniContext *pContext, const char *param,
         logWarning("file: "__FILE__", line: %d, "
                 "NO set directives before, set value to %s",
                 __LINE__, param);
-        snprintf(output, FAST_INI_ITEM_VALUE_SIZE, "%s", param);
+        fc_strlcpy(output, param, FAST_INI_ITEM_VALUE_SIZE);
         return output;
     }
 
@@ -359,10 +352,10 @@ static char *doReplaceVars(IniContext *pContext, const char *param,
                 memcpy(name, start, name_len);
             }
             *(name + name_len) = '\0';
-            trim(name);
+            fc_trim(name);
             name_len = strlen(name);
             if (name_len > 0) {
-                value = (char *)hash_find(set->vars, name, name_len);
+                value = (char *)fc_hash_find(set->vars, name, name_len);
             } else {
                 value = NULL;
             }
@@ -553,10 +546,10 @@ static int iniInitContext(IniContext *pContext, const char annotation_type,
 
 	memset(pContext, 0, sizeof(IniContext));
 	pContext->current_section = &pContext->global;
-	if ((result=hash_init(&pContext->sections, Time33Hash, 32, 0.75)) != 0)
+	if ((result=fc_hash_init(&pContext->sections, Time33Hash, 32, 0.75)) != 0)
 	{
 		logError("file: "__FILE__", line: %d, " \
-			"hash_init fail, errno: %d, error info: %s", \
+			"fc_hash_init fail, errno: %d, error info: %s", \
 			__LINE__, result, STRERROR(result));
 	}
 
@@ -586,7 +579,7 @@ static void iniSortItems(IniContext *pContext)
 			sizeof(IniItem), iniCompareByItemName);
 	}
 
-	hash_walk(&pContext->sections, iniSortHashData, NULL);
+	fc_hash_walk(&pContext->sections, iniSortHashData, NULL);
 }
 
 int iniLoadFromFile(const char *szFilename, IniContext *pContext)
@@ -596,6 +589,13 @@ int iniLoadFromFile(const char *szFilename, IniContext *pContext)
             NULL, 0, FAST_INI_FLAGS_NONE);
 }
 
+int iniLoadFromFile1(const char *szFilename,
+        IniContext *pContext, const char flags)
+{
+    return iniLoadFromFileEx(szFilename, pContext,
+            FAST_INI_ANNOTATION_WITH_BUILTIN, NULL, 0, flags);
+}
+
 static void iniDestroyAnnotations(const int old_annotation_count)
 {
     AnnotationEntry *pAnnoEntry;
@@ -640,7 +640,7 @@ int iniLoadFromFileEx(const char *szFilename, IniContext *pContext,
 	int result;
 	int len;
 	char *pLast;
-	char full_filename[MAX_PATH_SIZE];
+	char full_filename[PATH_MAX];
     int old_annotation_count;
 
 	if ((result=iniInitContext(pContext, annotation_type,
@@ -649,13 +649,18 @@ int iniLoadFromFileEx(const char *szFilename, IniContext *pContext,
 		return result;
 	}
 
-	if (strncasecmp(szFilename, "http://", 7) == 0)
+	if (IS_URL_RESOURCE(szFilename))
 	{
 		*pContext->config_path = '\0';
-		snprintf(full_filename, sizeof(full_filename),"%s",szFilename);
+		fc_safe_strcpy(full_filename, szFilename);
 	}
 	else
 	{
+        if (IS_FILE_RESOURCE(szFilename))
+        {
+            szFilename += FILE_RESOURCE_TAG_LEN;
+        }
+
 		if (*szFilename == '/')
 		{
 			pLast = strrchr(szFilename, '/');
@@ -670,8 +675,7 @@ int iniLoadFromFileEx(const char *szFilename, IniContext *pContext,
 
 			memcpy(pContext->config_path, szFilename, len);
 			*(pContext->config_path + len) = '\0';
-			snprintf(full_filename, sizeof(full_filename), \
-				"%s", szFilename);
+            fc_safe_strcpy(full_filename, szFilename);
 		}
 		else
 		{
@@ -694,9 +698,8 @@ int iniLoadFromFileEx(const char *szFilename, IniContext *pContext,
 				*(pContext->config_path + len) = '\0';
 			}
 
-			snprintf(full_filename, sizeof(full_filename), \
-				"%s/%s", pContext->config_path, szFilename);
-
+            fc_combine_full_filename(pContext->config_path,
+                    szFilename, full_filename);
 			pLast = strrchr(szFilename, '/');
 			if (pLast != NULL)
 			{
@@ -751,7 +754,7 @@ static int iniDoLoadFromFile(const char *szFilename, \
 	int64_t file_size;
 	char error_info[512];
 
-	if (strncasecmp(szFilename, "http://", 7) == 0)
+	if (IS_URL_RESOURCE(szFilename))
 	{
 		if ((result=get_url_content(szFilename, 10, 60, &http_status, \
 				&content, &content_len, error_info)) != 0)
@@ -826,6 +829,11 @@ int iniLoadFromBuffer(char *content, IniContext *pContext)
             NULL, 0, FAST_INI_FLAGS_NONE);
 }
 
+int iniLoadFromBuffer1(char *content, IniContext *pContext, const char flags)
+{
+    return iniLoadFromBufferEx(content, pContext,
+            FAST_INI_ANNOTATION_WITH_BUILTIN, NULL, 0, flags);
+}
 
 typedef int (*init_annotation_func0)(AnnotationEntry *annotation);
 typedef int (*init_annotation_func1)(AnnotationEntry *annotation,
@@ -849,7 +857,7 @@ static int iniAddAnnotation(char *params)
     int count;
     int result;
 
-    trim(params);
+    fc_trim(params);
     count = fc_split_string(params, " \t", cols, MAX_PARAMS);
     if (count < 2)
     {
@@ -904,7 +912,7 @@ static int iniAddAnnotation(char *params)
         return EFAULT;
     }
 
-    snprintf(symbol, sizeof(symbol), "%s_init_annotation", func_name);
+    fc_combine_two_strings(func_name, "init_annotation", '_', symbol);
     init_func = dlsym(dlhandle, symbol);
     if (init_func == NULL)
     {
@@ -960,10 +968,11 @@ static int iniDoLoadItemsFromBuffer(char *content, IniContext *pContext)
 	char *pEqualChar;
     char pItemName[FAST_INI_ITEM_NAME_LEN + 1];
     char *pAnnoItemLine;
-	char *pIncludeFilename;
+	char pIncludeFilename[PATH_MAX];
+	char *pTrueFilename;
     char *pItemValues[100];
     char pFuncName[FAST_INI_ITEM_NAME_LEN + 1];
-	char full_filename[MAX_PATH_SIZE];
+	char full_filename[PATH_MAX];
     int i;
 	int nLineLen;
 	int nNameLen;
@@ -997,55 +1006,53 @@ static int iniDoLoadItemsFromBuffer(char *content, IniContext *pContext)
             isAnnotation = 0;
         }
 
-		STR_TRIM(pLine);
+		fc_trim(pLine);
 		if (*pLine == '#' && \
 			strncasecmp(pLine+1, "include", 7) == 0 && \
 			(*(pLine+8) == ' ' || *(pLine+8) == '\t'))
 		{
-			pIncludeFilename = fc_strdup(pLine + 9);
-			if (pIncludeFilename == NULL)
-			{
-				result = ENOMEM;
-				break;
-			}
-
-			STR_TRIM(pIncludeFilename);
-			if (strncasecmp(pIncludeFilename, "http://", 7) == 0)
-			{
-				snprintf(full_filename, sizeof(full_filename),\
-					"%s", pIncludeFilename);
-			}
+            fc_safe_strcpy(pIncludeFilename, pLine + 9);
+			fc_trim(pIncludeFilename);
+			if (IS_URL_RESOURCE(pIncludeFilename))
+            {
+                fc_safe_strcpy(full_filename, pIncludeFilename);
+            }
 			else
 			{
-				if (*pIncludeFilename == '/')
+                if (IS_FILE_RESOURCE(pIncludeFilename))
+                {
+                    pTrueFilename = pIncludeFilename + FILE_RESOURCE_TAG_LEN;
+                }
+                else
+                {
+                    pTrueFilename = pIncludeFilename;
+                }
+
+                if (*pTrueFilename == '/')
 				{
-				snprintf(full_filename, sizeof(full_filename), \
-					"%s", pIncludeFilename);
+                    fc_safe_strcpy(full_filename, pTrueFilename);
 				}
 				else
-				{
-				snprintf(full_filename, sizeof(full_filename), \
-					"%s/%s", pContext->config_path, \
-					 pIncludeFilename);
-				}
+                {
+                    fc_combine_full_filename(pContext->config_path,
+                            pTrueFilename, full_filename);
+                }
 
 				if (!fileExists(full_filename))
-				{
-				logError("file: "__FILE__", line: %d, " \
-					"include file \"%s\" not exists, " \
-					"line: \"%s\"", __LINE__, \
-					pIncludeFilename, pLine);
-				free(pIncludeFilename);
-				result = ENOENT;
-				break;
-				}
+                {
+                    logError("file: "__FILE__", line: %d, "
+                            "include file \"%s\" not exists, "
+                            "line: \"%s\"", __LINE__,
+                            pTrueFilename, pLine);
+                    result = ENOENT;
+                    break;
+                }
 			}
 
             pContext->current_section = &pContext->global;
 			result = iniDoLoadFromFile(full_filename, pContext);
 			if (result != 0)
 			{
-				free(pIncludeFilename);
 				break;
 			}
 
@@ -1053,7 +1060,6 @@ static int iniDoLoadItemsFromBuffer(char *content, IniContext *pContext)
 			pSection = pContext->current_section;
             pItem = pSection->items + pSection->count;  //must re-asign
 
-			free(pIncludeFilename);
 			continue;
 		}
         else if (*pLine == '#')
@@ -1073,7 +1079,7 @@ static int iniDoLoadItemsFromBuffer(char *content, IniContext *pContext)
                 }
                 memcpy(pFuncName, pLine + 11, nNameLen);
                 pFuncName[nNameLen] = '\0';
-                STR_TRIM(pFuncName);
+                fc_trim(pFuncName);
                 if ((int)strlen(pFuncName) > 0)
                 {
                     isAnnotation = 1;
@@ -1113,7 +1119,7 @@ static int iniDoLoadItemsFromBuffer(char *content, IniContext *pContext)
 			*(pLine + (nLineLen - 1)) = '\0';
 			section_name = pLine + 1; //skip [
 
-			STR_TRIM(section_name);
+			fc_trim(section_name);
 			if (*section_name == '\0') //global section
 			{
 				pContext->current_section = &pContext->global;
@@ -1123,7 +1129,7 @@ static int iniDoLoadItemsFromBuffer(char *content, IniContext *pContext)
 			}
 
 			section_len = strlen(section_name);
-			pSection = (IniSection *)hash_find(&pContext->sections,\
+			pSection = (IniSection *)fc_hash_find(&pContext->sections,\
 					section_name, section_len);
 			if (pSection == NULL)
 			{
@@ -1135,7 +1141,7 @@ static int iniDoLoadItemsFromBuffer(char *content, IniContext *pContext)
 				}
 
 				memset(pSection, 0, sizeof(IniSection));
-				result = hash_insert(&pContext->sections, \
+				result = fc_hash_insert(&pContext->sections, \
 					  section_name, section_len, pSection);
 				if (result < 0)
 				{
@@ -1206,8 +1212,8 @@ static int iniDoLoadItemsFromBuffer(char *content, IniContext *pContext)
 		memcpy(pItem->name, pLine, nNameLen);
 		memcpy(pItem->value, pEqualChar + 1, nValueLen);
 
-		STR_TRIM(pItem->name);
-		STR_TRIM(pItem->value);
+		fc_trim(pItem->name);
+		fc_trim(pItem->value);
 
         if (isAnnotation)
         {
@@ -1521,7 +1527,7 @@ static SetDirectiveVars *iniAllocVars(IniContext *pContext, const bool initVars)
         {
             return NULL;
         }
-        if (hash_init_ex(set->vars, simple_hash, 17, 0.75, 0, true) != 0)
+        if (fc_hash_init_ex(set->vars, fc_simple_hash, 17, 0.75, 0, true) != 0)
         {
             free(set->vars);
             set->vars = NULL;
@@ -1988,7 +1994,7 @@ static bool iniCalcCondition(char *condition, const int condition_len,
         set = iniGetVars(pContext);
         if (set != NULL && set->vars != NULL)
         {
-            value = (char *)hash_find(set->vars, varStr, varLen);
+            value = (char *)fc_hash_find(set->vars, varStr, varLen);
             if (value == NULL)
             {
                 logWarning("file: "__FILE__", line: %d, "
@@ -2145,7 +2151,7 @@ static int iniDoProccessSet(char *pSet, char **ppSetEnd,
         }
     }
 
-    result = hash_insert_ex(set->vars, key, strlen(key),
+    result = fc_hash_insert_ex(set->vars, key, strlen(key),
             new_value, value_len + 1, false);
     if (new_value != value) {
         free(new_value);
@@ -2617,8 +2623,7 @@ static char *iniProccessFor(char *content, const int content_len,
         char *pRemain;
         int remainLen;
 
-        valueLen = sprintf(value, "%d", i);
-
+        valueLen = fc_itoa(i, value);
         pRemain = pForBlock;
         remainLen = forBlockLen;
         while (remainLen >= tagLen)
@@ -2767,13 +2772,13 @@ void iniFreeContext(IniContext *pContext)
 		memset(&pContext->global, 0, sizeof(IniSection));
 	}
 
-	hash_walk(&pContext->sections, iniFreeHashData, NULL);
-	hash_destroy(&pContext->sections);
+	fc_hash_walk(&pContext->sections, iniFreeHashData, NULL);
+	fc_hash_destroy(&pContext->sections);
 
     set = iniGetVars(pContext);
     if (set != NULL && set->vars != NULL)
     {
-        hash_destroy(set->vars);
+        fc_hash_destroy(set->vars);
         free(set->vars);
         set->vars = NULL;
         set->offset = 0;
@@ -2790,7 +2795,7 @@ do { \
     } \
     else \
     { \
-        pSection = (IniSection *)hash_find(&pContext->sections, \
+        pSection = (IniSection *)fc_hash_find(&pContext->sections, \
                 szSectionName, strlen(szSectionName)); \
         if (pSection == NULL) \
         { \
@@ -2805,7 +2810,7 @@ do { \
         break;  \
     } \
     \
-    snprintf(targetItem.name, sizeof(targetItem.name), "%s", szItemName); \
+    fc_safe_strcpy(targetItem.name, szItemName); \
     pItem = (IniItem *)bsearch(&targetItem, pSection->items, \
             pSection->count, sizeof(IniItem), iniCompareByItemName); \
 } while (0)
@@ -2856,6 +2861,21 @@ char *iniGetStrValueEx(const char *szSectionName, const char *szItemName,
     return pFound->value;
 }
 
+char iniGetCharValueEx(const char *szSectionName, const char *szItemName,
+        IniContext *pContext, const char cDefaultValue,
+        const bool bRetryGlobal)
+{
+    char *value;
+
+    value = iniGetStrValueEx(szSectionName, szItemName,
+            pContext, bRetryGlobal);
+    if (value == NULL) {
+        return cDefaultValue;
+    } else {
+        return value[0];
+    }
+}
+
 #define INI_FILL_SECTION_PROMPT(prompt, size, section_name) \
     do { \
         if (section_name != NULL && *(section_name) != '\0') { \
@@ -2894,6 +2914,64 @@ int64_t iniCheckAndCorrectIntValue(IniFullContext *pIniContext,
     return nValue;
 }
 
+double iniCheckAndCorrectDoubleValue(IniFullContext *pIniContext,
+        const char *szItemName, const double dValue,
+        const double dMinValue, const double dMaxValue)
+{
+    char section_prompt[128];
+    if (dValue < dMinValue) {
+        INI_FILL_SECTION_PROMPT(section_prompt, sizeof(section_prompt),
+                pIniContext->section_name);
+        logWarning("file: "__FILE__", line: %d, "
+                "config file: %s, %sitem name: %s, item value: %.2f"
+                " < min value: %.2f, set to min value: %.2f",
+                __LINE__, pIniContext->filename, section_prompt,
+                szItemName, dValue, dMinValue, dMinValue);
+
+        return dMinValue;
+    } else if (dValue > dMaxValue) {
+        INI_FILL_SECTION_PROMPT(section_prompt, sizeof(section_prompt),
+                pIniContext->section_name);
+        logWarning("file: "__FILE__", line: %d, "
+                "config file: %s, %sitem name: %s, item value: %.2f"
+                " > max value: %.2f, set to max value: %.2f",
+                __LINE__, pIniContext->filename, section_prompt,
+                szItemName, dValue, dMaxValue, dMaxValue);
+        return dMaxValue;
+    }
+
+    return dValue;
+}
+
+double iniCheckAndCorrectPercentValue(IniFullContext *pIniContext,
+        const char *szItemName, const double dValue,
+        const double dMinValue, const double dMaxValue)
+{
+    char section_prompt[128];
+    if (dValue < dMinValue) {
+        INI_FILL_SECTION_PROMPT(section_prompt, sizeof(section_prompt),
+                pIniContext->section_name);
+        logWarning("file: "__FILE__", line: %d, "
+                "config file: %s, %sitem name: %s, item value: %.2f%%"
+                " < min value: %.2f%%, set to min value: %.2f%%",
+                __LINE__, pIniContext->filename, section_prompt,
+                szItemName, dValue * 100, dMinValue * 100, dMinValue * 100);
+
+        return dMinValue;
+    } else if (dValue > dMaxValue) {
+        INI_FILL_SECTION_PROMPT(section_prompt, sizeof(section_prompt),
+                pIniContext->section_name);
+        logWarning("file: "__FILE__", line: %d, "
+                "config file: %s, %sitem name: %s, item value: %.2f%%"
+                " > max value: %.2f%%, set to max value: %.2f%%",
+                __LINE__, pIniContext->filename, section_prompt,
+                szItemName, dValue * 100, dMaxValue * 100, dMaxValue * 100);
+        return dMaxValue;
+    }
+
+    return dValue;
+}
+
 int64_t iniGetInt64ValueEx(const char *szSectionName,
         const char *szItemName, IniContext *pContext,
         const int64_t nDefaultValue, const bool bRetryGlobal)
@@ -2925,6 +3003,36 @@ int64_t iniGetInt64CorrectValueEx(IniFullContext *pIniContext,
             value, nMinValue, nMaxValue);
 }
 
+double iniGetDoubleCorrectValueEx(IniFullContext *pIniContext,
+        const char *szItemName, const double dbDefaultValue,
+        const double dbMinValue, const double dbMaxValue,
+        const bool bRetryGlobal)
+{
+    double value;
+
+    value = iniGetDoubleValueEx(pIniContext->section_name, szItemName,
+            pIniContext->context, dbDefaultValue, bRetryGlobal);
+    return iniCheckAndCorrectDoubleValue(pIniContext, szItemName,
+            value, dbMinValue, dbMaxValue);
+}
+
+int iniGetPercentCorrectValueEx(IniFullContext *pIniContext,
+        const char *szItemName, double *dbItemValue,
+        const double dbDefaultValue, const double dbMinValue,
+        const double dbMaxValue, const bool bRetryGlobal)
+{
+    int result;
+
+    if ((result=iniGetPercentValueEx(pIniContext, szItemName, dbItemValue,
+                    dbDefaultValue, bRetryGlobal)) == 0)
+    {
+        *dbItemValue = iniCheckAndCorrectPercentValue(pIniContext,
+                szItemName, *dbItemValue, dbMinValue, dbMaxValue);
+    }
+
+    return result;
+}
+
 int64_t iniGetByteValueEx(const char *szSectionName,
         const char *szItemName, IniContext *pContext,
         const int64_t nDefaultValue, const int nDefaultUnitBytes,
@@ -3163,7 +3271,7 @@ void iniPrintItems(IniContext *pContext)
 	}
 	printf("\n");
 
-	hash_walk(&pContext->sections, iniPrintHashData, NULL);
+	fc_hash_walk(&pContext->sections, iniPrintHashData, NULL);
 }
 
 struct section_name_walk_arg {
@@ -3227,7 +3335,7 @@ int iniGetSectionNamesEx(IniContext *pContext, IniSectionNameFilterFunc
     walk_arg.args = args;
     walk_arg.size = max_size;
     walk_arg.count = 0;
-	result = hash_walk(&pContext->sections, iniSectionNameWalkCallback,
+	result = fc_hash_walk(&pContext->sections, iniSectionNameWalkCallback,
             &walk_arg);
     *nCount = walk_arg.count;
     return result;
@@ -3298,7 +3406,7 @@ int iniGetSectionCountEx(IniContext *pContext, IniSectionNameFilterFunc
     walk_arg.filter_func = filter_func;
     walk_arg.args = args;
     walk_arg.count = 0;
-    hash_walk(&pContext->sections, iniSectionCountWalkCallback, &walk_arg);
+    fc_hash_walk(&pContext->sections, iniSectionCountWalkCallback, &walk_arg);
     return walk_arg.count;
 }
 
@@ -3321,7 +3429,7 @@ IniItem *iniGetSectionItems(const char *szSectionName, IniContext *pContext,
 	}
 	else
 	{
-		pSection = (IniSection *)hash_find(&pContext->sections,
+		pSection = (IniSection *)fc_hash_find(&pContext->sections,
 				szSectionName, strlen(szSectionName));
 		if (pSection == NULL)
 		{

src/ini_file_reader.h

@@ -117,28 +117,32 @@ extern "C" {
 #define iniGetStrValue(szSectionName, szItemName, pContext) \
     iniGetStrValueEx(szSectionName, szItemName, pContext, false)
 
+#define iniGetCharValue(szSectionName, szItemName, pContext, cDefaultValue) \
+    iniGetCharValueEx(szSectionName, szItemName, \
+            pContext, cDefaultValue, false)
+
 #define iniGetIntValue(szSectionName, szItemName, pContext, nDefaultValue) \
-    iniGetIntValueEx(szSectionName, szItemName, pContext,  \
-    nDefaultValue, false)
+    iniGetIntValueEx(szSectionName, szItemName, \
+            pContext, nDefaultValue, false)
 
 #define iniGetInt64Value(szSectionName, szItemName, pContext, nDefaultValue) \
-    iniGetInt64ValueEx(szSectionName, szItemName, pContext, \
-    nDefaultValue, false)
+    iniGetInt64ValueEx(szSectionName, szItemName, \
+            pContext, nDefaultValue, false)
 
 #define iniGetDoubleValue(szSectionName, szItemName, pContext, dbDefaultValue) \
-    iniGetDoubleValueEx(szSectionName, szItemName, pContext, \
-    dbDefaultValue, false)
+    iniGetDoubleValueEx(szSectionName, szItemName, \
+            pContext, dbDefaultValue, false)
 
 #define iniGetBoolValue(szSectionName, szItemName, pContext, bDefaultValue) \
-    iniGetBoolValueEx(szSectionName, szItemName, pContext, \
-    bDefaultValue, false)
+    iniGetBoolValueEx(szSectionName, szItemName, \
+            pContext, bDefaultValue, false)
 
 #define iniGetPercentValue(ini_ctx, item_name, item_value, default_value) \
     iniGetPercentValueEx(ini_ctx, item_name, item_value, default_value, false)
 
 #define iniGetByteValue(szSectionName, szItemName, pContext, nDefaultValue) \
-    iniGetByteValueEx(szSectionName, szItemName, pContext, \
-            nDefaultValue, 1, false)
+    iniGetByteValueEx(szSectionName, szItemName, \
+            pContext, nDefaultValue, 1, false)
 
 #define iniGetIntCorrectValue(ini_ctx, item_name, \
         default_value, min_value, max_value)    \
@@ -155,6 +159,16 @@ extern "C" {
     iniGetByteCorrectValueEx(ini_ctx, item_name, \
             default_value, 1, min_value, max_value, false)
 
+#define iniGetDoubleCorrectValue(ini_ctx, item_name, \
+        default_value, min_value, max_value)       \
+    iniGetDoubleCorrectValueEx(ini_ctx, item_name, \
+            default_value, 1, min_value, max_value, false)
+
+#define iniGetPercentCorrectValue(ini_ctx, item_name,    \
+        item_value, default_value, min_value, max_value) \
+    iniGetPercentCorrectValueEx(ini_ctx, item_name, item_value, \
+        default_value, min_value, max_value, false)
+
 int iniSetAnnotationCallBack(AnnotationEntry *annotations, int count);
 void iniDestroyAnnotationCallBack();
 
@@ -169,6 +183,16 @@ void iniAnnotationFreeValues(struct ini_annotation_entry *annotation,
 */
 int iniLoadFromFile(const char *szFilename, IniContext *pContext);
 
+/** load ini items from file with flags
+ *  parameters:
+ *           szFilename: the filename, can be an URL
+ *           pContext: the ini context
+ *           flags: the flags
+ *  return: error no, 0 for success, != 0 fail
+*/
+int iniLoadFromFile1(const char *szFilename,
+        IniContext *pContext, const char flags);
+
 /** load ini items from file
  *  parameters:
  *           szFilename: the filename, can be an URL
@@ -205,6 +229,15 @@ int iniLoadFromBufferEx(char *content, IniContext *pContext,
     const char annotation_type, AnnotationEntry *annotations, const int count,
     const char flags);
 
+/** load ini items from string buffer with flags
+ *  parameters:
+ *           content: the string buffer to parse
+ *           pContext: the ini context
+ *           flags: the flags
+ *  return: error no, 0 for success, != 0 fail
+*/
+int iniLoadFromBuffer1(char *content, IniContext *pContext, const char flags);
+
 /** free ini context
  *  parameters:
  *           pContext: the ini context
@@ -214,7 +247,7 @@ void iniFreeContext(IniContext *pContext);
 
 /** get item string value
  *  parameters:
- *           szSectionName: the section name, NULL or empty string for 
+ *           szSectionName: the section name, NULL or empty string for
  *                          global section
  *           szItemName: the item name
  *           pContext:   the ini context
@@ -224,9 +257,23 @@ void iniFreeContext(IniContext *pContext);
 char *iniGetStrValueEx(const char *szSectionName, const char *szItemName,
 		IniContext *pContext, const bool bRetryGlobal);
 
+/** get the first charactor
+ *  parameters:
+ *           szSectionName: the section name, NULL or empty string for
+ *                          global section
+ *           szItemName: the item name
+ *           pContext:   the ini context
+ *           cDefaultValue: the default value
+ *           bRetryGlobal: if fetch from global section when the item not exist
+ *  return: item value, return default value when the item not exist
+*/
+char iniGetCharValueEx(const char *szSectionName, const char *szItemName,
+        IniContext *pContext, const char cDefaultValue,
+        const bool bRetryGlobal);
+
 /** get item string value
  *  parameters:
- *           szSectionName: the section name, NULL or empty string for 
+ *           szSectionName: the section name, NULL or empty string for
  *                          global section
  *           szItemName: the item name
  *           pContext:   the ini context
@@ -239,7 +286,7 @@ int iniGetValues(const char *szSectionName, const char *szItemName, \
 
 /** get item int value (32 bits)
  *  parameters:
- *           szSectionName: the section name, NULL or empty string for 
+ *           szSectionName: the section name, NULL or empty string for
  *                          global section
  *           szItemName: the item name
  *           pContext:   the ini context
@@ -251,7 +298,7 @@ int iniGetIntValueEx(const char *szSectionName,
         const char *szItemName, IniContext *pContext,
         const int nDefaultValue, const bool bRetryGlobal);
 
-/** check and correct item value
+/** check and correct int value
  *  parameters:
  *           pIniContext: the full ini context
  *           szItemName:  the item name
@@ -264,6 +311,32 @@ int64_t iniCheckAndCorrectIntValue(IniFullContext *pIniContext,
         const char *szItemName, const int64_t nValue,
         const int64_t nMinValue, const int64_t nMaxValue);
 
+/** check and correct double value
+ *  parameters:
+ *           pIniContext: the full ini context
+ *           szItemName:  the item name
+ *           dValue: the item value
+ *           dMinValue: the min value to check (including)
+ *           dMaxValue: the max value to check (including)
+ *  return: corrected value
+*/
+double iniCheckAndCorrectDoubleValue(IniFullContext *pIniContext,
+        const char *szItemName, const double dValue,
+        const double dMinValue, const double dMaxValue);
+
+/** check and correct double value (show as percentage)
+ *  parameters:
+ *           pIniContext: the full ini context
+ *           szItemName:  the item name
+ *           dValue: the item value
+ *           dMinValue: the min value to check (including)
+ *           dMaxValue: the max value to check (including)
+ *  return: corrected value
+*/
+double iniCheckAndCorrectPercentValue(IniFullContext *pIniContext,
+        const char *szItemName, const double dValue,
+        const double dMinValue, const double dMaxValue);
+
 /** get item correct value (32 bits integer)
  *  parameters:
  *           pIniContext: the full ini context
@@ -280,7 +353,7 @@ int iniGetIntCorrectValueEx(IniFullContext *pIniContext,
 
 /** get item string value array
  *  parameters:
- *           szSectionName: the section name, NULL or empty string for 
+ *           szSectionName: the section name, NULL or empty string for
  *                          global section
  *           szItemName: the item name
  *           pContext:   the ini context
@@ -353,7 +426,7 @@ int64_t iniGetByteCorrectValueEx(IniFullContext *pIniContext,
 
 /** get item boolean value
  *  parameters:
- *           szSectionName: the section name, NULL or empty string for 
+ *           szSectionName: the section name, NULL or empty string for
  *                          global section
  *           szItemName: the item name
  *           pContext:   the ini context
@@ -367,7 +440,7 @@ bool iniGetBoolValueEx(const char *szSectionName,
 
 /** get item double value
  *  parameters:
- *           szSectionName: the section name, NULL or empty string for 
+ *           szSectionName: the section name, NULL or empty string for
  *                          global section
  *           szItemName: the item name
  *           pContext:   the ini context
@@ -379,6 +452,20 @@ double iniGetDoubleValueEx(const char *szSectionName,
         const char *szItemName, IniContext *pContext,
         const double dbDefaultValue, const bool bRetryGlobal);
 
+/** get item correct double value
+ *  parameters:
+ *           pIniContext: the full ini context
+ *           szItemName:  the item name
+ *           dbDefaultValue: the default value
+ *           dbMinValue: the min value to check (including)
+ *           dbMaxValue: the max value to check (including)
+ *           bRetryGlobal: if fetch from global section when the item not exist
+ *  return: double value, return dbDefaultValue when the item not exist
+*/
+double iniGetDoubleCorrectValueEx(IniFullContext *pIniContext,
+        const char *szItemName, const double dbDefaultValue,
+        const double dbMinValue, const double dbMaxValue,
+        const bool bRetryGlobal);
 
 /** get item percent double value
  *  parameters:
@@ -393,6 +480,22 @@ int iniGetPercentValueEx(IniFullContext *ini_ctx,
         const char *item_name, double *item_value,
         const double default_value, const bool retry_global);
 
+/** get item correct double value (show as percentage)
+ *  parameters:
+ *           pIniContext: the full ini context
+ *           szItemName:  the item name
+ *           dbItemValue: store the item value
+ *           dbDefaultValue: the default value
+ *           dbMinValue: the min value to check (including)
+ *           dbMaxValue: the max value to check (including)
+ *           bRetryGlobal: if fetch from global section when the item not exist
+ *  return: error no, 0 for success, != 0 for fail
+*/
+int iniGetPercentCorrectValueEx(IniFullContext *pIniContext,
+        const char *szItemName, double *dbItemValue,
+        const double dbDefaultValue, const double dbMinValue,
+        const double dbMaxValue, const bool bRetryGlobal);
+
 /** print all items
  *  parameters:
  *           pContext:   the ini context

src/ioevent.c

@@ -45,71 +45,119 @@ int kqueue_ev_convert(int16_t event, uint16_t flags)
 }
 #endif
 
-int ioevent_init(IOEventPoller *ioevent, const int size,
-    const int timeout_ms, const int extra_events)
+int ioevent_init(IOEventPoller *ioevent, const char *service_name,
+        const bool use_io_uring, const int size, const int timeout_ms,
+        const int extra_events)
 {
-  int bytes;
+    int bytes;
 
-  ioevent->size = size;
-  ioevent->extra_events = extra_events;
-  ioevent->iterator.index = 0;
-  ioevent->iterator.count = 0;
+    ioevent->iterator.index = 0;
+    ioevent->iterator.count = 0;
+    ioevent->service_name = service_name;
+    ioevent->size = size;
+    ioevent->extra_events = extra_events;
 
-#if IOEVENT_USE_EPOLL
-  ioevent->poll_fd = epoll_create(ioevent->size);
-  if (ioevent->poll_fd < 0) {
-    return errno != 0 ? errno : ENOMEM;
-  }
-  bytes = sizeof(struct epoll_event) * size;
-  ioevent->events = (struct epoll_event *)fc_malloc(bytes);
+#ifdef OS_LINUX
+#if IOEVENT_USE_URING
+    ioevent->use_io_uring = use_io_uring;
+    if (use_io_uring) {
+        int result;
+        if ((result=io_uring_queue_init(size, &ioevent->ring, 0)) < 0) {
+            return -result;
+        }
+        ioevent->cqe = NULL;
+        ioevent->submit_count = 0;
+        ioevent->send_zc_logged = false;
+        ioevent->send_zc_done_notify = false;
+    } else {
+#endif
+        ioevent->poll_fd = epoll_create(ioevent->size);
+        if (ioevent->poll_fd < 0) {
+            return errno != 0 ? errno : ENOMEM;
+        }
+        bytes = sizeof(struct epoll_event) * size;
+        ioevent->events = (struct epoll_event *)fc_malloc(bytes);
+#if IOEVENT_USE_URING
+    }
+#endif
 #elif IOEVENT_USE_KQUEUE
-  ioevent->poll_fd = kqueue();
-  if (ioevent->poll_fd < 0) {
-    return errno != 0 ? errno : ENOMEM;
-  }
-  bytes = sizeof(struct kevent) * size;
-  ioevent->events = (struct kevent *)fc_malloc(bytes);
+    ioevent->poll_fd = kqueue();
+    if (ioevent->poll_fd < 0) {
+        return errno != 0 ? errno : ENOMEM;
+    }
+    bytes = sizeof(struct kevent) * size;
+    ioevent->events = (struct kevent *)fc_malloc(bytes);
 #elif IOEVENT_USE_PORT
-  ioevent->poll_fd = port_create();
-  if (ioevent->poll_fd < 0) {
-    return errno != 0 ? errno : ENOMEM;
-  }
-  bytes = sizeof(port_event_t) * size;
-  ioevent->events = (port_event_t *)fc_malloc(bytes);
+    ioevent->poll_fd = port_create();
+    if (ioevent->poll_fd < 0) {
+        return errno != 0 ? errno : ENOMEM;
+    }
+    bytes = sizeof(port_event_t) * size;
+    ioevent->events = (port_event_t *)fc_malloc(bytes);
 #endif
 
-  if (ioevent->events == NULL) {
-    close(ioevent->poll_fd);
-    ioevent->poll_fd = -1;
-    return ENOMEM;
-  }
-  ioevent_set_timeout(ioevent, timeout_ms);
+#if IOEVENT_USE_URING
+    if (!ioevent->use_io_uring) {
+#endif
+        if (ioevent->events == NULL) {
+            close(ioevent->poll_fd);
+            ioevent->poll_fd = -1;
+            return ENOMEM;
+        }
+#if IOEVENT_USE_URING
+    }
+#endif
 
-  return 0;
+    ioevent_set_timeout(ioevent, timeout_ms);
+    return 0;
 }
 
 void ioevent_destroy(IOEventPoller *ioevent)
 {
-  if (ioevent->events != NULL) {
-    free(ioevent->events);
-    ioevent->events = NULL;
-  }
+#if IOEVENT_USE_URING
+    if (ioevent->use_io_uring) {
+        io_uring_queue_exit(&ioevent->ring);
+    } else {
+#endif
+        if (ioevent->events != NULL) {
+            free(ioevent->events);
+            ioevent->events = NULL;
+        }
 
-  if (ioevent->poll_fd >= 0) {
-    close(ioevent->poll_fd);
-    ioevent->poll_fd = -1;
-  }
+        if (ioevent->poll_fd >= 0) {
+            close(ioevent->poll_fd);
+            ioevent->poll_fd = -1;
+        }
+#if IOEVENT_USE_URING
+    }
+#endif
 }
 
-int ioevent_attach(IOEventPoller *ioevent, const int fd, const int e,
-    void *data)
+int ioevent_attach(IOEventPoller *ioevent, const int fd,
+        const int e, void *data)
 {
-#if IOEVENT_USE_EPOLL
-  struct epoll_event ev;
-  memset(&ev, 0, sizeof(ev));
-  ev.events = e | ioevent->extra_events;
-  ev.data.ptr = data;
-  return epoll_ctl(ioevent->poll_fd, EPOLL_CTL_ADD, fd, &ev);
+#ifdef OS_LINUX
+#if IOEVENT_USE_URING
+    if (ioevent->use_io_uring) {
+        struct io_uring_sqe *sqe = io_uring_get_sqe(&ioevent->ring);
+        if (sqe == NULL) {
+            return ENOSPC;
+        }
+        io_uring_prep_poll_multishot(sqe, fd, e | ioevent->extra_events);
+        sqe->user_data = (long)data;
+        ioevent->submit_count++;
+        return 0;
+    } else {
+#endif
+        struct epoll_event ev;
+        memset(&ev, 0, sizeof(ev));
+        ev.events = e | ioevent->extra_events;
+        ev.data.ptr = data;
+        return epoll_ctl(ioevent->poll_fd, EPOLL_CTL_ADD, fd, &ev);
+#if IOEVENT_USE_URING
+    }
+#endif
+
 #elif IOEVENT_USE_KQUEUE
   struct kevent ev[2];
   int n = 0;
@@ -128,15 +176,32 @@ int ioevent_attach(IOEventPoller *ioevent, const int fd, const int e,
 #endif
 }
 
-int ioevent_modify(IOEventPoller *ioevent, const int fd, const int e,
-    void *data)
+int ioevent_modify(IOEventPoller *ioevent, const int fd,
+        const int e, void *data)
 {
-#if IOEVENT_USE_EPOLL
-  struct epoll_event ev;
-  memset(&ev, 0, sizeof(ev));
-  ev.events = e | ioevent->extra_events;
-  ev.data.ptr = data;
-  return epoll_ctl(ioevent->poll_fd, EPOLL_CTL_MOD, fd, &ev);
+#ifdef OS_LINUX
+#if IOEVENT_USE_URING
+    if (ioevent->use_io_uring) {
+        struct io_uring_sqe *sqe = io_uring_get_sqe(&ioevent->ring);
+        if (sqe == NULL) {
+            return ENOSPC;
+        }
+        io_uring_prep_poll_update(sqe, sqe->user_data, sqe->user_data,
+                e | ioevent->extra_events, IORING_POLL_UPDATE_EVENTS);
+        sqe->user_data = (long)data;
+        ioevent->submit_count++;
+        return 0;
+    } else {
+#endif
+        struct epoll_event ev;
+        memset(&ev, 0, sizeof(ev));
+        ev.events = e | ioevent->extra_events;
+        ev.data.ptr = data;
+        return epoll_ctl(ioevent->poll_fd, EPOLL_CTL_MOD, fd, &ev);
+#if IOEVENT_USE_URING
+    }
+#endif
+
 #elif IOEVENT_USE_KQUEUE
   struct kevent ev[2];
   int result;
@@ -171,8 +236,25 @@ int ioevent_modify(IOEventPoller *ioevent, const int fd, const int e,
 
 int ioevent_detach(IOEventPoller *ioevent, const int fd)
 {
-#if IOEVENT_USE_EPOLL
-  return epoll_ctl(ioevent->poll_fd, EPOLL_CTL_DEL, fd, NULL);
+#ifdef OS_LINUX
+#if IOEVENT_USE_URING
+    if (ioevent->use_io_uring) {
+        struct io_uring_sqe *sqe = io_uring_get_sqe(&ioevent->ring);
+        if (sqe == NULL) {
+            return ENOSPC;
+        }
+        io_uring_prep_cancel_fd(sqe, fd, 0);
+        /* set sqe->flags MUST after io_uring_prep_xxx */
+        sqe->flags = IOSQE_CQE_SKIP_SUCCESS;
+        ioevent->submit_count++;
+        return 0;
+    } else {
+#endif
+        return epoll_ctl(ioevent->poll_fd, EPOLL_CTL_DEL, fd, NULL);
+#if IOEVENT_USE_URING
+    }
+#endif
+
 #elif IOEVENT_USE_KQUEUE
   struct kevent ev[1];
   int r, w;
@@ -191,15 +273,33 @@ int ioevent_detach(IOEventPoller *ioevent, const int fd)
 
 int ioevent_poll(IOEventPoller *ioevent)
 {
-#if IOEVENT_USE_EPOLL
-  return epoll_wait(ioevent->poll_fd, ioevent->events, ioevent->size, ioevent->timeout);
+#ifdef OS_LINUX
+#if IOEVENT_USE_URING
+    if (ioevent->use_io_uring) {
+        int result;
+        result = io_uring_wait_cqe_timeout(&ioevent->ring,
+                &ioevent->cqe, &ioevent->timeout);
+        if (result < 0) {
+            errno = -result;
+            return -1;
+        }
+        return 0;
+    } else {
+#endif
+        return epoll_wait(ioevent->poll_fd, ioevent->events,
+                ioevent->size, ioevent->timeout_ms);
+#if IOEVENT_USE_URING
+    }
+#endif
+
 #elif IOEVENT_USE_KQUEUE
-  return kevent(ioevent->poll_fd, NULL, 0, ioevent->events, ioevent->size, &ioevent->timeout);
+  return kevent(ioevent->poll_fd, NULL, 0, ioevent->events,
+          ioevent->size, &ioevent->timeout);
 #elif IOEVENT_USE_PORT
   int result;
   int retval;
   unsigned int nget = 1;
-  if((retval = port_getn(ioevent->poll_fd, ioevent->events,
+  if((retval=port_getn(ioevent->poll_fd, ioevent->events,
           ioevent->size, &nget, &ioevent->timeout)) == 0)
   {
     result = (int)nget;
@@ -225,4 +325,3 @@ int ioevent_poll(IOEventPoller *ioevent)
 #error port me
 #endif
 }
-

src/ioevent.h

@@ -20,17 +20,28 @@
 #include <poll.h>
 #include <sys/time.h>
 #include "_os_define.h"
+#include "logger.h"
 
-#define IOEVENT_TIMEOUT  0x8000
+#define IOEVENT_TIMEOUT  (1 << 20)
+#define IOEVENT_NOTIFY   (1 << 21)  //for io_uring send_zc done callback
 
-#if IOEVENT_USE_EPOLL
+#ifdef OS_LINUX
 #include <sys/epoll.h>
 #define IOEVENT_EDGE_TRIGGER EPOLLET
+#endif
 
+#if IOEVENT_USE_EPOLL
 #define IOEVENT_READ  EPOLLIN
 #define IOEVENT_WRITE EPOLLOUT
 #define IOEVENT_ERROR (EPOLLERR | EPOLLPRI | EPOLLHUP)
 
+#elif IOEVENT_USE_URING
+#include <sys/mount.h>
+#include <liburing.h>
+#define IOEVENT_READ  POLLIN
+#define IOEVENT_WRITE POLLOUT
+#define IOEVENT_ERROR (POLLERR | POLLPRI | POLLHUP)
+
 #elif IOEVENT_USE_KQUEUE
 #include <sys/event.h>
 #include <sys/poll.h>
@@ -65,18 +76,33 @@ int kqueue_ev_convert(int16_t event, uint16_t flags);
 #endif
 
 typedef struct ioevent_puller {
+    const char *service_name;
     int size;  //max events (fd)
     int extra_events;
-    int poll_fd;
 
+#if IOEVENT_USE_URING
+    struct io_uring ring;
+    int submit_count;
+    bool send_zc_logged;
+    bool send_zc_done_notify; //if callback when send_zc done
+    bool use_io_uring;
+#endif
+
+    int poll_fd;
     struct {
         int index;
         int count;
     } iterator;  //for deal event loop
 
-#if IOEVENT_USE_EPOLL
+#ifdef OS_LINUX
     struct epoll_event *events;
-    int timeout;
+    int timeout_ms;   //for epoll
+#if IOEVENT_USE_URING
+    struct io_uring_cqe *cqe;
+    struct __kernel_timespec timeout;
+#endif
+    bool zero_timeout;
+
 #elif IOEVENT_USE_KQUEUE
     struct kevent *events;
     struct timespec timeout;
@@ -84,9 +110,10 @@ typedef struct ioevent_puller {
     port_event_t *events;
     timespec_t timeout;
 #endif
+
 } IOEventPoller;
 
-#if IOEVENT_USE_EPOLL
+#if OS_LINUX
   #define IOEVENT_GET_EVENTS(ioevent, index) \
       (ioevent)->events[index].events
 #elif IOEVENT_USE_KQUEUE
@@ -99,7 +126,7 @@ typedef struct ioevent_puller {
 #error port me
 #endif
 
-#if IOEVENT_USE_EPOLL
+#ifdef OS_LINUX
   #define IOEVENT_GET_DATA(ioevent, index)  \
       (ioevent)->events[index].data.ptr
 #elif IOEVENT_USE_KQUEUE
@@ -112,7 +139,7 @@ typedef struct ioevent_puller {
 #error port me
 #endif
 
-#if IOEVENT_USE_EPOLL
+#ifdef OS_LINUX
   #define IOEVENT_CLEAR_DATA(ioevent, index)  \
       (ioevent)->events[index].data.ptr = NULL
 #elif IOEVENT_USE_KQUEUE
@@ -129,24 +156,39 @@ typedef struct ioevent_puller {
 extern "C" {
 #endif
 
-int ioevent_init(IOEventPoller *ioevent, const int size,
-    const int timeout_ms, const int extra_events);
+int ioevent_init(IOEventPoller *ioevent, const char *service_name,
+        const bool use_io_uring, const int size, const int timeout_ms,
+        const int extra_events);
 void ioevent_destroy(IOEventPoller *ioevent);
 
-int ioevent_attach(IOEventPoller *ioevent, const int fd, const int e,
-    void *data);
-int ioevent_modify(IOEventPoller *ioevent, const int fd, const int e,
-    void *data);
+int ioevent_attach(IOEventPoller *ioevent, const int fd,
+        const int e, void *data);
+int ioevent_modify(IOEventPoller *ioevent, const int fd,
+        const int e, void *data);
 int ioevent_detach(IOEventPoller *ioevent, const int fd);
 int ioevent_poll(IOEventPoller *ioevent);
 
-static inline void ioevent_set_timeout(IOEventPoller *ioevent, const int timeout_ms)
+static inline void ioevent_set_timeout(IOEventPoller *ioevent,
+        const int timeout_ms)
 {
 #if IOEVENT_USE_EPOLL
-  ioevent->timeout = timeout_ms;
+    ioevent->timeout_ms = timeout_ms;
 #else
-  ioevent->timeout.tv_sec = timeout_ms / 1000;
-  ioevent->timeout.tv_nsec = 1000000 * (timeout_ms % 1000);
+#if IOEVENT_USE_URING
+    if (!ioevent->use_io_uring) {
+        ioevent->timeout_ms = timeout_ms;
+    } else {
+#endif
+        ioevent->timeout.tv_sec = timeout_ms / 1000;
+        ioevent->timeout.tv_nsec = 1000000 * (timeout_ms % 1000);
+
+#if IOEVENT_USE_URING
+    }
+#endif
+#endif
+
+#ifdef OS_LINUX
+    ioevent->zero_timeout = (timeout_ms == 0);
 #endif
 }
 
@@ -156,6 +198,114 @@ static inline int ioevent_poll_ex(IOEventPoller *ioevent, const int timeout_ms)
   return ioevent_poll(ioevent);
 }
 
+#if IOEVENT_USE_URING
+static inline void ioevent_set_send_zc_done_notify(
+        IOEventPoller *ioevent, const bool need_notify)
+{
+    ioevent->send_zc_done_notify = need_notify;
+}
+
+static inline int ioevent_uring_submit(IOEventPoller *ioevent)
+{
+    int result;
+
+    ioevent->submit_count = 0;
+    while (1) {
+        result = io_uring_submit(&ioevent->ring);
+        if (result < 0) {
+            if (result != -EINTR) {
+                return -result;
+            }
+        } else {
+            return 0;
+        }
+    }
+}
+
+static inline struct io_uring_sqe *ioevent_uring_get_sqe(IOEventPoller *ioevent)
+{
+    struct io_uring_sqe *sqe = io_uring_get_sqe(&ioevent->ring);
+    if (sqe == NULL) {
+        logError("file: "__FILE__", line: %d, "
+                "io_uring_get_sqe fail", __LINE__);
+    }
+    return sqe;
+}
+
+static inline void ioevent_uring_prep_recv(IOEventPoller *ioevent,
+        struct io_uring_sqe *sqe, int sockfd,
+        void *buf, size_t size, void *user_data)
+{
+    io_uring_prep_recv(sqe, sockfd, buf, size, 0);
+    sqe->user_data = (long)user_data;
+    ioevent->submit_count++;
+}
+
+static inline void ioevent_uring_prep_send(IOEventPoller *ioevent,
+        struct io_uring_sqe *sqe, int sockfd,
+        void *buf, size_t len, void *user_data)
+{
+    io_uring_prep_send(sqe, sockfd, buf, len, 0);
+    sqe->user_data = (long)user_data;
+    ioevent->submit_count++;
+}
+
+static inline void ioevent_uring_prep_writev(IOEventPoller *ioevent,
+        struct io_uring_sqe *sqe, int sockfd, const struct iovec *iovecs,
+        unsigned nr_vecs, void *user_data)
+{
+    io_uring_prep_writev(sqe, sockfd, iovecs, nr_vecs, 0);
+    sqe->user_data = (long)user_data;
+    ioevent->submit_count++;
+}
+
+static inline void ioevent_uring_prep_send_zc(IOEventPoller *ioevent,
+        struct io_uring_sqe *sqe, int sockfd,
+        void *buf, size_t len, void *user_data)
+{
+    io_uring_prep_send_zc(sqe, sockfd, buf, len, 0,
+#ifdef IORING_SEND_ZC_REPORT_USAGE
+            IORING_SEND_ZC_REPORT_USAGE
+#else
+            0
+#endif
+            );
+    sqe->user_data = (long)user_data;
+    ioevent->submit_count++;
+}
+
+static inline void ioevent_uring_prep_close(IOEventPoller *ioevent,
+        struct io_uring_sqe *sqe, int fd, void *user_data)
+{
+    io_uring_prep_close(sqe, fd);
+    if (user_data == NULL) {
+        /* set sqe->flags MUST after io_uring_prep_xxx */
+        sqe->flags = IOSQE_CQE_SKIP_SUCCESS;
+    } else {
+        sqe->user_data = (long)user_data;
+    }
+    ioevent->submit_count++;
+}
+
+static inline void ioevent_uring_prep_cancel(IOEventPoller *ioevent,
+        struct io_uring_sqe *sqe, void *user_data)
+{
+    io_uring_prep_cancel(sqe, user_data, 0);
+    sqe->user_data = (long)user_data;
+    ioevent->submit_count++;
+}
+
+static inline void ioevent_uring_prep_connect(IOEventPoller *ioevent,
+        struct io_uring_sqe *sqe, int fd, const struct sockaddr *addr,
+        socklen_t addrlen, void *user_data)
+{
+    io_uring_prep_connect(sqe, fd, addr, addrlen);
+    sqe->user_data = (long)user_data;
+    ioevent->submit_count++;
+}
+
+#endif
+
 #ifdef __cplusplus
 }
 #endif

src/ioevent_loop.c

@@ -17,6 +17,76 @@
 #include "logger.h"
 #include "ioevent_loop.h"
 
+#if IOEVENT_USE_URING
+static int ioevent_process_by_uring(IOEventPoller *ioevent)
+{
+    int result;
+    unsigned head;
+    unsigned count = 0;
+	IOEventEntry *pEntry;
+
+    result = io_uring_wait_cqe_timeout(&ioevent->ring,
+            &ioevent->cqe, &ioevent->timeout);
+    switch (result) {
+        case 0:
+            break;
+        case -ETIME:
+        case -EINTR:
+            return 0;
+        default:
+            result *= -1;
+            logError("file: "__FILE__", line: %d, "
+                    "io_uring_wait_cqe fail, errno: %d, error info: %s",
+                    __LINE__, result, STRERROR(result));
+            return result;
+    }
+
+    io_uring_for_each_cqe(&ioevent->ring, head, ioevent->cqe) {
+        count++;
+        pEntry = (IOEventEntry *)ioevent->cqe->user_data;
+        if (pEntry != NULL) {
+            if (ioevent->cqe->flags & IORING_CQE_F_NOTIF) {
+                if (ioevent->send_zc_done_notify) {
+                    pEntry->callback(pEntry->fd, IOEVENT_NOTIFY, pEntry);
+                }
+
+#ifdef IORING_NOTIF_USAGE_ZC_COPIED
+                if (!ioevent->send_zc_logged) {
+                    struct fast_task_info *task;
+
+                    task = (struct fast_task_info *)pEntry;
+                    ioevent->send_zc_logged = true;
+                    if (ioevent->cqe->res & IORING_NOTIF_USAGE_ZC_COPIED) {
+                        logWarning("file: "__FILE__", line: %d, %s "
+                                "client %s:%u, io_uring send_zc: memory "
+                                "copy instead of zero copy!", __LINE__,
+                                ioevent->service_name, task->client_ip,
+                                task->port);
+                    } else {
+                        logInfo("file: "__FILE__", line: %d, %s "
+                                "client %s:%u, io_uring send_zc: zero "
+                                "copy OK.", __LINE__, ioevent->service_name,
+                                task->client_ip, task->port);
+                    }
+                }
+#endif
+            } else {
+                pEntry->res = ioevent->cqe->res;
+                pEntry->callback(pEntry->fd, 0, pEntry);
+            }
+        } else {
+            logWarning("file: "__FILE__", line: %d, "
+                    "io_uring unexpected flags: %d, result: %d", __LINE__,
+                    ioevent->cqe->flags, ioevent->cqe->res);
+        }
+    }
+
+    io_uring_cq_advance(&ioevent->ring, count);
+    return 0;
+}
+
+#endif
+
 static void deal_ioevents(IOEventPoller *ioevent)
 {
 	int event;
@@ -39,35 +109,25 @@ static void deal_ioevents(IOEventPoller *ioevent)
 	}
 }
 
-int ioevent_remove(IOEventPoller *ioevent, void *data)
+static int ioevent_process_by_poll(IOEventPoller *ioevent)
 {
-	IOEventEntry *pEntry;
-    int index;
+    int result;
 
-    if (ioevent->iterator.index >= ioevent->iterator.count)
-    {
-        return ENOENT;
+    ioevent->iterator.count = ioevent_poll(ioevent);
+    if (ioevent->iterator.count > 0) {
+        deal_ioevents(ioevent);
     }
-
-    pEntry = (IOEventEntry *)IOEVENT_GET_DATA(ioevent,
-            ioevent->iterator.index);
-    if (pEntry != NULL && (void *)pEntry == data) {
-        return 0;  //do NOT clear current entry
-    }
-
-    for (index=ioevent->iterator.index + 1; index < ioevent->iterator.count;
-            index++)
-    {
-        pEntry = (IOEventEntry *)IOEVENT_GET_DATA(ioevent, index);
-        if (pEntry != NULL && (void *)pEntry == data) {
-            logDebug("file: "__FILE__", line: %d, "
-                    "clear ioevent data: %p", __LINE__, data);
-            IOEVENT_CLEAR_DATA(ioevent, index);
-            return 0;
+    else if (ioevent->iterator.count < 0) {
+        result = errno != 0 ? errno : EINVAL;
+        if (result != EINTR) {
+            logError("file: "__FILE__", line: %d, "
+                    "ioevent_poll fail, errno: %d, error info: %s",
+                    __LINE__, result, STRERROR(result));
+            return result;
         }
     }
 
-    return ENOENT;
+    return 0;
 }
 
 static void deal_timeouts(FastTimerEntry *head)
@@ -82,16 +142,14 @@ static void deal_timeouts(FastTimerEntry *head)
 		current = entry;
 		entry = entry->next;
 
-        current->prev = current->next = NULL; //must set NULL because NOT in time wheel
+        /* must set NULL because NOT in time wheel */
+        current->prev = current->next = NULL;
 		pEventEntry = (IOEventEntry *)current;
-		if (pEventEntry != NULL)
-		{
-			pEventEntry->callback(pEventEntry->fd, IOEVENT_TIMEOUT, current);
-		}
+        pEventEntry->callback(pEventEntry->fd, IOEVENT_TIMEOUT, current);
 	}
 }
 
-int ioevent_loop(struct nio_thread_data *pThreadData,
+int ioevent_loop(struct nio_thread_data *thread_data,
 	IOEventCallback recv_notify_callback, TaskCleanUpCallback
 	clean_up_callback, volatile bool *continue_flag)
 {
@@ -100,90 +158,133 @@ int ioevent_loop(struct nio_thread_data *pThreadData,
 	FastTimerEntry head;
 	struct fast_task_info *task;
 	time_t last_check_time;
+    int save_extra_events;
 	int count;
+#ifdef OS_LINUX
+    uint32_t sched_counter;
+#endif
+    bool sched_pull;
 
 	memset(&ev_notify, 0, sizeof(ev_notify));
-	ev_notify.event.fd = FC_NOTIFY_READ_FD(pThreadData);
+	ev_notify.event.fd = FC_NOTIFY_READ_FD(thread_data);
 	ev_notify.event.callback = recv_notify_callback;
-	ev_notify.thread_data = pThreadData;
-	if (ioevent_attach(&pThreadData->ev_puller,
-		pThreadData->pipe_fds[0], IOEVENT_READ,
-		&ev_notify) != 0)
+	ev_notify.thread_data = thread_data;
+
+    save_extra_events = thread_data->ev_puller.extra_events;
+    thread_data->ev_puller.extra_events = 0; //disable edge trigger temporarily
+	if (ioevent_attach(&thread_data->ev_puller, ev_notify.
+                event.fd, IOEVENT_READ, &ev_notify) != 0)
 	{
 		result = errno != 0 ? errno : ENOMEM;
-		logCrit("file: "__FILE__", line: %d, " \
-			"ioevent_attach fail, " \
-			"errno: %d, error info: %s", \
+		logCrit("file: "__FILE__", line: %d, "
+			"ioevent_attach fail, errno: %d, error info: %s",
 			__LINE__, result, STRERROR(result));
 		return result;
 	}
+    thread_data->ev_puller.extra_events = save_extra_events; //restore
 
-    pThreadData->deleted_list = NULL;
+#ifdef OS_LINUX
+    sched_counter = 0;
+#endif
+
+    thread_data->deleted_list = NULL;
 	last_check_time = g_current_time;
-	while (*continue_flag)
-	{
-		pThreadData->ev_puller.iterator.count = ioevent_poll(
-                &pThreadData->ev_puller);
-		if (pThreadData->ev_puller.iterator.count > 0)
-		{
-			deal_ioevents(&pThreadData->ev_puller);
-		}
-		else if (pThreadData->ev_puller.iterator.count < 0)
-		{
-			result = errno != 0 ? errno : EINVAL;
-			if (result != EINTR)
-			{
-				logError("file: "__FILE__", line: %d, " \
-					"ioevent_poll fail, " \
-					"errno: %d, error info: %s", \
-					__LINE__, result, STRERROR(result));
-				return result;
-			}
-		}
+	while (*continue_flag) {
+#ifdef OS_LINUX
+        if (thread_data->ev_puller.zero_timeout) {
+            sched_pull = (sched_counter++ & 8) != 0;
+        } else {
+            sched_pull = true;
+        }
+#else
+        sched_pull = true;
+#endif
 
-		if (pThreadData->deleted_list != NULL)
-		{
-			count = 0;
-			while (pThreadData->deleted_list != NULL)
-			{
-				task = pThreadData->deleted_list;
-				pThreadData->deleted_list = task->next;
+#if IOEVENT_USE_URING
+        if (thread_data->ev_puller.use_io_uring) {
+            if (thread_data->ev_puller.submit_count > 0) {
+                if ((result=ioevent_uring_submit(&thread_data->
+                                ev_puller)) != 0)
+                {
+                    logError("file: "__FILE__", line: %d, "
+                            "io_uring_submit fail, errno: %d, error info: %s",
+                            __LINE__, result, STRERROR(result));
+                    return result;
+                }
+            }
+        }
+#endif
 
+        if (sched_pull) {
+#if IOEVENT_USE_URING
+            if (thread_data->ev_puller.use_io_uring) {
+                if ((result=ioevent_process_by_uring(&thread_data->
+                                ev_puller)) != 0)
+                {
+                    return result;
+                }
+            } else {
+#endif
+                if ((result=ioevent_process_by_poll(&thread_data->
+                                ev_puller)) != 0)
+                {
+                    return result;
+                }
+#if IOEVENT_USE_URING
+            }
+#endif
+        }
+
+        if (thread_data->busy_polling_callback != NULL) {
+            thread_data->busy_polling_callback(thread_data);
+        }
+
+		if (thread_data->deleted_list != NULL) {
+			//count = 0;
+			while (thread_data->deleted_list != NULL) {
+				task = thread_data->deleted_list;
+				thread_data->deleted_list = task->next;
+
+                if (task->polling.in_queue) {
+                    fc_list_del_init(&task->polling.dlink);
+                    task->polling.in_queue = false;
+                    if (fc_list_empty(&task->thread_data->polling_queue)) {
+                        ioevent_set_timeout(&task->thread_data->ev_puller,
+                                task->thread_data->timeout_ms);
+                    }
+                }
 				clean_up_callback(task);
-				count++;
+				//count++;
 			}
 			//logInfo("cleanup task count: %d", count);
 		}
 
-		if (g_current_time - last_check_time > 0)
-		{
+		if (g_current_time - last_check_time > 0) {
 			last_check_time = g_current_time;
 			count = fast_timer_timeouts_get(
-				&pThreadData->timer, g_current_time, &head);
+				&thread_data->timer, g_current_time, &head);
 			if (count > 0)
 			{
 				deal_timeouts(&head);
 			}
 		}
 
-        if (pThreadData->notify.enabled)
-        {
+        if (thread_data->notify.enabled) {
             int64_t n;
-            if ((n=__sync_fetch_and_add(&pThreadData->notify.counter, 0)) != 0)
+            if ((n=__sync_fetch_and_add(&thread_data->notify.counter, 0)) != 0)
             {
-                __sync_fetch_and_sub(&pThreadData->notify.counter, n);
+                __sync_fetch_and_sub(&thread_data->notify.counter, n);
                 /*
                 logInfo("file: "__FILE__", line: %d, "
                         "n ==== %"PRId64", now: %"PRId64,
                         __LINE__, n, __sync_fetch_and_add(
-                            &pThreadData->notify.counter, 0));
+                            &thread_data->notify.counter, 0));
                             */
             }
         }
 
-        if (pThreadData->thread_loop_callback != NULL)
-        {
-            pThreadData->thread_loop_callback(pThreadData);
+        if (thread_data->thread_loop_callback != NULL) {
+            thread_data->thread_loop_callback(thread_data);
         }
 	}
 
@@ -191,25 +292,64 @@ int ioevent_loop(struct nio_thread_data *pThreadData,
 }
 
 int ioevent_set(struct fast_task_info *task, struct nio_thread_data *pThread,
-	int sock, short event, IOEventCallback callback, const int timeout)
+        int sock, short event, IOEventCallback callback,
+        const int timeout)
 {
 	int result;
 
 	task->thread_data = pThread;
 	task->event.fd = sock;
 	task->event.callback = callback;
-	if (ioevent_attach(&pThread->ev_puller,
-		sock, event, task) < 0)
-	{
-		result = errno != 0 ? errno : ENOENT;
-		logError("file: "__FILE__", line: %d, " \
-			"ioevent_attach fail, " \
-			"errno: %d, error info: %s", \
-			__LINE__, result, STRERROR(result));
-		return result;
-	}
+#if IOEVENT_USE_URING
+    if (pThread->ev_puller.use_io_uring) {
+        if (FC_URING_OP_TYPE(task) == IORING_OP_NOP) {
+            if ((result=uring_prep_first_recv(task)) != 0) {
+                logError("file: "__FILE__", line: %d, "
+                        "uring_prep_recv fail, fd: %d, "
+                        "errno: %d, error info: %s",
+                        __LINE__, sock, result, STRERROR(result));
+                return result;
+            }
+        } else {
+            /*
+            logWarning("file: "__FILE__", line: %d, "
+                    "skip uring_prep_recv, fd: %d, port: %d, "
+                    "in progress op type: %d, timeout: %"PRId64,
+                    __LINE__, sock, task->port, FC_URING_OP_TYPE(task),
+                    task->event.timer.expires);
+                    */
+        }
+    } else {
+#endif
+        if (ioevent_attach(&pThread->ev_puller, sock, event, task) < 0) {
+            result = errno != 0 ? errno : ENOENT;
+            logError("file: "__FILE__", line: %d, "
+                    "ioevent_attach fail, fd: %d, "
+                    "errno: %d, error info: %s",
+                    __LINE__, sock, result, STRERROR(result));
+            return result;
+        }
+#if IOEVENT_USE_URING
+    }
+#endif
 
 	task->event.timer.expires = g_current_time + timeout;
 	fast_timer_add(&pThread->timer, &task->event.timer);
 	return 0;
 }
+
+int ioevent_reset(struct fast_task_info *task, int new_fd, short event)
+{
+    if (task->event.fd == new_fd)
+    {
+        return 0;
+    }
+
+    if (task->event.fd >= 0)
+    {
+        ioevent_detach(&task->thread_data->ev_puller, task->event.fd);
+    }
+
+    task->event.fd = new_fd;
+    return ioevent_attach(&task->thread_data->ev_puller, new_fd, event, task);
+}

src/ioevent_loop.h

@@ -17,20 +17,33 @@
 #define _IOEVENT_LOOP_H
 
 #include "fast_task_queue.h"
+#if IOEVENT_USE_URING
+#include "sockopt.h"
+#endif
+
+#define fc_hold_task_ex(task, inc_count) __sync_add_and_fetch( \
+        &task->reffer_count, inc_count)
+
+#define fc_hold_task(task)  fc_hold_task_ex(task, 1)
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-int ioevent_loop(struct nio_thread_data *pThreadData,
+int ioevent_loop(struct nio_thread_data *thread_data,
 	IOEventCallback recv_notify_callback, TaskCleanUpCallback
 	clean_up_callback, volatile bool *continue_flag);
 
-//remove entry from ready list
-int ioevent_remove(IOEventPoller *ioevent, void *data);
+int ioevent_set(struct fast_task_info *task, struct nio_thread_data *pThread,
+        int sock, short event, IOEventCallback callback,
+        const int timeout);
 
-int ioevent_set(struct fast_task_info *pTask, struct nio_thread_data *pThread,
-	int sock, short event, IOEventCallback callback, const int timeout);
+int ioevent_reset(struct fast_task_info *task, int new_fd, short event);
+
+static inline bool ioevent_is_canceled(struct fast_task_info *task)
+{
+    return __sync_fetch_and_add(&task->canceled, 0) != 0;
+}
 
 //only called by the nio thread
 static inline void ioevent_add_to_deleted_list(struct fast_task_info *task)
@@ -68,9 +81,170 @@ static inline int ioevent_notify_thread(struct nio_thread_data *thread_data)
     return 0;
 }
 
+#if IOEVENT_USE_URING
+
+#define SET_OP_TYPE_AND_HOLD_TASK(task, _op_type) \
+    struct io_uring_sqe *sqe; \
+    if ((sqe=ioevent_uring_get_sqe(&task->thread_data->ev_puller)) == NULL) { \
+        return ENOSPC; \
+    } \
+    FC_URING_OP_TYPE(task) = _op_type; \
+    fc_hold_task(task)
+
+static inline int uring_prep_recv_data(struct fast_task_info *task,
+        char *buff, const int len)
+{
+    SET_OP_TYPE_AND_HOLD_TASK(task, IORING_OP_RECV);
+    ioevent_uring_prep_recv(&task->thread_data->ev_puller,
+            sqe, task->event.fd, buff, len, task);
+    return 0;
+}
+
+static inline int uring_prep_first_recv(struct fast_task_info *task)
+{
+    SET_OP_TYPE_AND_HOLD_TASK(task, IORING_OP_RECV);
+    ioevent_uring_prep_recv(&task->thread_data->ev_puller,
+            sqe, task->event.fd, task->recv.ptr->data,
+            task->recv.ptr->size, task);
+    return 0;
+}
+
+static inline int uring_prep_next_recv(struct fast_task_info *task)
+{
+    SET_OP_TYPE_AND_HOLD_TASK(task, IORING_OP_RECV);
+    ioevent_uring_prep_recv(&task->thread_data->ev_puller, sqe,
+            task->event.fd, task->recv.ptr->data + task->recv.ptr->offset,
+            task->recv.ptr->length - task->recv.ptr->offset, task);
+    return 0;
+}
+
+static inline int uring_prep_first_send(struct fast_task_info *task)
+{
+    if (task->iovec_array.iovs != NULL) {
+        SET_OP_TYPE_AND_HOLD_TASK(task, IORING_OP_WRITEV);
+        ioevent_uring_prep_writev(&task->thread_data->ev_puller,
+                sqe, task->event.fd, task->iovec_array.iovs,
+                FC_MIN(task->iovec_array.count, IOV_MAX),
+                task);
+    } else {
+        SET_OP_TYPE_AND_HOLD_TASK(task, IORING_OP_SEND);
+        ioevent_uring_prep_send(&task->thread_data->ev_puller,
+                sqe, task->event.fd, task->send.ptr->data,
+                task->send.ptr->length, task);
+    }
+    return 0;
+}
+
+static inline int uring_prep_next_send(struct fast_task_info *task)
+{
+    if (task->iovec_array.iovs != NULL) {
+        SET_OP_TYPE_AND_HOLD_TASK(task, IORING_OP_WRITEV);
+        ioevent_uring_prep_writev(&task->thread_data->ev_puller,
+                sqe, task->event.fd, task->iovec_array.iovs,
+                FC_MIN(task->iovec_array.count, IOV_MAX),
+                task);
+    } else {
+        SET_OP_TYPE_AND_HOLD_TASK(task, IORING_OP_SEND);
+        ioevent_uring_prep_send(&task->thread_data->ev_puller, sqe,
+                task->event.fd, task->send.ptr->data + task->send.ptr->offset,
+                task->send.ptr->length - task->send.ptr->offset, task);
+    }
+    return 0;
+}
+
+static inline int uring_prep_first_send_zc(struct fast_task_info *task)
+{
+    if (task->iovec_array.iovs != NULL) {
+        SET_OP_TYPE_AND_HOLD_TASK(task, IORING_OP_WRITEV);
+        ioevent_uring_prep_writev(&task->thread_data->ev_puller,
+                sqe, task->event.fd, task->iovec_array.iovs,
+                FC_MIN(task->iovec_array.count, IOV_MAX),
+                task);
+    } else if (task->send.ptr->length < 4096) {
+        SET_OP_TYPE_AND_HOLD_TASK(task, IORING_OP_SEND);
+        ioevent_uring_prep_send(&task->thread_data->ev_puller,
+                sqe, task->event.fd, task->send.ptr->data,
+                task->send.ptr->length, task);
+    } else {
+        SET_OP_TYPE_AND_HOLD_TASK(task, IORING_OP_SEND_ZC);
+        ioevent_uring_prep_send_zc(&task->thread_data->ev_puller,
+                sqe, task->event.fd, task->send.ptr->data,
+                task->send.ptr->length, task);
+    }
+    return 0;
+}
+
+static inline int uring_prep_next_send_zc(struct fast_task_info *task)
+{
+    if (task->iovec_array.iovs != NULL) {
+        SET_OP_TYPE_AND_HOLD_TASK(task, IORING_OP_WRITEV);
+        ioevent_uring_prep_writev(&task->thread_data->ev_puller,
+                sqe, task->event.fd, task->iovec_array.iovs,
+                FC_MIN(task->iovec_array.count, IOV_MAX),
+                task);
+    } else if (task->send.ptr->length - task->send.ptr->offset < 4096) {
+        SET_OP_TYPE_AND_HOLD_TASK(task, IORING_OP_SEND);
+        ioevent_uring_prep_send(&task->thread_data->ev_puller, sqe,
+                task->event.fd, task->send.ptr->data + task->send.ptr->offset,
+                task->send.ptr->length - task->send.ptr->offset, task);
+    } else {
+        SET_OP_TYPE_AND_HOLD_TASK(task, IORING_OP_SEND_ZC);
+        ioevent_uring_prep_send_zc(&task->thread_data->ev_puller, sqe,
+                task->event.fd, task->send.ptr->data + task->send.ptr->offset,
+                task->send.ptr->length - task->send.ptr->offset, task);
+    }
+    return 0;
+}
+
+static inline int uring_prep_close_fd(struct fast_task_info *task)
+{
+    struct io_uring_sqe *sqe;
+
+    if ((sqe=ioevent_uring_get_sqe(&task->thread_data->ev_puller)) == NULL) {
+        return ENOSPC;
+    }
+
+    /* do NOT need callback */
+    ioevent_uring_prep_close(&task->thread_data->
+            ev_puller, sqe, task->event.fd, NULL);
+    return 0;
+}
+
+static inline int uring_prep_cancel(struct fast_task_info *task)
+{
+    SET_OP_TYPE_AND_HOLD_TASK(task, IORING_OP_ASYNC_CANCEL);
+    ioevent_uring_prep_cancel(&task->thread_data->ev_puller, sqe, task);
+    return 0;
+}
+
+static inline int uring_prep_connect(struct fast_task_info *task)
+{
+    int result;
+    sockaddr_convert_t *convert;
+
+    if ((task->event.fd=socketCreateEx2(AF_UNSPEC, task->server_ip,
+                    O_NONBLOCK, NULL, &result)) < 0)
+    {
+        return result;
+    }
+
+    convert = (sockaddr_convert_t *)(task->send.ptr->data +
+            task->send.ptr->size - 2 * sizeof(sockaddr_convert_t));
+    if ((result=setsockaddrbyip(task->server_ip, task->port, convert)) != 0) {
+        return result;
+    }
+
+    do {
+        SET_OP_TYPE_AND_HOLD_TASK(task, IORING_OP_CONNECT);
+        ioevent_uring_prep_connect(&task->thread_data->ev_puller, sqe,
+                task->event.fd, &convert->sa.addr, convert->len, task);
+    } while (0);
+    return 0;
+}
+#endif
+
 #ifdef __cplusplus
 }
 #endif
 
 #endif
-

src/json_parser.c

@@ -29,7 +29,7 @@
      (ch >= '0' && ch <= '9') || (ch == '_' || ch == '-'  || \
          ch == '.'))
 
-int detect_json_type(const string_t *input)
+int fc_detect_json_type(const string_t *input)
 {
     if (input->len < 2) {
         return FC_JSON_TYPE_STRING;
@@ -45,18 +45,9 @@ int detect_json_type(const string_t *input)
     return FC_JSON_TYPE_STRING;
 }
 
-typedef struct {
-    const char *str;  //input string
-    const char *p;    //current
-    const char *end;
-    string_t element;
-    char *error_info;
-    int error_size;
-} ParseContext;
-
 static void set_parse_error(const char *str, const char *current,
         const int expect_len, const char *front,
-        char *error_info, const int error_size)
+        string_t *error_info, const int error_size)
 {
     const char *show_str;
     int show_len;
@@ -66,26 +57,18 @@ static void set_parse_error(const char *str, const char *current,
         show_len = expect_len;
     }
     show_str = current - show_len;
-    snprintf(error_info, error_size, "%s, input: %.*s",
-            front, show_len, show_str);
+    error_info->len = snprintf(error_info->str, error_size,
+            "%s, input: %.*s", front, show_len, show_str);
 }
 
-static int json_escape_string(const string_t *input, string_t *output,
-        char *error_info, const int error_size)
+static int json_escape_string(fc_json_context_t *context,
+        const string_t *input, char *output)
 {
     const char *src;
     const char *end;
     char *dest;
-    int size;
 
-    size = 2 * input->len + 1;
-    output->str = (char *)fc_malloc(size);
-    if (output->str == NULL) {
-        snprintf(error_info, error_size, "malloc %d bytes fail", size);
-        return ENOMEM;
-    }
-
-    dest = output->str;
+    dest = output;
     end = input->str + input->len;
     for (src=input->str; src<end; src++) {
         switch (*src) {
@@ -109,13 +92,21 @@ static int json_escape_string(const string_t *input, string_t *output,
                 *dest++ = '\\';
                 *dest++ = 'b';
                 break;
+            case '\f':
+                *dest++ = '\\';
+                *dest++ = 'f';
+                break;
             case '\"':
                 *dest++ = '\\';
                 *dest++ = '\"';
                 break;
-            case '\'':
+            case '\0':
                 *dest++ = '\\';
-                *dest++ = '\'';
+                *dest++ = 'u';
+                *dest++ = '0';
+                *dest++ = '0';
+                *dest++ = '0';
+                *dest++ = '0';
                 break;
             default:
                 *dest++ = *src;
@@ -123,18 +114,19 @@ static int json_escape_string(const string_t *input, string_t *output,
         }
     }
 
-    *dest = '\0';
-    output->len = dest - output->str;
-    return 0;
+    return dest - output;
 }
 
-static int next_json_element(ParseContext *context)
+static int next_json_element(fc_json_context_t *context)
 {
     char *dest;
+    const char *start;
     char buff[128];
     char quote_ch;
+    int unicode;
+    int i;
 
-    dest = context->element.str;
+    dest = context->decode.element.str;
     quote_ch = *context->p;
     if (quote_ch == '\"' || quote_ch == '\'') {
         context->p++;
@@ -143,9 +135,42 @@ static int next_json_element(ParseContext *context)
                 if (++context->p == context->end) {
                     set_parse_error(context->str, context->p,
                             EXPECT_STR_LEN, "expect a character after \\",
-                            context->error_info, context->error_size);
+                            &context->error_info, context->error_size);
                     return EINVAL;
                 }
+
+                if (*context->p == 'u') {  //unicode
+                    start = ++context->p;  //skip charator 'u'
+                    i = 0;
+                    while (i < 4 && context->p < context->end &&
+                            IS_HEX_CHAR(*context->p))
+                    {
+                        buff[i++] = *context->p;
+                        ++context->p;
+                    }
+                    if (i != 4) {
+                        set_parse_error(context->str, start,
+                                EXPECT_STR_LEN, "expect 4 hex characters "
+                                "after \\u", &context->error_info,
+                                context->error_size);
+                        return EINVAL;
+                    }
+
+                    buff[i] = '\0';
+                    unicode = strtol(buff, NULL, 16);
+                    if (unicode < 0x80) {
+                        *dest++ = unicode;
+                    } else if (unicode < 0x800) {
+                        *dest++ = 0xC0 | ((unicode >> 6) & 0x1F);
+                        *dest++ = 0x80 | (unicode & 0x3F);
+                    } else {
+                        *dest++ = 0xE0 | ((unicode >> 12) & 0x0F);
+                        *dest++ = 0x80 | ((unicode >> 6) & 0x3F);
+                        *dest++ = 0x80 | (unicode & 0x3F);
+                    }
+                    continue;
+                }
+
                 switch (*context->p) {
                     case '\\':
                         *dest++ = '\\';
@@ -162,20 +187,21 @@ static int next_json_element(ParseContext *context)
                     case 'n':
                         *dest++ = '\n';
                         break;
-                    case 'b':
+                    case 'f':
                         *dest++ = '\f';
                         break;
+                    case 'b':
+                        *dest++ = '\b';
+                        break;
                     case '"':
                         *dest++ = '\"';
                         break;
-                    case '\'':
-                        *dest++ = '\'';
-                        break;
                     default:
                         sprintf(buff, "invalid escaped character: %c(0x%x)",
                                 *context->p, (unsigned char)*context->p);
-                        set_parse_error(context->str, context->p + 1, EXPECT_STR_LEN,
-                                buff, context->error_info, context->error_size);
+                        set_parse_error(context->str, context->p + 1,
+                                EXPECT_STR_LEN, buff, &context->error_info,
+                                context->error_size);
                         return EINVAL;
                 }
                 context->p++;
@@ -187,7 +213,7 @@ static int next_json_element(ParseContext *context)
         if (context->p == context->end) {
             sprintf(buff, "expect closed character: %c", quote_ch);
             set_parse_error(context->str, context->p, EXPECT_STR_LEN,
-                    buff, context->error_info, context->error_size);
+                    buff, &context->error_info, context->error_size);
             return EINVAL;
         }
         context->p++; //skip quote char
@@ -198,12 +224,12 @@ static int next_json_element(ParseContext *context)
     }
 
     *dest = '\0';
-    context->element.len = dest - context->element.str;
+    context->decode.element.len = dest - context->decode.element.str;
     return 0;
 }
 
-static int check_alloc_array(common_array_t *array,
-        char *error_info, const int error_size)
+static int check_alloc_array(fc_json_context_t *context,
+        fc_common_array_t *array)
 {
     int bytes;
     if (array->count < array->alloc) {
@@ -219,344 +245,320 @@ static int check_alloc_array(common_array_t *array,
     bytes = array->element_size * array->alloc;
     array->elements = fc_realloc(array->elements, bytes);
     if (array->elements == NULL) {
-        snprintf(error_info, error_size, "realloc %d bytes fail", bytes);
+        context->error_info.len = snprintf(context->error_info.str,
+                context->error_size, "realloc %d bytes fail", bytes);
         return ENOMEM;
     }
 
     return 0;
 }
 
-static inline int check_alloc_json_array(json_array_t *array,
-                char *error_info, const int error_size)
+static int prepare_json_parse(fc_json_context_t *context,
+        const string_t *input, const char lquote,
+        const char rquote)
 {
-    return check_alloc_array((common_array_t *)array, error_info, error_size);
-}
-
-static inline int check_alloc_json_map(json_map_t *array,
-                char *error_info, const int error_size)
-{
-    return check_alloc_array((common_array_t *)array, error_info, error_size);
-}
-
-static int prepare_json_parse(const string_t *input, common_array_t *array,
-        char *error_info, const int error_size,
-        const char lquote, const char rquote, ParseContext *context)
-{
-    int buff_len;
-
-    array->elements = NULL;
-    array->count = array->alloc = 0;
-    array->buff = NULL;
+    int expect_size;
+    int result;
 
     if (input->len < 2) {
-        snprintf(error_info, error_size, "json string is too short");
+        context->error_info.len = snprintf(context->error_info.str,
+                context->error_size, "json string is too short");
         return EINVAL;
     }
 
     if (input->str[0] != lquote) {
-        snprintf(error_info, error_size,
-                "json array must start with \"%c\"", lquote);
+        context->error_info.len = snprintf(context->error_info.str, context->
+                error_size, "json array must start with \"%c\"", lquote);
         return EINVAL;
     }
     if (input->str[input->len - 1] != rquote) {
-        snprintf(error_info, error_size,
-                "json array must end with \"%c\"", rquote);
+        context->error_info.len = snprintf(context->error_info.str, context->
+                error_size, "json array must end with \"%c\"", rquote);
         return EINVAL;
     }
 
-    buff_len = input->len - 2;
-    array->buff = (char *)fc_malloc(buff_len + 1);
-    if (array->buff == NULL) {
-        snprintf(error_info, error_size,
-                "malloc %d bytes fail", buff_len + 1);
-        return ENOMEM;
+    expect_size = input->len;
+    if (context->output.alloc_size < expect_size) {
+        if ((result=fc_realloc_buffer(&context->output, context->
+                        init_buff_size, expect_size)) != 0)
+        {
+            context->error_info.len = snprintf(context->error_info.str,
+                    context->error_size, "realloc buffer fail");
+            return result;
+        }
     }
 
-    context->error_info = error_info;
-    context->error_size = error_size;
-    context->element.str = array->buff;
-    context->element.len = 0;
+    context->decode.element.str = context->output.buff;
+    context->decode.element.len = 0;
     context->str = input->str;
     context->p = input->str + 1;
     context->end = input->str + input->len - 1;
     return 0;
 }
 
-int decode_json_array(const string_t *input, json_array_t *array,
-        char *error_info, const int error_size)
+static inline void json_quote_string(fc_json_context_t
+        *context, const string_t *input, char **buff)
 {
-    ParseContext context;
-    int result;
-
-    array->element_size = sizeof(string_t);
-    if ((result=prepare_json_parse(input, (common_array_t *)array,
-                    error_info, error_size, '[', ']', &context)) != 0)
-    {
-        return result;
-    }
-
-    result = 0;
-    while (context.p < context.end) {
-        while (context.p < context.end && JSON_SPACE(*context.p)) {
-            context.p++;
-        }
-
-        if (context.p == context.end) {
-            break;
-        }
-
-        if (*context.p == ',') {
-            set_parse_error(input->str, context.p + 1,
-                    EXPECT_STR_LEN, "unexpect comma \",\"",
-                    error_info, error_size);
-            result = EINVAL;
-            break;
-        }
-
-        if ((result=next_json_element(&context)) != 0) {
-            break;
-        }
-
-        while (context.p < context.end && JSON_SPACE(*context.p)) {
-            context.p++;
-        }
-        if (context.p < context.end) {
-            if (*context.p == ',') {
-                context.p++;   //skip comma
-            } else {
-                set_parse_error(input->str, context.p,
-                        EXPECT_STR_LEN, "expect comma \",\"",
-                        error_info, error_size);
-                result = EINVAL;
-                break;
-            }
-        }
-
-        if ((result=check_alloc_json_array(array, error_info, error_size)) != 0) {
-            array->count = 0;
-            break;
-        }
-
-        array->elements[array->count++] = context.element;
-        context.element.str += context.element.len + 1;
-    }
-
-    if (result != 0) {
-        free_json_array(array);
-    }
-    return result;
-}
-
-void free_common_array(common_array_t *array)
-{
-    if (array->elements != NULL) {
-        free(array->elements);
-        array->elements = NULL;
-        array->count = 0;
-    }
-
-    if (array->buff != NULL) {
-        free(array->buff);
-        array->buff = NULL;
-    }
-}
-
-static int json_quote_string(const string_t *input, char **buff,
-        char *error_info, const int error_size)
-{
-    int result;
-    string_t escaped;
     char *p;
 
-    if ((result=json_escape_string(input, &escaped,
-                    error_info, error_size)) != 0)
-    {
-        return result;
-    }
-
     p = *buff;
     *p++ = '"';
-    memcpy(p, escaped.str, escaped.len);
-    p += escaped.len;
+    p += json_escape_string(context, input, p);
     *p++ = '"';
-
     *buff = p;
-    free(escaped.str);
-    return 0;
 }
 
-int encode_json_array(json_array_t *array, string_t *output,
-        char *error_info, const int error_size)
+int fc_encode_json_array_ex(fc_json_context_t *context,
+        const string_t *elements, const int count,
+        BufferInfo *buffer)
 {
-    string_t *el;
-    string_t *end;
+    const string_t *el;
+    const string_t *end;
     char *p;
-    int result;
-    int size;
+    int expect_size;
 
-    end = array->elements + array->count;
-    size = 3;
-    for (el=array->elements; el<end; el++) {
-        size += 2 * el->len + 3;
+    expect_size = 3;
+    end = elements + count;
+    for (el=elements; el<end; el++) {
+        expect_size += 6 * el->len + 3;
     }
 
-    output->str = (char *)fc_malloc(size);
-    if (output->str == NULL) {
-        snprintf(error_info, error_size, "malloc %d bytes fail", size);
-        return ENOMEM;
+    if (buffer->alloc_size < expect_size) {
+        if ((context->error_no=fc_realloc_buffer(buffer, context->
+                        init_buff_size, expect_size)) != 0)
+        {
+            context->error_info.len = snprintf(context->error_info.str,
+                    context->error_size, "realloc buffer fail");
+            return context->error_no;
+        }
     }
 
-    p = output->str;
+    p = buffer->buff;
     *p++ = '[';
-    for (el=array->elements; el<end; el++) {
-        if (el > array->elements) {
+    for (el=elements; el<end; el++) {
+        if (el > elements) {
             *p++ = ',';
         }
 
-        if ((result=json_quote_string(el, &p, error_info, error_size)) != 0) {
-            free_json_string(output);
-            return result;
-        }
+        json_quote_string(context, el, &p);
     }
 
     *p++ = ']';
     *p = '\0';
-    output->len = p - output->str;
+    buffer->length = p - buffer->buff;
     return 0;
 }
 
-int decode_json_map(const string_t *input, json_map_t *map,
-        char *error_info, const int error_size)
+int fc_encode_json_map_ex(fc_json_context_t *context,
+        const key_value_pair_t *elements, const int count,
+        BufferInfo *buffer)
 {
-    ParseContext context;
-    key_value_pair_t kv_pair;
-    int result;
-
-    map->element_size = sizeof(key_value_pair_t);
-    if ((result=prepare_json_parse(input, (common_array_t *)map,
-                    error_info, error_size, '{', '}', &context)) != 0)
-    {
-        return result;
-    }
-
-    result = 0;
-    while (context.p < context.end) {
-        while (context.p < context.end && JSON_SPACE(*context.p)) {
-            context.p++;
-        }
-
-        if (context.p == context.end) {
-            break;
-        }
-
-        if (*context.p == ',') {
-            set_parse_error(input->str, context.p + 1,
-                    EXPECT_STR_LEN, "unexpect comma \",\"",
-                    error_info, error_size);
-            result = EINVAL;
-            break;
-        }
-
-        if ((result=next_json_element(&context)) != 0) {
-            break;
-        }
-        while (context.p < context.end && JSON_SPACE(*context.p)) {
-            context.p++;
-        }
-        if (!(context.p < context.end && *context.p == ':')) {
-            set_parse_error(input->str, context.p,
-                    EXPECT_STR_LEN, "expect colon \":\"",
-                    error_info, error_size);
-            result = EINVAL;
-            break;
-        }
-        context.p++;   //skip colon
-
-        kv_pair.key = context.element;
-        context.element.str += context.element.len + 1;
-
-        while (context.p < context.end && JSON_SPACE(*context.p)) {
-            context.p++;
-        }
-        if ((result=next_json_element(&context)) != 0) {
-            break;
-        }
-        while (context.p < context.end && JSON_SPACE(*context.p)) {
-            context.p++;
-        }
-        if (context.p < context.end) {
-            if (*context.p == ',') {
-                context.p++;  //skip comma
-            } else {
-                set_parse_error(input->str, context.p,
-                        EXPECT_STR_LEN, "expect comma \",\"",
-                        error_info, error_size);
-                result = EINVAL;
-                break;
-            }
-        }
-
-        kv_pair.value = context.element;
-        context.element.str += context.element.len + 1;
-
-        if ((result=check_alloc_json_map(map, error_info, error_size)) != 0) {
-            map->count = 0;
-            break;
-        }
-        map->elements[map->count++] = kv_pair;
-    }
-
-    if (result != 0) {
-        free_json_map(map);
-    }
-    return result;
-}
-
-int encode_json_map(json_map_t *map, string_t *output,
-        char *error_info, const int error_size)
-{
-    key_value_pair_t *pair;
-    key_value_pair_t *end;
+    const key_value_pair_t *pair;
+    const key_value_pair_t *end;
     char *p;
-    int result;
-    int size;
+    int expect_size;
 
-    end = map->elements + map->count;
-    size = 3;
-    for (pair=map->elements; pair<end; pair++) {
-        size += 2 * (pair->key.len + pair->value.len + 2) + 1;
+    expect_size = 3;
+    end = elements + count;
+    for (pair=elements; pair<end; pair++) {
+        expect_size += 6 * (pair->key.len + pair->value.len) + 5;
     }
 
-    output->str = (char *)fc_malloc(size);
-    if (output->str == NULL) {
-        snprintf(error_info, error_size, "malloc %d bytes fail", size);
-        return ENOMEM;
+    if (buffer->alloc_size < expect_size) {
+        if ((context->error_no=fc_realloc_buffer(buffer, context->
+                        init_buff_size, expect_size)) != 0)
+        {
+            context->error_info.len = snprintf(context->error_info.str,
+                    context->error_size, "realloc buffer fail");
+            return context->error_no;
+        }
     }
 
-    p = output->str;
+    p = buffer->buff;
     *p++ = '{';
-    for (pair=map->elements; pair<end; pair++) {
-        if (pair > map->elements) {
+    for (pair=elements; pair<end; pair++) {
+        if (pair > elements) {
             *p++ = ',';
         }
 
-        if ((result=json_quote_string(&pair->key, &p,
-                        error_info, error_size)) != 0)
-        {
-            free_json_string(output);
-            return result;
-        }
+        json_quote_string(context, &pair->key, &p);
         *p++ = ':';
-        if ((result=json_quote_string(&pair->value, &p,
-                        error_info, error_size)) != 0)
-        {
-            free_json_string(output);
-            return result;
-        }
+        json_quote_string(context, &pair->value, &p);
     }
 
     *p++ = '}';
     *p = '\0';
-    output->len = p - output->str;
+    buffer->length = p - buffer->buff;
     return 0;
 }
+
+#define JSON_DECODE_COPY_STRING(ctx, input, dest, src) \
+    do { \
+        if ((context->error_no=fast_mpool_alloc_string_ex2(   \
+                        &ctx->decode.mpool, dest, src)) != 0) \
+        { \
+            set_parse_error(input->str, ctx->p, EXPECT_STR_LEN, \
+                    "out of memory", &ctx->error_info, ctx->error_size); \
+            return NULL; \
+        } \
+    } while (0)
+
+
+const fc_json_array_t *fc_decode_json_array(fc_json_context_t
+        *context, const string_t *input)
+{
+    if ((context->error_no=prepare_json_parse(context,
+                    input, '[', ']')) != 0)
+    {
+        return NULL;
+    }
+
+    context->jarray.count = 0;
+    while (context->p < context->end) {
+        while (context->p < context->end && JSON_SPACE(*context->p)) {
+            context->p++;
+        }
+
+        if (context->p == context->end) {
+            break;
+        }
+
+        if (*context->p == ',') {
+            set_parse_error(input->str, context->p + 1,
+                    EXPECT_STR_LEN, "unexpect comma \",\"",
+                    &context->error_info, context->error_size);
+            context->error_no = EINVAL;
+            return NULL;
+        }
+
+        if ((context->error_no=next_json_element(context)) != 0) {
+            return NULL;
+        }
+
+        while (context->p < context->end && JSON_SPACE(*context->p)) {
+            context->p++;
+        }
+        if (context->p < context->end) {
+            if (*context->p == ',') {
+                context->p++;   //skip comma
+            } else {
+                set_parse_error(input->str, context->p,
+                        EXPECT_STR_LEN, "expect comma \",\"",
+                        &context->error_info, context->error_size);
+                context->error_no = EINVAL;
+                return NULL;
+            }
+        }
+
+        if ((context->error_no=check_alloc_array(context,
+                        (fc_common_array_t *)
+                        &context->jarray)) != 0)
+        {
+            return NULL;
+        }
+
+        if (context->decode.use_mpool) {
+            JSON_DECODE_COPY_STRING(context, input, context->jarray.elements +
+                    context->jarray.count++, &context->decode.element);
+        } else {
+            context->jarray.elements[context->jarray.count++] =
+                context->decode.element;
+        }
+        context->decode.element.str += context->decode.element.len + 1;
+    }
+
+    return &context->jarray;
+}
+
+const fc_json_map_t *fc_decode_json_map(fc_json_context_t
+        *context, const string_t *input)
+{
+    key_value_pair_t kv_pair;
+
+    if ((context->error_no=prepare_json_parse(context,
+                    input, '{', '}')) != 0)
+    {
+        return NULL;
+    }
+
+    context->jmap.count = 0;
+    while (context->p < context->end) {
+        while (context->p < context->end && JSON_SPACE(*context->p)) {
+            context->p++;
+        }
+
+        if (context->p == context->end) {
+            break;
+        }
+
+        if (*context->p == ',') {
+            set_parse_error(input->str, context->p + 1,
+                    EXPECT_STR_LEN, "unexpect comma \",\"",
+                    &context->error_info, context->error_size);
+            context->error_no = EINVAL;
+            return NULL;
+        }
+
+        if ((context->error_no=next_json_element(context)) != 0) {
+            return NULL;
+        }
+        while (context->p < context->end && JSON_SPACE(*context->p)) {
+            context->p++;
+        }
+        if (!(context->p < context->end && *context->p == ':')) {
+            set_parse_error(input->str, context->p,
+                    EXPECT_STR_LEN, "expect colon \":\"",
+                    &context->error_info, context->error_size);
+            context->error_no = EINVAL;
+            return NULL;
+        }
+        context->p++;   //skip colon
+
+        kv_pair.key = context->decode.element;
+        context->decode.element.str += context->decode.element.len + 1;
+
+        while (context->p < context->end && JSON_SPACE(*context->p)) {
+            context->p++;
+        }
+        if ((context->error_no=next_json_element(context)) != 0) {
+            return NULL;
+        }
+        while (context->p < context->end && JSON_SPACE(*context->p)) {
+            context->p++;
+        }
+        if (context->p < context->end) {
+            if (*context->p == ',') {
+                context->p++;  //skip comma
+            } else {
+                set_parse_error(input->str, context->p,
+                        EXPECT_STR_LEN, "expect comma \",\"",
+                        &context->error_info, context->error_size);
+                context->error_no = EINVAL;
+                return NULL;
+            }
+        }
+
+        kv_pair.value = context->decode.element;
+        context->decode.element.str += context->decode.element.len + 1;
+
+        if ((context->error_no=check_alloc_array(context,
+                        (fc_common_array_t *)
+                        &context->jmap)) != 0)
+        {
+            return NULL;
+        }
+
+        if (context->decode.use_mpool) {
+            key_value_pair_t *dest;
+            dest = context->jmap.elements + context->jmap.count++;
+            JSON_DECODE_COPY_STRING(context, input,
+                    &dest->key, &kv_pair.key);
+            JSON_DECODE_COPY_STRING(context, input,
+                    &dest->value, &kv_pair.value);
+        } else {
+            context->jmap.elements[context->jmap.count++] = kv_pair;
+        }
+    }
+
+    return &context->jmap;
+}

src/json_parser.h

@@ -15,14 +15,16 @@
 
 //json_parser.h
 
-#ifndef _JSON_PARSER_H
-#define _JSON_PARSER_H
+#ifndef _FC_JSON_PARSER_H
+#define _FC_JSON_PARSER_H
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include "common_define.h"
+#include "shared_func.h"
+#include "fast_mpool.h"
 
 #define FC_JSON_TYPE_STRING   1
 #define FC_JSON_TYPE_ARRAY    2
@@ -36,55 +38,200 @@
         /* for internal use */   \
         int element_size;  \
         int alloc;         \
-        char *buff;        \
     } ARRAY_TYPE
 
-DEFINE_ARRAY_STRUCT(void, common_array_t);
-DEFINE_ARRAY_STRUCT(string_t, json_array_t);
-DEFINE_ARRAY_STRUCT(key_value_pair_t, json_map_t);
+DEFINE_ARRAY_STRUCT(void, fc_common_array_t);
+DEFINE_ARRAY_STRUCT(string_t, fc_json_array_t);
+DEFINE_ARRAY_STRUCT(key_value_pair_t, fc_json_map_t);
+
+typedef struct {
+    BufferInfo output;  //for json encode/decode
+    struct {
+        struct fast_mpool_man mpool;
+        string_t element;   //string allocator use output buffer
+        bool use_mpool;
+    } decode;
+    int init_buff_size;
+    int error_no;
+    int error_size;
+    char error_holder[256];
+    string_t error_info;
+
+    fc_json_array_t jarray;
+    fc_json_map_t jmap;
+
+    /* for internal use */
+    const char *str;  //input string
+    const char *p;    //current
+    const char *end;
+} fc_json_context_t;
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-    void free_common_array(common_array_t *array);
-
-    static inline void free_json_array(json_array_t *array)
+    static inline void fc_init_common_array(fc_common_array_t *array,
+            const int element_size)
     {
-        free_common_array((common_array_t *)array);
+        array->elements = NULL;
+        array->element_size = element_size;
+        array->count = array->alloc = 0;
     }
 
-    static inline void free_json_map(json_map_t *array)
+    static inline void fc_init_json_array(fc_json_array_t *array)
     {
-        free_common_array((common_array_t *)array);
+        fc_init_common_array((fc_common_array_t *)array, sizeof(string_t));
     }
 
-    static inline void free_json_string(string_t *buffer)
+    static inline void fc_init_json_map(fc_json_map_t *array)
     {
-        if (buffer->str != NULL) {
-            free(buffer->str);
-            buffer->str = NULL;
-            buffer->len = 0;
+        fc_init_common_array((fc_common_array_t *)array,
+                sizeof(key_value_pair_t));
+    }
+
+    static inline void fc_free_common_array(fc_common_array_t *array)
+    {
+        if (array->elements != NULL) {
+            free(array->elements);
+            array->elements = NULL;
+            array->count = array->alloc = 0;
         }
     }
 
-    int detect_json_type(const string_t *input);
+    static inline void fc_free_json_array(fc_json_array_t *array)
+    {
+        fc_free_common_array((fc_common_array_t *)array);
+    }
 
-    int decode_json_array(const string_t *input, json_array_t *array,
-            char *error_info, const int error_size);
+    static inline void fc_free_json_map(fc_json_map_t *array)
+    {
+        fc_free_common_array((fc_common_array_t *)array);
+    }
 
-    int encode_json_array(json_array_t *array, string_t *output,
-            char *error_info, const int error_size);
+    static inline void fc_set_json_error_buffer(fc_json_context_t *ctx,
+            char *error_info, const int error_size)
+    {
+        if (error_info != NULL && error_size > 0) {
+            ctx->error_info.str = error_info;
+            ctx->error_size = error_size;
+        } else {
+            ctx->error_info.str = ctx->error_holder;
+            ctx->error_size = sizeof(ctx->error_holder);
+        }
 
-    int decode_json_map(const string_t *input, json_map_t *map,
-            char *error_info, const int error_size);
+        ctx->error_info.len = 0;
+        *ctx->error_info.str = '\0';
+    }
 
-    int encode_json_map(json_map_t *map, string_t *output,
-            char *error_info, const int error_size);
+    static inline int fc_init_json_context_ex(fc_json_context_t *ctx,
+            const bool decode_use_mpool, const int alloc_size_once,
+            const int init_buff_size, char *error_info,
+            const int error_size)
+    {
+        const int discard_size = 0;
+
+        ctx->output.buff = NULL;
+        ctx->output.alloc_size = ctx->output.length = 0;
+        FC_SET_STRING_NULL(ctx->decode.element);
+        if (init_buff_size > 0) {
+            ctx->init_buff_size = init_buff_size;
+        } else {
+            ctx->init_buff_size = 1024;
+        }
+        fc_init_json_array(&ctx->jarray);
+        fc_init_json_map(&ctx->jmap);
+
+        ctx->error_no = 0;
+        fc_set_json_error_buffer(ctx, error_info, error_size);
+        ctx->decode.use_mpool = decode_use_mpool;
+        if (decode_use_mpool) {
+            return fast_mpool_init(&ctx->decode.mpool,
+                    alloc_size_once, discard_size);
+        } else {
+            return 0;
+        }
+    }
+
+    static inline int fc_init_json_context(fc_json_context_t *ctx)
+    {
+        const bool decode_use_mpool = false;
+        const int alloc_size_once = 0;
+        const int init_buff_size = 0;
+
+        return fc_init_json_context_ex(ctx, decode_use_mpool,
+                alloc_size_once, init_buff_size, NULL, 0);
+    }
+
+    static inline void fc_reset_json_context(fc_json_context_t *ctx)
+    {
+        if (ctx->decode.use_mpool) {
+            fast_mpool_reset(&ctx->decode.mpool);
+        }
+    }
+
+    static inline void fc_destroy_json_context(fc_json_context_t *ctx)
+    {
+        fc_free_buffer(&ctx->output);
+        fc_free_json_array(&ctx->jarray);
+        fc_free_json_map(&ctx->jmap);
+        if (ctx->decode.use_mpool) {
+            fast_mpool_destroy(&ctx->decode.mpool);
+        }
+    }
+
+    static inline int fc_json_parser_get_error_no(fc_json_context_t *ctx)
+    {
+        return ctx->error_no;
+    }
+
+    static inline const string_t *fc_json_parser_get_error_info(
+            fc_json_context_t *ctx)
+    {
+        return &ctx->error_info;
+    }
+
+    int fc_detect_json_type(const string_t *input);
+
+    int fc_encode_json_array_ex(fc_json_context_t *context,
+            const string_t *elements, const int count,
+            BufferInfo *buffer);
+
+    int fc_encode_json_map_ex(fc_json_context_t *context,
+            const key_value_pair_t *elements, const int count,
+            BufferInfo *buffer);
+
+    static inline const BufferInfo *fc_encode_json_array(fc_json_context_t
+            *context, const string_t *elements, const int count)
+    {
+        if (fc_encode_json_array_ex(context, elements, count,
+                    &context->output) == 0)
+        {
+            return &context->output;
+        } else {
+            return NULL;
+        }
+    }
+
+    static inline const BufferInfo *fc_encode_json_map(fc_json_context_t
+            *context, const key_value_pair_t *elements, const int count)
+    {
+        if (fc_encode_json_map_ex(context, elements, count,
+                    &context->output) == 0)
+        {
+            return &context->output;
+        } else {
+            return NULL;
+        }
+    }
+
+    const fc_json_array_t *fc_decode_json_array(fc_json_context_t
+            *context, const string_t *input);
+
+    const fc_json_map_t *fc_decode_json_map(fc_json_context_t
+            *context, const string_t *input);
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif
-

src/local_ip_func.c

@@ -31,7 +31,7 @@ bool is_local_host_ip(const char *client_ip)
 	char *p;
 	char *pEnd;
 
-	pEnd = g_local_host_ip_addrs + \
+	pEnd = g_local_host_ip_addrs +
 		IP_ADDRESS_SIZE * g_local_host_ip_count;
 	for (p=g_local_host_ip_addrs; p<pEnd; p+=IP_ADDRESS_SIZE)
 	{
@@ -56,9 +56,8 @@ int insert_into_local_host_ip(const char *client_ip)
 		return -1;
 	}
 
-	strcpy(g_local_host_ip_addrs + \
-		IP_ADDRESS_SIZE * g_local_host_ip_count, \
-		client_ip);
+	strcpy(g_local_host_ip_addrs + IP_ADDRESS_SIZE *
+            g_local_host_ip_count, client_ip);
 	g_local_host_ip_count++;
 	return 1;
 }
@@ -83,7 +82,7 @@ const char *local_host_ip_addrs_to_string(char *buff, const int size)
 
 void log_local_host_ip_addrs()
 {
-	char buff[512];
+	char buff[1024];
 	logInfo("%s", local_host_ip_addrs_to_string(buff, sizeof(buff)));
 }
 
@@ -96,7 +95,7 @@ void load_local_host_ip_addrs()
 	char *if_alias_prefixes[STORAGE_MAX_ALIAS_PREFIX_COUNT];
 	int alias_count;
 
-	insert_into_local_host_ip(LOCAL_LOOPBACK_IP);
+	insert_into_local_host_ip(LOCAL_LOOPBACK_IPv4);
 
 	memset(if_alias_prefixes, 0, sizeof(if_alias_prefixes));
 	if (*g_if_alias_prefix == '\0')
@@ -160,8 +159,8 @@ const char *get_next_local_ip(const char *previous_ip)
 	pEnd = g_local_host_ip_addrs + \
 		IP_ADDRESS_SIZE * g_local_host_ip_count;
 	for (p=g_local_host_ip_addrs; p<pEnd; p+=IP_ADDRESS_SIZE)
-	{
-	    if (strcmp(p, LOCAL_LOOPBACK_IP) != 0)
+    {
+        if (!is_loopback_ip(p))
         {
             if (found)
             {
@@ -172,7 +171,7 @@ const char *get_next_local_ip(const char *previous_ip)
                 found = true;
             }
         }
-	}
+    }
 
     return NULL;
 }
@@ -187,7 +186,10 @@ const char *get_first_local_ip()
     }
     else
     {
-        return LOCAL_LOOPBACK_IP;
+        /* 注意，当系统存在IPv6回环地址时，为了简化系统的改动，
+           会将IPv6回环地址修改成IPv4回环地址返回
+           */
+        return LOCAL_LOOPBACK_IPv4;
     }
 }
 
@@ -212,3 +214,17 @@ const char *get_first_local_private_ip()
     return NULL;
 }
 
+void stat_local_host_ip(int *ipv4_count, int *ipv6_count)
+{
+    const char *ip_addr;
+
+    *ipv4_count = *ipv6_count = 0;
+    ip_addr = NULL;
+    while ((ip_addr=get_next_local_ip(ip_addr)) != NULL) {
+        if (is_ipv6_addr(ip_addr)) {
+            ++(*ipv6_count);
+        } else {
+            ++(*ipv4_count);
+        }
+    }
+}

src/local_ip_func.h

@@ -25,22 +25,32 @@
 #include "common_define.h"
 
 #define FAST_IF_ALIAS_PREFIX_MAX_SIZE 32
-#define FAST_MAX_LOCAL_IP_ADDRS	  16
+#define FAST_MAX_LOCAL_IP_ADDRS	  32
 
-#define LOCAL_LOOPBACK_IP  "127.0.0.1"
+#define LOCAL_LOOPBACK_IPv4  "127.0.0.1"
+#define LOCAL_LOOPBACK_IPv6  "::1"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 extern int g_local_host_ip_count;
-extern char g_local_host_ip_addrs[FAST_MAX_LOCAL_IP_ADDRS * \
+extern char g_local_host_ip_addrs[FAST_MAX_LOCAL_IP_ADDRS *
 				IP_ADDRESS_SIZE];
 extern char g_if_alias_prefix[FAST_IF_ALIAS_PREFIX_MAX_SIZE];
 
 void load_local_host_ip_addrs();
 bool is_local_host_ip(const char *client_ip);
 
+static inline bool is_loopback_ip(const char *ip_addr)
+{
+    return (strcmp(ip_addr, LOCAL_LOOPBACK_IPv4) == 0 ||
+            strcmp(ip_addr, LOCAL_LOOPBACK_IPv6) == 0 ||
+            strcasecmp(ip_addr, "fe80::1") == 0);
+}
+
+void stat_local_host_ip(int *ipv4_count, int *ipv6_count);
+
 const char *get_first_local_ip();
 const char *get_next_local_ip(const char *previous_ip);
 

src/locked_list.h

@@ -0,0 +1,115 @@
+#ifndef _LOCKED_LIST_H
+#define _LOCKED_LIST_H
+
+#include "fc_list.h"
+#include "pthread_func.h"
+
+typedef struct fc_locked_list {
+    struct fc_list_head head;
+    pthread_mutex_t lock;
+} FCLockedList;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define LOCKED_LIST_LOCK(list) PTHREAD_MUTEX_LOCK(&(list)->lock)
+#define LOCKED_LIST_UNLOCK(list) PTHREAD_MUTEX_UNLOCK(&(list)->lock)
+
+    static inline int locked_list_init(FCLockedList *list)
+    {
+        int result;
+        if ((result=init_pthread_lock(&list->lock)) != 0) {
+            return result;
+        }
+
+        FC_INIT_LIST_HEAD(&list->head);
+        return 0;
+    }
+
+    static inline void locked_list_destroy(FCLockedList *list)
+    {
+        pthread_mutex_destroy(&list->lock);
+    }
+
+    static inline void locked_list_add(struct fc_list_head *_new,
+            FCLockedList *list)
+    {
+        PTHREAD_MUTEX_LOCK(&list->lock);
+        fc_list_add(_new, &list->head);
+        PTHREAD_MUTEX_UNLOCK(&list->lock);
+    }
+
+    static inline void locked_list_add_tail(struct fc_list_head *_new,
+            FCLockedList *list)
+    {
+        PTHREAD_MUTEX_LOCK(&list->lock);
+        fc_list_add_tail(_new, &list->head);
+        PTHREAD_MUTEX_UNLOCK(&list->lock);
+    }
+
+    static inline void locked_list_move(struct fc_list_head *obj,
+            FCLockedList *list)
+    {
+        PTHREAD_MUTEX_LOCK(&list->lock);
+        fc_list_move(obj, &list->head);
+        PTHREAD_MUTEX_UNLOCK(&list->lock);
+    }
+
+    static inline void locked_list_move_tail(struct fc_list_head *obj,
+            FCLockedList *list)
+    {
+        PTHREAD_MUTEX_LOCK(&list->lock);
+        fc_list_move_tail(obj, &list->head);
+        PTHREAD_MUTEX_UNLOCK(&list->lock);
+    }
+
+    static inline void locked_list_del(struct fc_list_head *old,
+            FCLockedList *list)
+    {
+        PTHREAD_MUTEX_LOCK(&list->lock);
+        fc_list_del_init(old);
+        PTHREAD_MUTEX_UNLOCK(&list->lock);
+    }
+
+    static inline int locked_list_empty(FCLockedList *list)
+    {
+        int empty;
+        PTHREAD_MUTEX_LOCK(&list->lock);
+        empty = fc_list_empty(&list->head);
+        PTHREAD_MUTEX_UNLOCK(&list->lock);
+        return empty;
+    }
+
+    static inline int locked_list_count(FCLockedList *list)
+    {
+        int count;
+        PTHREAD_MUTEX_LOCK(&list->lock);
+        count = fc_list_count(&list->head);
+        PTHREAD_MUTEX_UNLOCK(&list->lock);
+        return count;
+    }
+
+#define locked_list_first_entry(list, type, member, var) \
+        PTHREAD_MUTEX_LOCK(&(list)->lock); \
+        var = fc_list_first_entry(&(list)->head, type, member); \
+        PTHREAD_MUTEX_UNLOCK(&(list)->lock)
+
+#define locked_list_last_entry(list, type, member, var) \
+        PTHREAD_MUTEX_LOCK(&(list)->lock); \
+        var = fc_list_last_entry(&(list)->head, type, member); \
+        PTHREAD_MUTEX_UNLOCK(&(list)->lock)
+
+#define locked_list_pop(list, type, member, var) \
+        PTHREAD_MUTEX_LOCK(&(list)->lock); \
+        var = fc_list_first_entry(&(list)->head, type, member); \
+        if (var != NULL) {  \
+            fc_list_del_init(&var->member);  \
+        }  \
+        PTHREAD_MUTEX_UNLOCK(&(list)->lock)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/logger.c

@@ -50,21 +50,21 @@ static int log_fsync(LogContext *pContext, const bool bNeedLock);
 
 static int check_and_mk_log_dir(const char *base_path)
 {
-	char data_path[MAX_PATH_SIZE];
+    char log_path[MAX_PATH_SIZE];
 
-	snprintf(data_path, sizeof(data_path), "%s/logs", base_path);
-	if (!fileExists(data_path))
-	{
-		if (mkdir(data_path, 0755) != 0)
-		{
-			fprintf(stderr, "mkdir \"%s\" fail, " \
-				"errno: %d, error info: %s\n", \
-				data_path, errno, STRERROR(errno));
-			return errno != 0 ? errno : EPERM;
-		}
-	}
+    fc_combine_full_filename(base_path, "logs", log_path);
+    if (!fileExists(log_path))
+    {
+        if (mkdir(log_path, 0755) != 0)
+        {
+            fprintf(stderr, "mkdir \"%s\" fail, "
+                    "errno: %d, error info: %s\n",
+                    log_path, errno, STRERROR(errno));
+            return errno != 0 ? errno : EPERM;
+        }
+    }
 
-	return 0;
+    return 0;
 }
 
 int log_init()
@@ -112,7 +112,7 @@ int log_init_ex(LogContext *pContext)
 	}
 	pContext->pcurrent_buff = pContext->log_buff;
 
-	if ((result=init_pthread_lock(&(pContext->log_thread_lock))) != 0)
+	if ((result=init_pthread_lock(&(pContext->lock))) != 0)
 	{
 		return result;
 	}
@@ -136,8 +136,8 @@ static int log_print_header(LogContext *pContext)
     if (pContext->current_size < 0)
     {
         result = errno != 0 ? errno : EACCES;
-        fprintf(stderr, "lseek file \"%s\" fail, " \
-                "errno: %d, error info: %s\n", \
+        fprintf(stderr, "lseek file \"%s\" fail, "
+                "errno: %d, error info: %s\n",
                 pContext->log_filename, result, STRERROR(result));
     }
     else {
@@ -158,8 +158,8 @@ static int log_print_header(LogContext *pContext)
 static int log_open(LogContext *pContext)
 {
     int result;
-	if ((pContext->log_fd = open(pContext->log_filename, O_WRONLY | \
-				O_CREAT | O_APPEND | pContext->fd_flags, 0644)) < 0)
+	if ((pContext->log_fd = open(pContext->log_filename, O_WRONLY | O_CREAT |
+                    O_APPEND | O_CLOEXEC | pContext->fd_flags, 0644)) < 0)
 	{
 		fprintf(stderr, "open log file \"%s\" to write fail, " \
 			"errno: %d, error info: %s\n", \
@@ -222,31 +222,44 @@ int log_reopen_ex(LogContext *pContext)
     return log_open(pContext);
 }
 
-int log_set_prefix_ex(LogContext *pContext, const char *base_path, \
+int log_set_prefix_ex(LogContext *pContext, const char *base_path,
 		const char *filename_prefix)
 {
-	int result;
+    int result;
+    char log_filename[MAX_PATH_SIZE];
 
-	if ((result=check_and_mk_log_dir(base_path)) != 0)
-	{
-		return result;
-	}
+    if ((result=check_and_mk_log_dir(base_path)) != 0)
+    {
+        return result;
+    }
 
-	snprintf(pContext->log_filename, MAX_PATH_SIZE, "%s/logs/%s.log", \
-		base_path, filename_prefix);
-
-	return log_open(pContext);
+    snprintf(log_filename, MAX_PATH_SIZE, "%s/logs/%s.log",
+            base_path, filename_prefix);
+    return log_set_filename_ex(pContext, log_filename);
 }
 
 int log_set_filename_ex(LogContext *pContext, const char *log_filename)
 {
-    if (log_filename == NULL) {
-		fprintf(stderr, "file: "__FILE__", line: %d, " \
-                "log_filename is NULL!\n", __LINE__);
+    if (log_filename == NULL || *log_filename == '\0')
+    {
+        fprintf(stderr, "file: "__FILE__", line: %d, "
+                "log_filename is NULL or empty!\n", __LINE__);
         return EINVAL;
     }
-	snprintf(pContext->log_filename, MAX_PATH_SIZE, "%s", log_filename);
-	return log_open(pContext);
+
+    if (*(pContext->log_filename) == '\0')
+    {
+        fc_strlcpy(pContext->log_filename, log_filename, MAX_PATH_SIZE);
+        return log_open(pContext);
+    }
+
+    if (strcmp(log_filename, pContext->log_filename) == 0)
+    {
+        return 0;
+    }
+
+    fc_strlcpy(pContext->log_filename, log_filename, MAX_PATH_SIZE);
+    return log_reopen_ex(pContext);
 }
 
 void log_set_cache_ex(LogContext *pContext, const bool bLogCache)
@@ -283,9 +296,9 @@ void log_set_header_callback(LogContext *pContext, LogHeaderCallback header_call
     {
         int64_t current_size;
 
-		pthread_mutex_lock(&(pContext->log_thread_lock));
+		pthread_mutex_lock(&(pContext->lock));
         current_size = pContext->current_size;
-		pthread_mutex_unlock(&(pContext->log_thread_lock));
+		pthread_mutex_unlock(&(pContext->lock));
         if (current_size == 0)
         {
             log_print_header(pContext);
@@ -334,7 +347,7 @@ void log_destroy_ex(LogContext *pContext)
 		close(pContext->log_fd);
 		pContext->log_fd = STDERR_FILENO;
 
-		pthread_mutex_destroy(&pContext->log_thread_lock);
+		pthread_mutex_destroy(&pContext->lock);
 	}
 
 	if (pContext->log_buff != NULL)
@@ -372,12 +385,11 @@ static int log_delete_old_file(LogContext *pContext,
     char full_filename[MAX_PATH_SIZE + 128];
     if (NEED_COMPRESS_LOG(pContext->compress_log_flags))
     {
-        snprintf(full_filename, sizeof(full_filename), "%s%s",
-                old_filename, GZIP_EXT_NAME_STR);
+        fc_concat_two_strings(old_filename, GZIP_EXT_NAME_STR, full_filename);
     }
     else
     {
-        snprintf(full_filename, sizeof(full_filename), "%s", old_filename);
+        fc_safe_strcpy(full_filename, old_filename);
     }
 
     if (unlink(full_filename) != 0)
@@ -577,7 +589,9 @@ static int log_get_matched_files(LogContext *pContext,
     the_time = get_current_time() - days_before * 86400;
     localtime_r(&the_time, &tm);
     memset(filename_prefix, 0, sizeof(filename_prefix));
-    len = sprintf(filename_prefix, "%s.", log_filename);
+    len = strlen(log_filename);
+    memcpy(filename_prefix, log_filename, len);
+    *(filename_prefix + len++) = '.';
     strftime(filename_prefix + len, sizeof(filename_prefix) - len,
             rotate_time_format_prefix, &tm);
     prefix_filename_len = strlen(filename_prefix);
@@ -638,8 +652,8 @@ static int log_delete_matched_old_files(LogContext *pContext,
     log_get_file_path(pContext, log_filepath);
     for (i=0; i<filename_array.count; i++)
     {
-        snprintf(full_filename, sizeof(full_filename), "%s%s",
-                log_filepath, filename_array.filenames[i]);
+        fc_concat_two_strings(log_filepath, filename_array.
+                filenames[i], full_filename);
         if (unlink(full_filename) != 0)
         {
             if (errno != ENOENT)
@@ -690,7 +704,9 @@ int log_delete_old_files(void *args)
             the_time -= 86400;
             localtime_r(&the_time, &tm);
             memset(old_filename, 0, sizeof(old_filename));
-            len = sprintf(old_filename, "%s.", pContext->log_filename);
+            len = strlen(pContext->log_filename);
+            memcpy(old_filename, pContext->log_filename, len);
+            *(old_filename + len++) = '.';
             strftime(old_filename + len, sizeof(old_filename) - len,
                     pContext->rotate_time_format, &tm);
             if ((result=log_delete_old_file(pContext, old_filename)) != 0)
@@ -720,6 +736,7 @@ static void *log_gzip_func(void *args)
     char log_filepath[MAX_PATH_SIZE];
     char full_filename[MAX_PATH_SIZE + 32];
     char output[512];
+    const char *gzip_cmd_filename;
     int prefix_len;
     int result;
     int i;
@@ -747,11 +764,10 @@ static void *log_gzip_func(void *args)
             continue;
         }
 
-        snprintf(full_filename, sizeof(full_filename), "%s%s",
-                log_filepath, filename_array.filenames[i]);
-        snprintf(cmd, sizeof(cmd), "%s %s",
-                get_gzip_command_filename(), full_filename);
-
+        gzip_cmd_filename = get_gzip_command_filename();
+        fc_concat_two_strings(log_filepath, filename_array.
+                filenames[i], full_filename);
+        fc_combine_two_strings(gzip_cmd_filename, full_filename, ' ', cmd);
         result = getExecResult(cmd, output, sizeof(output));
         if (result != 0)
         {
@@ -817,8 +833,7 @@ int log_rotate(LogContext *pContext)
 
 	close(pContext->log_fd);
 
-	current_time = get_current_time();
-	localtime_r(&current_time, &tm);
+    current_time = get_current_time();
     if (tm.tm_hour == 0 && tm.tm_min <= 1)
     {
         if (strstr(pContext->rotate_time_format, "%H") == NULL
@@ -826,12 +841,14 @@ int log_rotate(LogContext *pContext)
                 && strstr(pContext->rotate_time_format, "%S") == NULL)
         {
             current_time -= 120;
-            localtime_r(&current_time, &tm);
         }
     }
+    localtime_r(&current_time, &tm);
 
     memset(old_filename, 0, sizeof(old_filename));
-	len = sprintf(old_filename, "%s.", pContext->log_filename);
+    len = strlen(pContext->log_filename);
+    memcpy(old_filename, pContext->log_filename, len);
+    *(old_filename + len++) = '.';
     strftime(old_filename + len, sizeof(old_filename) - len,
             pContext->rotate_time_format, &tm);
     if (access(old_filename, F_OK) == 0)
@@ -901,19 +918,19 @@ static int log_fsync(LogContext *pContext, const bool bNeedLock)
 		{
             if (bNeedLock)
             {
-                pthread_mutex_lock(&(pContext->log_thread_lock));
+                pthread_mutex_lock(&(pContext->lock));
             }
             result = log_check_rotate(pContext);
             if (bNeedLock)
             {
-                pthread_mutex_unlock(&(pContext->log_thread_lock));
+                pthread_mutex_unlock(&(pContext->lock));
             }
             return result;
 		}
 	}
 
 	if (bNeedLock && ((lock_res=pthread_mutex_lock( \
-			&(pContext->log_thread_lock))) != 0))
+			&(pContext->lock))) != 0))
 	{
 		fprintf(stderr, "file: "__FILE__", line: %d, " \
 			"call pthread_mutex_lock fail, " \
@@ -938,10 +955,10 @@ static int log_fsync(LogContext *pContext, const bool bNeedLock)
 	if (written != write_bytes)
 	{
 		result = errno != 0 ? errno : EIO;
-		fprintf(stderr, "file: "__FILE__", line: %d, " \
-			"call write fail, errno: %d, error info: %s\n",\
-			 __LINE__, result, STRERROR(result));
-	}
+        fprintf(stderr, "file: "__FILE__", line: %d, "
+                "pid: %d, call write fail, fd: %d, errno: %d, error info: %s\n",
+                __LINE__, getpid(), pContext->log_fd, result, STRERROR(result));
+    }
 
 	if (pContext->rotate_immediately)
 	{
@@ -949,7 +966,7 @@ static int log_fsync(LogContext *pContext, const bool bNeedLock)
 	}
 
 	if (bNeedLock && ((lock_res=pthread_mutex_unlock( \
-			&(pContext->log_thread_lock))) != 0))
+			&(pContext->lock))) != 0))
 	{
 		fprintf(stderr, "file: "__FILE__", line: %d, " \
 			"call pthread_mutex_unlock fail, " \
@@ -960,8 +977,8 @@ static int log_fsync(LogContext *pContext, const bool bNeedLock)
 	return result;
 }
 
-static void doLogEx(LogContext *pContext, struct timeval *tv, \
-		const char *caption, const char *text, const int text_len, \
+void log_it_ex3(LogContext *pContext, struct timeval *tv,
+		const char *caption, const char *text, const int text_len,
 		const bool bNeedSync, const bool bNeedLock)
 {
 	struct tm tm;
@@ -986,7 +1003,7 @@ static void doLogEx(LogContext *pContext, struct timeval *tv, \
 		}
 	}
 
-	if (bNeedLock && (result=pthread_mutex_lock(&pContext->log_thread_lock)) != 0)
+	if (bNeedLock && (result=pthread_mutex_lock(&pContext->lock)) != 0)
 	{
 		fprintf(stderr, "file: "__FILE__", line: %d, " \
 			"call pthread_mutex_lock fail, " \
@@ -1001,12 +1018,12 @@ static void doLogEx(LogContext *pContext, struct timeval *tv, \
 			__LINE__, LOG_BUFF_SIZE, text_len + 64);
         if (bNeedLock)
         {
-		    pthread_mutex_unlock(&(pContext->log_thread_lock));
+		    pthread_mutex_unlock(&(pContext->lock));
         }
 		return;
 	}
 
-	if ((pContext->pcurrent_buff - pContext->log_buff) + text_len + 64 \
+	if ((pContext->pcurrent_buff - pContext->log_buff) + text_len + 64
 			> LOG_BUFF_SIZE)
 	{
 		log_fsync(pContext, false);
@@ -1033,10 +1050,14 @@ static void doLogEx(LogContext *pContext, struct timeval *tv, \
     }
 
 	if (caption != NULL)
-	{
-		buff_len = sprintf(pContext->pcurrent_buff, "%s - ", caption);
-		pContext->pcurrent_buff += buff_len;
-	}
+    {
+        buff_len = strlen(caption);
+        memcpy(pContext->pcurrent_buff, caption, buff_len);
+        pContext->pcurrent_buff += buff_len;
+        *pContext->pcurrent_buff++ = ' ';
+        *pContext->pcurrent_buff++ = '-';
+        *pContext->pcurrent_buff++ = ' ';
+    }
 	memcpy(pContext->pcurrent_buff, text, text_len);
 	pContext->pcurrent_buff += text_len;
 	*pContext->pcurrent_buff++ = '\n';
@@ -1046,7 +1067,7 @@ static void doLogEx(LogContext *pContext, struct timeval *tv, \
 		log_fsync(pContext, false);
 	}
 
-	if (bNeedLock && (result=pthread_mutex_unlock(&(pContext->log_thread_lock))) != 0)
+	if (bNeedLock && (result=pthread_mutex_unlock(&(pContext->lock))) != 0)
 	{
 		fprintf(stderr, "file: "__FILE__", line: %d, " \
 			"call pthread_mutex_unlock fail, " \
@@ -1055,8 +1076,8 @@ static void doLogEx(LogContext *pContext, struct timeval *tv, \
 	}
 }
 
-void log_it_ex2(LogContext *pContext, const char *caption, \
-		const char *text, const int text_len, \
+void log_it_ex2(LogContext *pContext, const char *caption,
+		const char *text, const int text_len,
         const bool bNeedSync, const bool bNeedLock)
 {
 	struct timeval tv;
@@ -1071,10 +1092,10 @@ void log_it_ex2(LogContext *pContext, const char *caption, \
 		gettimeofday(&tv, NULL);
 	}
 
-	doLogEx(pContext, &tv, caption, text, text_len, bNeedSync, bNeedLock);
+	log_it_ex3(pContext, &tv, caption, text, text_len, bNeedSync, bNeedLock);
 }
 
-void log_it_ex1(LogContext *pContext, const int priority, \
+void log_it_ex1(LogContext *pContext, const int priority,
 		const char *text, const int text_len)
 {
 	bool bNeedSync;
@@ -1270,45 +1291,12 @@ void logAccess(LogContext *pContext, struct timeval *tvStart, \
     {
         len = sizeof(text) - 1;
     }
-	doLogEx(pContext, tvStart, NULL, text, len, false, true);
+	log_it_ex3(pContext, tvStart, NULL, text, len, false, true);
 }
 
 const char *log_get_level_caption_ex(LogContext *pContext)
 {
-	const char *caption;
-
-	switch (pContext->log_level)
-	{
-		case LOG_DEBUG:
-			caption = "DEBUG";
-			break;
-		case LOG_INFO:
-			caption = "INFO";
-			break;
-		case LOG_NOTICE:
-			caption = "NOTICE";
-			break;
-		case LOG_WARNING:
-			caption = "WARNING";
-			break;
-		case LOG_ERR:
-			caption = "ERROR";
-			break;
-		case LOG_CRIT:
-			caption = "CRIT";
-			break;
-		case LOG_ALERT:
-			caption = "ALERT";
-			break;
-		case LOG_EMERG:
-			caption = "EMERG";
-			break;
-		default:
-			caption = "UNKOWN";
-			break;
-	}
-
-    return caption;
+    return get_log_level_caption(pContext->log_level);
 }
 
 #ifndef LOG_FORMAT_CHECK

src/logger.h

@@ -62,7 +62,7 @@ typedef struct log_context
 	char *pcurrent_buff;
 
 	/* mutext lock */
-	pthread_mutex_t log_thread_lock;
+	pthread_mutex_t lock;
 
 	/*
 	rotate the log when the log file exceeds this parameter
@@ -145,6 +145,7 @@ static inline int log_try_init()
 */
 int log_init2();
 
+
 #define log_reopen() log_reopen_ex(&g_log_context)
 
 #define log_set_prefix(base_path, filename_prefix) \
@@ -200,7 +201,7 @@ int log_reopen_ex(LogContext *pContext);
  *           filename_prefix: log filename prefix
  *  return: 0 for success, != 0 fail
 */
-int log_set_prefix_ex(LogContext *pContext, const char *base_path, \
+int log_set_prefix_ex(LogContext *pContext, const char *base_path,
 		const char *filename_prefix);
 
 /** set log filename
@@ -273,6 +274,24 @@ void log_take_over_stderr_ex(LogContext *pContext);
 */
 void log_take_over_stdout_ex(LogContext *pContext);
 
+
+/** init function using global log context
+ *  do nothing when already inited
+ *  return: 0 for success, != 0 fail
+*/
+static inline int log_try_init2()
+{
+    int result;
+    if ((result=log_try_init()) != 0)
+    {
+        return result;
+    }
+
+    log_take_over_stderr();
+    log_take_over_stdout();
+    return 0;
+}
+
 /** set compress_log_flags to true
  *  parameters:
  *           pContext: the log context
@@ -324,7 +343,7 @@ void log_it_ex(LogContext *pContext, const int priority, \
  *           text_len: text string length (bytes)
  *  return: none
 */
-void log_it_ex1(LogContext *pContext, const int priority, \
+void log_it_ex1(LogContext *pContext, const int priority,
 		const char *text, const int text_len);
 
 /** log to file
@@ -336,10 +355,13 @@ void log_it_ex1(LogContext *pContext, const int priority, \
  *           bNeedSync: if sync to file immediatelly
  *  return: none
 */
-void log_it_ex2(LogContext *pContext, const char *caption, \
-		const char *text, const int text_len, \
+void log_it_ex2(LogContext *pContext, const char *caption,
+		const char *text, const int text_len,
         const bool bNeedSync, const bool bNeedLock);
 
+void log_it_ex3(LogContext *pContext, struct timeval *tv,
+		const char *caption, const char *text, const int text_len,
+		const bool bNeedSync, const bool bNeedLock);
 
 /** sync log buffer to log file
  *  parameters:

src/md5.c

@@ -311,7 +311,7 @@ MD5_memset(POINTER         output, int             value, unsigned int    len)
 /*
  * Digests a string
  */
-int my_md5_string(char *string,unsigned char digest[16])
+int my_md5_string(char *string, unsigned char digest[16])
 {
 	MD5_CTX	context;
 	unsigned int len = strlen(string);
@@ -332,25 +332,22 @@ int my_md5_buffer(char *buffer, unsigned int len, unsigned char digest[16])
 	return 0;
 }
 
-int my_md5_file(char *filename,unsigned char digest[16])	
+int my_md5_file(char *filename, unsigned char digest[16])
 {
 	FILE           *file;
 	MD5_CTX         context;
 	int             len;
-	unsigned char   buffer[1024];
+	unsigned char   buff[16 * 1024];
 
-	if ((file = fopen(filename, "rb")) == NULL)
+	if ((file = fopen(filename, "rb")) == NULL) {
 		return -1;
-	else {
-		my_md5_init(&context);
-		while ((len = fread(buffer, 1, 1024, file)) > 0)
-		{
-			my_md5_update(&context, buffer, len);
-		}
-		my_md5_final(digest, &context);
+    }
 
-		fclose(file);
-	}
-	return 0;
+    my_md5_init(&context);
+    while ((len = fread(buff, 1, sizeof(buff), file)) > 0) {
+        my_md5_update(&context, buff, len);
+    }
+    my_md5_final(digest, &context);
+    fclose(file);
+    return 0;
 }
-

src/md5.h

@@ -41,12 +41,12 @@ int my_md5_file(char *filename, unsigned char digest[16]);
 */
 int my_md5_buffer(char *buffer, unsigned int len, unsigned char digest[16]);
 
-void my_md5_init (MD5_CTX *context);
+void my_md5_init(MD5_CTX *context);
 
-void my_md5_update (MD5_CTX *context, unsigned char *input,
+void my_md5_update(MD5_CTX *context, unsigned char *input,
         unsigned int inputLen);
 
-void my_md5_final (unsigned char digest[16], MD5_CTX *context);
+void my_md5_final(unsigned char digest[16], MD5_CTX *context);
 
 #ifdef __cplusplus
 }

src/multi_socket_client.c

@@ -46,6 +46,7 @@ int fast_multi_sock_client_init_ex(FastMultiSockClient *client,
         fms_client_get_current_time_ms_func get_current_time_ms_func,
         const int init_recv_buffer_size, const int timeout_ms)
 {
+    const bool use_io_uring = false;
     int result;
     int new_init_recv_buffer_size;
     int i;
@@ -65,8 +66,8 @@ int fast_multi_sock_client_init_ex(FastMultiSockClient *client,
         return EINVAL;
     }
 
-    if ((result=ioevent_init(&client->ioevent, entry_count,
-                    timeout_ms, 0)) != 0)
+    if ((result=ioevent_init(&client->ioevent, "client",
+                    use_io_uring, entry_count, timeout_ms, 0)) != 0)
     {
         logError("file: "__FILE__", line: %d, "
                 "ioevent_init fail, errno: %d, error info: %s",
@@ -85,7 +86,7 @@ int fast_multi_sock_client_init_ex(FastMultiSockClient *client,
     }
 
     for (i=0; i<entry_count; i++) {
-        if ((result=fast_buffer_init_ex(&entries[i].recv_buffer,
+        if ((result=fast_buffer_init1(&entries[i].recv_buffer,
                         new_init_recv_buffer_size)) != 0)
         {
             return result;
@@ -128,6 +129,7 @@ static int fast_multi_sock_client_do_send(FastMultiSockClient *client,
 {
     int bytes;
     int result;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
     result = 0;
     while (entry->remain > 0) {
@@ -139,27 +141,26 @@ static int fast_multi_sock_client_do_send(FastMultiSockClient *client,
                 break;
             } else if (errno == EINTR) {  //should retry
                 logDebug("file: "__FILE__", line: %d, "
-                        "server: %s:%u, ignore interupt signal",
-                        __LINE__, entry->conn->ip_addr,
+                        "server: %s:%u, ignore interupt signal", __LINE__,
+                        format_ip_address(entry->conn->ip_addr, formatted_ip),
                         entry->conn->port);
                 continue;
             } else {
                 result = errno != 0 ? errno : ECONNRESET;
                 logError("file: "__FILE__", line: %d, "
                         "send to server %s:%u fail, "
-                        "errno: %d, error info: %s",
-                        __LINE__, entry->conn->ip_addr,
-                        entry->conn->port,
-                        result, strerror(result));
+                        "errno: %d, error info: %s", __LINE__,
+                        format_ip_address(entry->conn->ip_addr, formatted_ip),
+                        entry->conn->port, result, strerror(result));
 
                 break;
             }
         } else if (bytes == 0) {
             logError("file: "__FILE__", line: %d, "
                     "send to server %s:%u, sock: %d fail, "
-                    "connection disconnected",
-                    __LINE__, entry->conn->ip_addr, entry->conn->port,
-                    entry->conn->sock);
+                    "connection disconnected", __LINE__,
+                    format_ip_address(entry->conn->ip_addr, formatted_ip),
+                    entry->conn->port, entry->conn->sock);
 
             result = ECONNRESET;
             break;
@@ -190,6 +191,7 @@ static int fast_multi_sock_client_send_data(FastMultiSockClient *client,
 {
     int i;
     int result;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
     for (i=0; i<client->entry_count; i++) {
         client->entries[i].remain = send_buffer->length;
@@ -202,9 +204,9 @@ static int fast_multi_sock_client_send_data(FastMultiSockClient *client,
             client->entries[i].error_no = ENOTCONN;
             client->entries[i].done = true;
             logError("file: "__FILE__", line: %d, "
-                    "NOT connected to %s:%u",
-                    __LINE__, client->entries[i].conn->ip_addr,
-                    client->entries[i].conn->port);
+                    "NOT connected to %s:%u", __LINE__,
+                    format_ip_address(client->entries[i].conn->ip_addr,
+                        formatted_ip), client->entries[i].conn->port);
             continue;
         }
 
@@ -244,6 +246,7 @@ static int fast_multi_sock_client_do_recv(FastMultiSockClient *client,
 {
     int bytes;
     int result;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
     result = 0;
     while (entry->remain > 0) {
@@ -254,27 +257,26 @@ static int fast_multi_sock_client_do_recv(FastMultiSockClient *client,
                 break;
             } else if (errno == EINTR) {  //should retry
                 logDebug("file: "__FILE__", line: %d, "
-                        "server: %s:%u, ignore interupt signal",
-                        __LINE__, entry->conn->ip_addr,
+                        "server: %s:%u, ignore interupt signal", __LINE__,
+                        format_ip_address(entry->conn->ip_addr, formatted_ip),
                         entry->conn->port);
                 continue;
             } else {
                 result = errno != 0 ? errno : ECONNRESET;
                 logError("file: "__FILE__", line: %d, "
                         "server: %s:%u, recv failed, "
-                        "errno: %d, error info: %s",
-                        __LINE__, entry->conn->ip_addr,
-                        entry->conn->port,
-                        result, strerror(result));
+                        "errno: %d, error info: %s", __LINE__,
+                        format_ip_address(entry->conn->ip_addr, formatted_ip),
+                        entry->conn->port, result, strerror(result));
 
                 break;
             }
         } else if (bytes == 0) {
             logError("file: "__FILE__", line: %d, "
                     "server: %s:%u, sock: %d, recv failed, "
-                    "connection disconnected",
-                    __LINE__, entry->conn->ip_addr, entry->conn->port,
-                    entry->conn->sock);
+                    "connection disconnected", __LINE__,
+                    format_ip_address(entry->conn->ip_addr, formatted_ip),
+                    entry->conn->port, entry->conn->sock);
 
             result = ECONNRESET;
             break;
@@ -289,8 +291,8 @@ static int fast_multi_sock_client_do_recv(FastMultiSockClient *client,
             body_length = client->get_body_length_func(&entry->recv_buffer);
             if (body_length < 0) {
                 logError("file: "__FILE__", line: %d, "
-                        "server: %s:%u, body_length: %d < 0",
-                        __LINE__, entry->conn->ip_addr,
+                        "server: %s:%u, body_length: %d < 0", __LINE__,
+                        format_ip_address(entry->conn->ip_addr, formatted_ip),
                         entry->conn->port, body_length);
                 result = EPIPE;
                 break;
@@ -315,11 +317,16 @@ static int fast_multi_sock_client_do_recv(FastMultiSockClient *client,
 static int fast_multi_sock_client_deal_io(FastMultiSockClient *client)
 {
     int result;
-	int event;
     int count;
+#if IOEVENT_USE_URING
+    unsigned head;
+#else
+	int event;
     int index;
+#endif
     int remain_timeout;
     FastMultiSockEntry *entry;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
     while (client->pulling_count > 0) {
         remain_timeout = client->deadline_time_ms -
@@ -328,8 +335,39 @@ static int fast_multi_sock_client_deal_io(FastMultiSockClient *client)
             break;
         }
 
+#if IOEVENT_USE_URING
+        result = io_uring_wait_cqe_timeout(&client->ioevent.ring,
+                &client->ioevent.cqe, &client->ioevent.timeout);
+        switch (result) {
+            case 0:
+                break;
+            case -ETIME:
+            case -EAGAIN:
+            case -EINTR:
+                continue;
+            default:
+                result *= -1;
+                logError("file: "__FILE__", line: %d, "
+                        "io_uring_wait_cqe fail, errno: %d, error info: %s",
+                        __LINE__, result, STRERROR(result));
+                return result;
+        }
+
+        count = 0;
+        io_uring_for_each_cqe(&client->ioevent.ring, head, client->ioevent.cqe) {
+            count++;
+            entry = (FastMultiSockEntry *)client->ioevent.cqe->user_data;
+            //logInfo("sock: %d, event: %d", entry->conn->sock, event);
+            result = entry->io_callback(client, entry);
+            if (result != 0 || entry->remain == 0) {
+                fast_multi_sock_client_finish(client, entry, result);
+            }
+        }
+        io_uring_cq_advance(&client->ioevent.ring, count);
+
+#else
         count = ioevent_poll_ex(&client->ioevent, remain_timeout);
-        logInfo("poll count: %d\n", count);
+        //logInfo("poll count: %d\n", count);
         for (index=0; index<count; index++) {
             event = IOEVENT_GET_EVENTS(&client->ioevent, index);
             entry = (FastMultiSockEntry *)IOEVENT_GET_DATA(
@@ -337,21 +375,22 @@ static int fast_multi_sock_client_deal_io(FastMultiSockClient *client)
 
             if (event & IOEVENT_ERROR) {
                 logError("file: "__FILE__", line: %d, "
-                        "server: %s:%u, recv error event: %d, "
-                        "connection reset", __LINE__,
-                        entry->conn->ip_addr, entry->conn->port, event);
+                        "server: %s:%u, recv error event: %d, connection "
+                        "reset", __LINE__, format_ip_address(entry->conn->
+                            ip_addr, formatted_ip), entry->conn->port, event);
 
                 fast_multi_sock_client_finish(client, entry, ECONNRESET);
                 continue;
             }
 
-            logInfo("sock: %d, event: %d", entry->conn->sock, event);
+            //logInfo("sock: %d, event: %d", entry->conn->sock, event);
 
             result = entry->io_callback(client, entry);
             if (result != 0 || entry->remain == 0) {
                 fast_multi_sock_client_finish(client, entry, result);
             }
         }
+#endif
     }
 
 /*
@@ -366,9 +405,9 @@ static int fast_multi_sock_client_deal_io(FastMultiSockClient *client)
                 fast_multi_sock_client_finish(client,
                         client->entries + i, ETIMEDOUT);
                 logError("file: "__FILE__", line: %d, "
-                        "recv from %s:%u timedout",
-                        __LINE__, client->entries[i].conn->ip_addr,
-                        client->entries[i].conn->port);
+                        "recv from %s:%u timedout", __LINE__,
+                        format_ip_address(client->entries[i].conn->ip_addr,
+                            formatted_ip), client->entries[i].conn->port);
             }
         }
     }

src/multi_socket_client.h

@@ -21,7 +21,6 @@
 #include <net/if.h>
 #include <string.h>
 #include <sys/types.h>
-#include <sys/stat.h>
 #include <sys/socket.h>
 #include "common_define.h"
 #include "connection_pool.h"

src/php7_ext_wrapper.h

@@ -34,6 +34,22 @@
 #include <SAPI.h>
 #include <php_ini.h>
 
+#ifndef TSRMLS_DC
+#define TSRMLS_DC
+#endif
+
+#ifndef TSRMLS_C
+#define TSRMLS_C
+#endif
+
+#ifndef TSRMLS_CC
+#define TSRMLS_CC
+#endif
+
+#ifndef TSRMLS_FETCH
+#define TSRMLS_FETCH()
+#endif
+
 #if PHP_MAJOR_VERSION < 7
 typedef int zend_size_t;
 #define ZEND_RETURN_STRING(s, dup) RETURN_STRING(s, dup)

src/process_ctrl.c

@@ -50,14 +50,14 @@ int write_to_pid_file(const char *pidFilename)
   char buff[32];
   int len;
 
-  len = sprintf(buff, "%d", (int)getpid());
+  len = fc_itoa(getpid(), buff);
   return writeToFile(pidFilename, buff, len);
 }
 
 int delete_pid_file(const char *pidFilename)
 {
   int result;
-  pid_t pid;
+  pid_t pid = 0;
 
   if ((result=get_pid_from_file(pidFilename, &pid)) != 0) {
     return result;
@@ -112,41 +112,57 @@ static int do_stop(const char *pidFilename, const bool bShowError, pid_t *pid)
   }
 }
 
-int process_stop(const char *pidFilename)
+int process_stop_ex(const char *pidFilename,
+        const bool bShowError, bool *force)
 {
-  pid_t pid;
+#define MAX_WAIT_COUNT  300
+  pid_t pid = 0;
   int result;
+  int sig;
+  int i;
 
-  result = do_stop(pidFilename, true, &pid);
-  if (result != 0) {
+  *force = false;
+  if ((result=do_stop(pidFilename, bShowError, &pid)) != 0) {
     return result;
   }
 
   fprintf(stderr, "waiting for pid [%d] exit ...\n", (int)pid);
-  do {
-    sleep(1);
-  } while (kill(pid, SIGTERM) == 0);
-  fprintf(stderr, "pid [%d] exit.\n", (int)pid);
+  for (i=0; i<MAX_WAIT_COUNT; i++) {
+    sig = (i % 10 == 0) ? SIGTERM : 0;
+    if (kill(pid, sig) != 0) {
+      break;
+    }
 
+    fc_sleep_ms(100);
+  }
+
+  if (i == MAX_WAIT_COUNT) {
+    if (kill(pid, SIGKILL) == 0) {
+      fprintf(stderr, "waiting for pid [%d] exit timeout, "
+              "force kill!\n", (int)pid);
+      *force = true;
+      fc_sleep_ms(100);
+    }
+  }
+
+  fprintf(stderr, "pid [%d] exit.\n\n", (int)pid);
   return 0;
 }
 
 int process_restart(const char *pidFilename)
 {
+  const bool bShowError = false;
+  bool force;
   int result;
-  pid_t pid;
-
-  result = do_stop(pidFilename, false, &pid);
-  if (result == 0) {
-    fprintf(stderr, "waiting for pid [%d] exit ...\n", (int)pid);
-    do {
-      sleep(1);
-    } while (kill(pid, SIGTERM) == 0);
-    fprintf(stderr, "starting ...\n");
-  }
 
+  result = process_stop_ex(pidFilename, bShowError, &force);
   if (result == ENOENT || result == ESRCH) {
-    return 0;
+    result = 0;
+  } else if (result == 0) {
+    if (force) {
+      sleep(1);
+    }
+    fprintf(stderr, "starting ...\n");
   }
 
   return result;
@@ -183,7 +199,7 @@ static const char *get_exename_by_pid(const pid_t pid, char *buff,
 
 int process_start(const char* pidFilename)
 {
-    pid_t pid;
+    pid_t pid = 0;
     int result;
 
     if ((result=get_pid_from_file(pidFilename, &pid)) != 0) {
@@ -235,40 +251,41 @@ int process_start(const char* pidFilename)
     }
 }
 
-int process_exist(const char *pidFilename)
+int process_exist(const char *pidFilename, pid_t *pid)
 {
-  pid_t pid;
   int result;
 
-  if ((result=get_pid_from_file(pidFilename, &pid)) != 0) {
+  if ((result=get_pid_from_file(pidFilename, pid)) != 0) {
     if (result == ENOENT) {
-      return false;
+      return result;
     }
     else {
       fprintf(stderr, "get pid from file: %s fail, " \
           "errno: %d, error info: %s\n",
           pidFilename, result, strerror(result));
-      return true;
+      return result;
     }
   }
 
-  if (kill(pid, 0) == 0) {
-    return true;
+  if (kill(*pid, 0) == 0) {
+    return 0;
   }
   else if (errno == ENOENT || errno == ESRCH) {
-    return false;
+    return ENOENT;
   }
   else {
+    result = errno != 0 ? errno : EPERM;
     fprintf(stderr, "kill pid: %d fail, errno: %d, error info: %s\n",
-        (int)pid, errno, strerror(errno));
-    return true;
+        (int)*pid, result, strerror(result));
+    return result;
   }
 }
 
-int get_base_path_from_conf_file(const char *filename, char *base_path,
-	const int path_size) 
+int get_base_path_from_conf_file_ex(const char *filename, char *base_path,
+	const int path_size, const int noent_log_level)
 {
 	char *pBasePath;
+    string_t path_string;
 	IniContext iniContext;
 	int result;
 
@@ -285,7 +302,7 @@ int get_base_path_from_conf_file(const char *filename, char *base_path,
 	do
 	{
 		pBasePath = iniGetStrValue(NULL, "base_path", &iniContext);
-		if (pBasePath == NULL)
+		if (pBasePath == NULL || *pBasePath == '\0')
 		{
 			logError("file: "__FILE__", line: %d, " \
 				"conf file \"%s\" must have item " \
@@ -294,16 +311,18 @@ int get_base_path_from_conf_file(const char *filename, char *base_path,
 			break;
 		}
 
-		snprintf(base_path, path_size, "%s", pBasePath);
+        FC_SET_STRING(path_string, pBasePath);
+        normalize_path(NULL, &path_string, base_path, path_size);
 		chopPath(base_path);
 		if (!fileExists(base_path))
-		{
-			logError("file: "__FILE__", line: %d, " \
-				"\"%s\" can't be accessed, error info: %s", \
-				__LINE__, base_path, STRERROR(errno));
-			result = errno != 0 ? errno : ENOENT;
-			break;
-		}
+        {
+            result = errno != 0 ? errno : ENOENT;
+            log_it_ex(&g_log_context, noent_log_level,
+                    "file: "__FILE__", line: %d, "
+                    "\"%s\" can't be accessed, error info: %s",
+                    __LINE__, base_path, STRERROR(result));
+            break;
+        }
 		if (!isDir(base_path))
 		{
 			logError("file: "__FILE__", line: %d, " \
@@ -320,6 +339,9 @@ int get_base_path_from_conf_file(const char *filename, char *base_path,
 
 int process_action(const char *pidFilename, const char *action, bool *stop)
 {
+    int result;
+    pid_t pid;
+
 	*stop = false;
 	if (action == NULL)
 	{
@@ -331,6 +353,23 @@ int process_action(const char *pidFilename, const char *action, bool *stop)
 		*stop = true;
 		return process_stop(pidFilename);
 	}
+    else if (strcmp(action, "status") == 0)
+	{
+		*stop = true;
+		result = process_exist(pidFilename, &pid);
+        switch (result) {
+            case 0:
+                printf("Running, pid: %d\n", (int)pid);
+                break;
+            case ENOENT:
+                printf("NOT running\n");
+                break;
+            default:
+                printf("Unkown status\n");
+                break;
+        }
+        return result;
+	}
 	else if (strcmp(action, "restart") == 0)
 	{
 		return process_restart(pidFilename);

src/process_ctrl.h

@@ -27,8 +27,11 @@
 extern "C" {
 #endif
 
-int get_base_path_from_conf_file(const char *filename, char *base_path,
-	const int path_size);
+int get_base_path_from_conf_file_ex(const char *filename, char *base_path,
+	const int path_size, const int noent_log_level);
+
+#define get_base_path_from_conf_file(filename, base_path, path_size) \
+    get_base_path_from_conf_file_ex(filename, base_path, path_size, LOG_ERR)
 
 int get_pid_from_file(const char *pidFilename, pid_t *pid);
 
@@ -36,11 +39,19 @@ int write_to_pid_file(const char *pidFilename);
 
 int delete_pid_file(const char *pidFilename);
 
-int process_stop(const char *pidFilename);
+int process_stop_ex(const char *pidFilename,
+        const bool bShowError, bool *force);
+
+static inline int process_stop(const char *pidFilename)
+{
+    const bool bShowError = true;
+    bool force;
+    return process_stop_ex(pidFilename, bShowError, &force);
+}
 
 int process_restart(const char *pidFilename);
 
-int process_exist(const char *pidFilename);
+int process_exist(const char *pidFilename, pid_t *pid);
 
 int process_action(const char *pidFilename, const char *action, bool *stop);
 

src/pthread_func.c

@@ -71,6 +71,58 @@ int init_pthread_lock(pthread_mutex_t *pthread_lock)
 	return 0;
 }
 
+int init_pthread_rwlock(pthread_rwlock_t *rwlock)
+{
+    struct {
+        pthread_rwlockattr_t holder;
+        pthread_rwlockattr_t *ptr;
+    } attr;
+	int result;
+
+
+#ifdef WITH_PTHREAD_RWLOCKATTR_SETKIND_NP
+    attr.ptr = &attr.holder;
+	if ((result=pthread_rwlockattr_init(attr.ptr)) != 0) {
+		logError("file: "__FILE__", line: %d, "
+			"call pthread_rwlockattr_init fail, "
+			"errno: %d, error info: %s",
+			__LINE__, result, STRERROR(result));
+		return result;
+	}
+
+	if ((result=pthread_rwlockattr_setkind_np(attr.ptr,
+			PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP)) != 0)
+    {
+        logError("file: "__FILE__", line: %d, "
+                "call pthread_rwlockattr_settype fail, "
+                "errno: %d, error info: %s",
+                __LINE__, result, STRERROR(result));
+        return result;
+    }
+#else
+    attr.ptr = NULL;
+#endif
+
+	if ((result=pthread_rwlock_init(rwlock, attr.ptr)) != 0) {
+		logError("file: "__FILE__", line: %d, "
+			"call pthread_rwlock_init fail, "
+			"errno: %d, error info: %s",
+			__LINE__, result, STRERROR(result));
+		return result;
+	}
+    if (attr.ptr != NULL) {
+        if ((result=pthread_rwlockattr_destroy(attr.ptr)) != 0) {
+            logError("file: "__FILE__", line: %d, "
+                    "call thread_rwlockattr_destroy fail, "
+                    "errno: %d, error info: %s",
+                    __LINE__, result, STRERROR(result));
+            return result;
+        }
+    }
+
+	return 0;
+}
+
 int init_pthread_attr(pthread_attr_t *pattr, const int stack_size)
 {
 	size_t old_stack_size;

src/pthread_func.h

@@ -32,6 +32,7 @@ extern "C" {
 #endif
 
 int init_pthread_lock(pthread_mutex_t *pthread_lock);
+int init_pthread_rwlock(pthread_rwlock_t *rwlock);
 int init_pthread_attr(pthread_attr_t *pattr, const int stack_size);
 
 int init_pthread_lock_cond_pair(pthread_lock_cond_pair_t *lcp);
@@ -63,6 +64,45 @@ void destroy_pthread_lock_cond_pair(pthread_lock_cond_pair_t *lcp);
     } while (0)
 
 
+#define PTHREAD_RWLOCK_WRLOCK(rwlock) \
+    do {  \
+        int rwlock_res;   \
+        if ((rwlock_res=pthread_rwlock_wrlock(rwlock)) != 0) \
+        {  \
+            logWarning("file: "__FILE__", line: %d, "  \
+                    "call pthread_rwlock_wrlock fail, " \
+                    "errno: %d, error info: %s", \
+                    __LINE__, rwlock_res, STRERROR(rwlock_res)); \
+        }  \
+    } while (0)
+
+
+#define PTHREAD_RWLOCK_RDLOCK(rwlock) \
+    do {  \
+        int rwlock_res;   \
+        if ((rwlock_res=pthread_rwlock_rdlock(rwlock)) != 0) \
+        {  \
+            logWarning("file: "__FILE__", line: %d, "  \
+                    "call pthread_rwlock_rdlock fail, " \
+                    "errno: %d, error info: %s", \
+                    __LINE__, rwlock_res, STRERROR(rwlock_res)); \
+        }  \
+    } while (0)
+
+
+#define PTHREAD_RWLOCK_UNLOCK(rwlock) \
+    do {  \
+        int unlock_res;   \
+        if ((unlock_res=pthread_rwlock_unlock(rwlock)) != 0) \
+        {  \
+            logWarning("file: "__FILE__", line: %d, "    \
+                    "call pthread_rwlock_unlock fail, " \
+                    "errno: %d, error info: %s", \
+                    __LINE__, unlock_res, STRERROR(unlock_res)); \
+        }  \
+    } while (0)
+
+
 #define lcp_timedwait_sec(lcp, timeout)    \
     fc_timedwait_sec(&(lcp)->lock, &(lcp)->cond, timeout)
 
@@ -74,9 +114,9 @@ static inline void fc_timedwait_sec(pthread_mutex_t *lock,
 {
     struct timespec ts;
 
-    PTHREAD_MUTEX_LOCK(lock);
     ts.tv_sec = get_current_time() + timeout;
     ts.tv_nsec = 0;
+    PTHREAD_MUTEX_LOCK(lock);
     pthread_cond_timedwait(cond, lock, &ts);
     PTHREAD_MUTEX_UNLOCK(lock);
 }
@@ -88,13 +128,67 @@ static inline void fc_timedwait_ms(pthread_mutex_t *lock,
     struct timespec ts;
 
     expires_ms = get_current_time_ms() + timeout_ms;
-    PTHREAD_MUTEX_LOCK(lock);
     ts.tv_sec =  expires_ms / 1000;
     ts.tv_nsec = (expires_ms % 1000) * (1000 * 1000);
+    PTHREAD_MUTEX_LOCK(lock);
     pthread_cond_timedwait(cond, lock, &ts);
     PTHREAD_MUTEX_UNLOCK(lock);
 }
 
+static inline int fc_timeout_to_timespec(const int timeout,
+        const int time_unit, struct timespec *ts)
+{
+    int seconds;
+
+    switch (time_unit) {
+        case FC_TIME_UNIT_SECOND:
+            seconds = timeout;
+            ts->tv_nsec = 0;
+            break;
+        case FC_TIME_UNIT_MSECOND:
+            seconds = timeout / 1000;
+            ts->tv_nsec = (timeout % 1000) * (1000 * 1000);
+            break;
+        case FC_TIME_UNIT_USECOND:
+            seconds = timeout / (1000 * 1000);
+            ts->tv_nsec = (timeout % (1000 * 1000)) * 1000;
+            break;
+        case FC_TIME_UNIT_NSECOND:
+            seconds = timeout / (1000 * 1000 * 1000);
+            ts->tv_nsec  = timeout % (1000 * 1000 * 1000);
+            break;
+        default:
+            logError("file: "__FILE__", line: %d, "
+                    "invalid time unit: %d", __LINE__, time_unit);
+            return EINVAL;
+    }
+
+    ts->tv_sec = get_current_time() + seconds;
+    return 0;
+}
+
+static inline int fc_cond_timedwait(pthread_lock_cond_pair_t *lcp,
+        const int timeout, const int time_unit)
+{
+    struct timespec ts;
+    int result;
+
+    if ((result=fc_timeout_to_timespec(timeout, time_unit, &ts)) != 0) {
+        return result;
+    }
+    return pthread_cond_timedwait(&lcp->cond, &lcp->lock, &ts);
+}
+
+#define fc_cond_timedwait_sec(lcp, timeout) \
+    fc_cond_timedwait(lcp, timeout, FC_TIME_UNIT_SECOND)
+
+#define fc_cond_timedwait_ms(lcp, timeout_ms) \
+    fc_cond_timedwait(lcp, timeout_ms, FC_TIME_UNIT_MSECOND)
+
+#define fc_cond_timedwait_us(lcp, timeout_us) \
+    fc_cond_timedwait(lcp, timeout_us, FC_TIME_UNIT_USECOND)
+
+
 int create_work_threads(int *count, void *(*start_func)(void *),
 		void **args, pthread_t *tids, const int stack_size);
 

src/sched_thread.c

@@ -45,16 +45,63 @@ static int sched_cmp_by_next_call_time(const void *p1, const void *p2)
 			((ScheduleEntry *)p2)->next_call_time;
 }
 
+time_t sched_make_first_call_time(struct tm *tm_current,
+        const TimeInfo *time_base, const int interval)
+{
+    int remain;
+    struct {
+        time_t time;
+        struct tm tm;
+    } base;
+
+    if (time_base->hour == TIME_NONE)
+    {
+        return g_current_time + interval;
+    }
+
+    if (tm_current->tm_hour > time_base->hour ||
+            (tm_current->tm_hour == time_base->hour
+             && tm_current->tm_min >= time_base->minute))
+    {
+        base.tm = *tm_current;
+    }
+    else
+    {
+        base.time = g_current_time - 24 * 3600;
+        localtime_r(&base.time, &base.tm);
+    }
+
+    base.tm.tm_hour = time_base->hour;
+    base.tm.tm_min = time_base->minute;
+    if (time_base->second >= 0 && time_base->second <= 59)
+    {
+        base.tm.tm_sec = time_base->second;
+    }
+    else
+    {
+        base.tm.tm_sec = 0;
+    }
+    base.time = mktime(&base.tm);
+    remain = g_current_time - base.time;
+    if (remain > 0)
+    {
+        return g_current_time + interval - remain % interval;
+    }
+    else if (remain < 0)
+    {
+        return g_current_time + (-1 * remain) % interval;
+    }
+    else
+    {
+        return g_current_time;
+    }
+}
+
 static int sched_init_entries(ScheduleEntry *entries, const int count)
 {
 	ScheduleEntry *pEntry;
 	ScheduleEntry *pEnd;
-	time_t time_base;
 	struct tm tm_current;
-	struct tm tm_base;
-    time_t current_time;
-    int remain;
-    int interval;
 
 	if (count < 0)
 	{
@@ -68,8 +115,8 @@ static int sched_init_entries(ScheduleEntry *entries, const int count)
 		return 0;
 	}
 
-	current_time = time(NULL);
-	localtime_r((time_t *)&current_time, &tm_current);
+	g_current_time = time(NULL);
+	localtime_r((time_t *)&g_current_time, &tm_current);
 	pEnd = entries + count;
 	for (pEntry=entries; pEntry<pEnd; pEntry++)
 	{
@@ -80,65 +127,21 @@ static int sched_init_entries(ScheduleEntry *entries, const int count)
 
 		if (pEntry->interval <= 0)
 		{
-			logError("file: "__FILE__", line: %d, " \
-				"shedule interval %d <= 0",  \
-				__LINE__, pEntry->interval);
+			logError("file: "__FILE__", line: %d, "
+				"shedule id: %d, interval %d <= 0",
+				__LINE__, pEntry->id, pEntry->interval);
 			return EINVAL;
 		}
 
-		if (pEntry->time_base.hour == TIME_NONE)
-		{
-			pEntry->next_call_time = current_time +
-						pEntry->interval;
-		}
-		else
-		{
-			if (tm_current.tm_hour > pEntry->time_base.hour ||
-				(tm_current.tm_hour == pEntry->time_base.hour
-				&& tm_current.tm_min >= pEntry->time_base.minute))
-            {
-                tm_base = tm_current;
-            }
-			else
-			{
-				time_base = current_time - 24 * 3600;
-				localtime_r(&time_base, &tm_base);
-			}
-
-			tm_base.tm_hour = pEntry->time_base.hour;
-			tm_base.tm_min = pEntry->time_base.minute;
-            if (pEntry->time_base.second >= 0 && pEntry->time_base.second <= 59)
-            {
-                tm_base.tm_sec = pEntry->time_base.second;
-            }
-            else
-            {
-                tm_base.tm_sec = 0;
-            }
-			time_base = mktime(&tm_base);
-            remain = current_time - time_base;
-            if (remain > 0)
-            {
-                interval = pEntry->interval - remain % pEntry->interval;
-            }
-            else if (remain < 0)
-            {
-                interval = (-1 * remain) % pEntry->interval;
-            }
-            else
-            {
-                interval = 0;
-            }
-
-			pEntry->next_call_time = current_time + interval;
-		}
+        pEntry->next_call_time = sched_make_first_call_time(
+                &tm_current, &pEntry->time_base, pEntry->interval);
 
         /*
 		{
 			char buff1[32];
 			char buff2[32];
 			logInfo("id=%d, current time=%s, first call time=%s",
-				pEntry->id, formatDatetime(current_time,
+				pEntry->id, formatDatetime(g_current_time,
 				"%Y-%m-%d %H:%M:%S", buff1, sizeof(buff1)),
 				formatDatetime(pEntry->next_call_time,
 				"%Y-%m-%d %H:%M:%S", buff2, sizeof(buff2)));
@@ -377,6 +380,10 @@ static void *sched_call_func(void *args)
     TaskFunc task_func;
     int task_id;
 
+#ifdef OS_LINUX
+    prctl(PR_SET_NAME, "sched-call");
+#endif
+
     pEntry = (ScheduleEntry *)args;
     task_func = pEntry->task_func;
     func_args = pEntry->func_args;
@@ -405,6 +412,10 @@ static void *sched_thread_entrance(void *args)
 	int exec_count;
 	int i;
 
+#ifdef OS_LINUX
+    prctl(PR_SET_NAME, "sched");
+#endif
+
 	pContext = (ScheduleContext *)args;
 	if (sched_init_entries(pContext->scheduleArray.entries,
                 pContext->scheduleArray.count) != 0)
@@ -708,7 +719,7 @@ int sched_start_ex(ScheduleArray *pScheduleArray, pthread_t *ptid,
     if (timer_slot_count > 0)
     {
         if ((result=fast_mblock_init_ex1(&pContext->delay_task_allocator,
-                        "sched_delay_task", sizeof(FastDelayTask),
+                        "sched-delay-task", sizeof(FastDelayTask),
                         mblock_alloc_once, 0, NULL, NULL, true)) != 0)
         {
 	    	free(pContext);
@@ -832,7 +843,7 @@ static void sched_deal_task_queue(ScheduleContext *pContext)
     FastDelayTask *task;
     struct fc_queue_info qinfo;
 
-    fc_queue_pop_to_queue(&pContext->delay_queue, &qinfo);
+    fc_queue_try_pop_to_queue(&pContext->delay_queue, &qinfo);
     task = qinfo.head;
     while (task != NULL)
     {
@@ -852,6 +863,10 @@ static void *sched_call_delay_func(void *args)
     ScheduleContext *pContext;
     FastDelayTask *task;
 
+#ifdef OS_LINUX
+    prctl(PR_SET_NAME, "sched-delay");
+#endif
+
     delay_context = (struct delay_thread_context *)args;
     task = delay_context->task;
     pContext = delay_context->schedule_context;
@@ -948,3 +963,16 @@ uint32_t sched_generate_next_id()
 {
     return ++next_id;
 }
+
+static int sched_free_ptr_func(void *ptr)
+{
+    free(ptr);
+    return 0;
+}
+
+int sched_delay_free_ptr(void *ptr, const int delay_seconds)
+{
+    const bool new_thread = false;
+    return sched_add_delay_task_ex(schedule_context, sched_free_ptr_func,
+            ptr, delay_seconds, new_thread);
+}

src/sched_thread.h

@@ -168,6 +168,15 @@ int sched_add_delay_task(TaskFunc task_func, void *func_args,
         const int delay_seconds, const bool new_thread);
 
 
+/** delay free a pointer
+ *  parameters:
+ *  	     ptr: the ptr to free
+ *  	     delay_seconds: delay seconds to free the ptr
+ * return: error no, 0 for success, != 0 fail
+*/
+int sched_delay_free_ptr(void *ptr, const int delay_seconds);
+
+
 /** init the schedule context
  *  parameters:
  *  	     pContext: store the ScheduleContext pointer
@@ -197,6 +206,9 @@ int sched_start(ScheduleArray *pScheduleArray, pthread_t *ptid, \
 */
 void sched_print_all_entries();
 
+time_t sched_make_first_call_time(struct tm *tm_current,
+        const TimeInfo *time_base, const int interval);
+
 #ifdef __cplusplus
 }
 #endif

src/server_id_func.c

@@ -244,6 +244,7 @@ static int fc_server_check_ip_port(FCServerConfig *ctx,
     FCServerMap *previous;
     FCServerMap *current;
     FCServerMap *end;
+    char formatted_ip[FORMATTED_IP_SIZE];
     int id1;
     int id2;
 
@@ -261,8 +262,8 @@ static int fc_server_check_ip_port(FCServerConfig *ctx,
             logError("file: "__FILE__", line: %d, "
                     "config file: %s, duplicate ip:port %s:%u, "
                     "the server ids: %d, %d", __LINE__,
-                    config_filename, previous->ip_addr.str,
-                    previous->port, id1, id2);
+                    config_filename, format_ip_address(previous->ip_addr.str,
+                        formatted_ip), previous->port, id1, id2);
             return EEXIST;
         }
 
@@ -293,15 +294,18 @@ FCServerInfo *fc_server_get_by_ip_port_ex(FCServerConfig *ctx,
 static inline void fc_server_set_group_ptr_name(FCServerGroupInfo *ginfo,
         const char *group_name)
 {
+    int len;
+
     ginfo->group_name.str = ginfo->name_buff;
-    ginfo->group_name.len = snprintf(ginfo->name_buff,
-            sizeof(ginfo->name_buff) - 1, "%s", group_name);
-    if (ginfo->group_name.len == 0) {
-        return;
+    len = strlen(group_name);
+    if (len >= sizeof(ginfo->name_buff)) {
+        len = sizeof(ginfo->name_buff) - 1;
     }
 
-    fc_trim(ginfo->group_name.str);
-    ginfo->group_name.len = strlen(ginfo->group_name.str);
+    memcpy(ginfo->name_buff, group_name, len);
+    *(ginfo->name_buff + len) = '\0';
+    fc_trim(ginfo->name_buff);
+    ginfo->group_name.len = strlen(ginfo->name_buff);
 }
 
 static inline void fc_server_set_ip_prefix(FCServerGroupInfo *ginfo,
@@ -309,40 +313,111 @@ static inline void fc_server_set_ip_prefix(FCServerGroupInfo *ginfo,
 {
     ginfo->filter.ip_prefix.str = ginfo->filter.prefix_buff;
     if (ip_prefix != NULL) {
-        ginfo->filter.ip_prefix.len = snprintf(ginfo->filter.prefix_buff,
-                sizeof(ginfo->filter.prefix_buff) - 1, "%s", ip_prefix);
+        ginfo->filter.ip_prefix.len = fc_safe_strcpy(
+                ginfo->filter.prefix_buff, ip_prefix);
     }
 }
 
-static int fc_server_load_one_group(FCServerConfig *ctx,
-        const char *config_filename, IniContext *ini_context,
-        const int group_count, const char *section_name)
+static inline int fc_server_set_comm_type(FCCommunicationType *comm_type,
+        const char *config_filename, const char *section_name,
+        const char *comm_type_str, const FCCommunicationType default_comm_type)
 {
+    if (comm_type_str == NULL) {
+        *comm_type = default_comm_type;
+        return 0;
+    } else if (strcasecmp(comm_type_str, "socket") == 0) {
+        *comm_type = fc_comm_type_sock;
+        return 0;
+    } else if (strcasecmp(comm_type_str, "rdma") == 0) {
+        *comm_type = fc_comm_type_rdma;
+        return 0;
+    } else {
+        logError("file: "__FILE__", line: %d, "
+                "config filename: %s, section: %s, "
+                "invalid communication: %s!", __LINE__,
+                config_filename, section_name, comm_type_str);
+        return EINVAL;
+    }
+}
+
+static int load_comm_type_and_smart_polling(IniFullContext *ini_ctx,
+        FCCommunicationType *comm_type, FCSmartPollingConfig *smart_polling,
+        const FCCommunicationType default_comm_type,
+        const FCSmartPollingConfig *default_smart_polling)
+{
+    int result;
+    char *comm_type_str;
+
+    comm_type_str = iniGetStrValue(ini_ctx->section_name,
+            "communication", ini_ctx->context);
+    if (comm_type_str == NULL) {
+        comm_type_str = iniGetStrValue(ini_ctx->section_name,
+                "comm_type", ini_ctx->context);
+    }
+    if ((result=fc_server_set_comm_type(comm_type, ini_ctx->filename,
+                    ini_ctx->section_name, comm_type_str,
+                    default_comm_type)) != 0)
+    {
+        return result;
+    }
+
+    if (*comm_type == fc_comm_type_sock) {
+        smart_polling->enabled = false;
+        smart_polling->switch_on_iops = 0;
+        smart_polling->switch_on_count = 0;
+    } else {
+        smart_polling->enabled = iniGetBoolValue(ini_ctx->section_name,
+                "smart_polling", ini_ctx->context,
+                default_smart_polling->enabled);
+        smart_polling->switch_on_iops = iniGetIntValue(ini_ctx->section_name,
+                "polling_switch_on_iops", ini_ctx->context,
+                default_smart_polling->switch_on_iops);
+        smart_polling->switch_on_count = iniGetIntValue(ini_ctx->section_name,
+                "polling_switch_on_count", ini_ctx->context,
+                default_smart_polling->switch_on_count);
+    }
+    return 0;
+}
+
+static inline int load_buffer_size(IniFullContext *ini_ctx,
+        const int default_buffer_size)
+{
+    int buffer_size;
+    buffer_size = iniGetByteValue(ini_ctx->section_name, "buffer_size",
+            ini_ctx->context, default_buffer_size);
+    return iniCheckAndCorrectIntValue(ini_ctx, "buffer_size",
+            buffer_size, 8 * 1024, 8 * 1024 * 1024);
+}
+
+static int fc_server_load_one_group(FCServerConfig *ctx,
+        IniFullContext *ini_ctx, const int group_count)
+{
+    int result;
     FCServerGroupInfo *group;
     char new_name[FAST_INI_ITEM_NAME_SIZE];
     char *port_str;
     char *net_type;
     char *ip_prefix;
 
-    strcpy(new_name, section_name);
+    strcpy(new_name, ini_ctx->section_name);
     group = ctx->group_array.groups + ctx->group_array.count;
     fc_server_set_group_ptr_name(group, new_name + GROUP_SECTION_PREFIX_LEN);
-
     if (group->group_name.len == 0) {
         logError("file: "__FILE__", line: %d, "
                 "config filename: %s, section: %s, no group name!",
-                __LINE__, config_filename, section_name);
+                __LINE__, ini_ctx->filename, ini_ctx->section_name);
         return EINVAL;
     }
 
-    port_str = iniGetStrValue(section_name, SERVER_ITEM_PORT_STR, ini_context);
+    port_str = iniGetStrValue(ini_ctx->section_name,
+            SERVER_ITEM_PORT_STR, ini_ctx->context);
     if (port_str == NULL) {
         if (group_count == 1) {
             group->port = ctx->default_port;
         } else {
             logError("file: "__FILE__", line: %d, "
                     "config filename: %s, section: %s, no item: %s!",
-                    __LINE__, config_filename, section_name,
+                    __LINE__, ini_ctx->filename, ini_ctx->section_name,
                     SERVER_ITEM_PORT_STR);
             return ENOENT;
         }
@@ -352,24 +427,39 @@ static int fc_server_load_one_group(FCServerConfig *ctx,
         if (group->port <= 0 || (endptr != NULL && *endptr != '\0')) {
             logError("file: "__FILE__", line: %d, "
                     "config filename: %s, section: %s, item: %s, "
-                    "invalid port: %s", __LINE__, config_filename,
-                    section_name, SERVER_ITEM_PORT_STR, port_str);
+                    "invalid port: %s", __LINE__, ini_ctx->filename,
+                    ini_ctx->section_name, SERVER_ITEM_PORT_STR, port_str);
             return EINVAL;
         }
     }
 
-    net_type = iniGetStrValue(section_name, "net_type", ini_context);
+    net_type = iniGetStrValue(ini_ctx->section_name,
+            "net_type", ini_ctx->context);
     group->filter.net_type = fc_get_net_type_by_name(net_type);
     if (group->filter.net_type == FC_NET_TYPE_NONE) {
         logError("file: "__FILE__", line: %d, "
                 "config filename: %s, section: %s, invalid net_type: %s",
-                __LINE__, config_filename, group->group_name.str, net_type);
+                __LINE__, ini_ctx->filename, group->group_name.str, net_type);
         return EINVAL;
     }
 
-    ip_prefix = iniGetStrValue(section_name, "ip_prefix", ini_context);
+    ip_prefix = iniGetStrValue(ini_ctx->section_name,
+            "ip_prefix", ini_ctx->context);
     fc_server_set_ip_prefix(group, ip_prefix);
 
+    if ((result=load_comm_type_and_smart_polling(ini_ctx,
+                    &group->comm_type, &group->smart_polling,
+                    ctx->comm_type, &ctx->smart_polling)) != 0)
+    {
+        return result;
+    }
+
+    if (group->comm_type == fc_comm_type_sock) {
+        group->buffer_size = 0;
+    } else {
+        group->buffer_size = load_buffer_size(ini_ctx, ctx->buffer_size);
+    }
+
     ctx->group_array.count++;
     return 0;
 }
@@ -429,7 +519,7 @@ static void fc_server_sort_groups(FCServerConfig *ctx)
 }
 
 static int fc_server_load_groups(FCServerConfig *ctx,
-        const char *config_filename, IniContext *ini_context)
+        IniFullContext *ini_ctx)
 {
 	int result;
     int count;
@@ -437,30 +527,30 @@ static int fc_server_load_groups(FCServerConfig *ctx,
     IniSectionInfo *section;
     IniSectionInfo *end;
 
-    if ((result=iniGetSectionNamesByPrefix(ini_context,
+    if ((result=iniGetSectionNamesByPrefix(ini_ctx->context,
                     GROUP_SECTION_PREFIX_STR, sections,
                     FC_MAX_GROUP_COUNT, &count)) != 0)
     {
         logError("file: "__FILE__", line: %d, "
                 "config filename: %s, get sections by prefix %s fail, "
-                "errno: %d, error info: %s", __LINE__, config_filename,
+                "errno: %d, error info: %s", __LINE__, ini_ctx->filename,
                 GROUP_SECTION_PREFIX_STR, result, STRERROR(result));
         return result;
     }
 
     if (count == 0) {
         ctx->group_array.count = 1;
+        memset(ctx->group_array.groups, 0, sizeof(FCServerGroupInfo));
         fc_server_set_group_ptr_name(ctx->group_array.groups + 0, "");
         ctx->group_array.groups[0].port = iniGetIntValue(NULL, "port",
-            ini_context, ctx->default_port);
+                ini_ctx->context, ctx->default_port);
         return 0;
     }
 
     end = sections + count;
     for (section=sections; section<end; section++) {
-        if ((result=fc_server_load_one_group(ctx, config_filename,
-                        ini_context, count, section->section_name)) != 0)
-        {
+        ini_ctx->section_name = section->section_name;
+        if ((result=fc_server_load_one_group(ctx, ini_ctx, count)) != 0) {
             return result;
         }
     }
@@ -612,6 +702,7 @@ static int check_addresses_duplicate(FCServerConfig *ctx,
     FCAddressInfo **ppaddr;
     FCAddressInfo **ppend;
     FCAddressInfo **pprevious;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
     if (group_addr->address_array.count <= 1) {
         return 0;
@@ -629,7 +720,8 @@ static int check_addresses_duplicate(FCServerConfig *ctx,
                     config_filename, section_name,
                     group_addr->server_group->group_name.len,
                     group_addr->server_group->group_name.str,
-                    (*ppaddr)->conn.ip_addr, (*ppaddr)->conn.port);
+                    format_ip_address((*ppaddr)->conn.ip_addr, formatted_ip),
+                    (*ppaddr)->conn.port);
             return EEXIST;
         }
         pprevious = ppaddr;
@@ -794,6 +886,7 @@ static int fc_server_load_group_server(FCServerConfig *ctx,
         return result;
     }
 
+    address.conn.comm_type = group->comm_type;
     if ((result=fc_server_set_group_server_address(server,
                     group_addr, &address)) != 0)
     {
@@ -812,6 +905,7 @@ static int fc_server_set_host(FCServerConfig *ctx, FCServerInfo *server,
     FCGroupAddresses *group_addr;
     const FCAddressInfo *new_addr;
     FCAddressInfo addr_holder;
+    char formatted_ip[FORMATTED_IP_SIZE];
     int result;
     int count;
     int group_index;
@@ -835,9 +929,16 @@ static int fc_server_set_host(FCServerConfig *ctx, FCServerInfo *server,
             if (addr->conn.port == 0) {
                 addr_holder = *addr;
                 addr_holder.conn.port = FC_SERVER_GROUP_PORT(group);
+                addr_holder.conn.comm_type = group->comm_type;
                 new_addr = &addr_holder;
             } else {
-                new_addr = addr;
+                if (addr->conn.comm_type == group->comm_type) {
+                    new_addr = addr;
+                } else {
+                    addr_holder = *addr;
+                    addr_holder.conn.comm_type = group->comm_type;
+                    new_addr = &addr_holder;
+                }
             }
 
             if ((result=fc_server_set_group_server_address(server,
@@ -870,7 +971,8 @@ static int fc_server_set_host(FCServerConfig *ctx, FCServerInfo *server,
                 "config filename: %s, section: %s, "
                 "host %s:%u belongs to %d groups",
                 __LINE__, config_filename, section_name,
-                addr->conn.ip_addr, addr->conn.port, count);
+                format_ip_address(addr->conn.ip_addr, formatted_ip),
+                addr->conn.port, count);
         return EEXIST;
     }
 
@@ -1069,7 +1171,6 @@ static int fc_server_load_one_server(FCServerConfig *ctx,
     }
 
     fc_server_set_group_ptr(ctx, server);
-
     if ((result=fc_server_load_hosts(ctx, server, config_filename,
                     ini_context, section_name)) != 0)
     {
@@ -1085,25 +1186,27 @@ static int fc_server_load_servers(FCServerConfig *ctx,
 {
 #define FIXED_SECTION_COUNT  16
 	int result;
-    int count;
+    int section_count;
+    int server_count;
     IniSectionInfo *sections;
     IniSectionInfo fixed[FIXED_SECTION_COUNT];
     IniSectionInfo *section;
     IniSectionInfo *end;
 	int alloc_bytes;
 
-    count = iniGetSectionCountByPrefix(ini_context, SERVER_SECTION_PREFIX_STR);
-    if (count == 0) {
+    section_count = iniGetSectionCountByPrefix(ini_context,
+            SERVER_SECTION_PREFIX_STR);
+    if (section_count == 0) {
         logError("file: "__FILE__", line: %d, "
                 "config filename: %s, no server section such as [%s$id]",
                 __LINE__, config_filename, SERVER_SECTION_PREFIX_STR);
         return ENOENT;
     }
 
-    if (count < FIXED_SECTION_COUNT) {
+    if (section_count < FIXED_SECTION_COUNT) {
         sections = fixed;
     } else {
-        alloc_bytes = sizeof(IniSectionInfo) * count;
+        alloc_bytes = sizeof(IniSectionInfo) * section_count;
         sections = (IniSectionInfo *)fc_malloc(alloc_bytes);
         if (sections == NULL) {
             return ENOMEM;
@@ -1113,7 +1216,7 @@ static int fc_server_load_servers(FCServerConfig *ctx,
     do {
         if ((result=iniGetSectionNamesByPrefix(ini_context,
                         SERVER_SECTION_PREFIX_STR, sections,
-                        count, &count)) != 0)
+                        section_count, &section_count)) != 0)
         {
             logError("file: "__FILE__", line: %d, "
                     "config filename: %s, get sections by prefix %s fail, "
@@ -1122,14 +1225,35 @@ static int fc_server_load_servers(FCServerConfig *ctx,
             break;
         }
 
-        if ((result=fc_server_alloc_servers(&ctx->
-                        sorted_server_arrays.by_id, count)) != 0)
+        end = sections + section_count;
+        server_count = 0;
+        for (section=sections; section<end; section++) {
+            if (is_digital_string(section->section_name +
+                        SERVER_SECTION_PREFIX_LEN))
+            {
+                ++server_count;
+            }
+        }
+        if (server_count == 0) {
+            logError("file: "__FILE__", line: %d, "
+                    "config filename: %s, no server section such as [%s$id]",
+                    __LINE__, config_filename, SERVER_SECTION_PREFIX_STR);
+            return ENOENT;
+        }
+
+        if ((result=fc_server_alloc_servers(&ctx->sorted_server_arrays.
+                        by_id, server_count)) != 0)
         {
             return result;
         }
 
-        end = sections + count;
         for (section=sections; section<end; section++) {
+            if (!is_digital_string(section->section_name +
+                        SERVER_SECTION_PREFIX_LEN))
+            {
+                continue;
+            }
+
             if ((result=fc_server_load_one_server(ctx, config_filename,
                             ini_context, section->section_name)) != 0)
             {
@@ -1145,17 +1269,71 @@ static int fc_server_load_servers(FCServerConfig *ctx,
     return result;
 }
 
-int fc_server_load_data(FCServerConfig *ctx, IniContext *ini_context,
-        const char *config_filename)
+static void load_connection_thread_local(FCServerConfig *ctx,
+        IniContext *ini_context, const char *config_filename)
+{
+    char *connection_thread_local;
+
+    connection_thread_local = iniGetStrValue(NULL,
+            "connection_thread_local", ini_context);
+    if (connection_thread_local == NULL || *connection_thread_local == '\0') {
+        ctx->connection_thread_local = fc_connection_thread_local_auto;
+    } else if (strcasecmp(connection_thread_local, "auto") == 0) {
+        ctx->connection_thread_local = fc_connection_thread_local_auto;
+    } else if (strcasecmp(connection_thread_local, "yes") == 0) {
+        ctx->connection_thread_local = fc_connection_thread_local_yes;
+    } else if (strcasecmp(connection_thread_local, "no") == 0) {
+        ctx->connection_thread_local = fc_connection_thread_local_no;
+    } else {
+        logWarning("file: "__FILE__", line: %d, "
+                "config file: %s, invalid connection_thread_local: %s, "
+                "set to auto!", __LINE__, config_filename,
+                connection_thread_local);
+        ctx->connection_thread_local = fc_connection_thread_local_auto;
+    }
+}
+
+static int fc_server_load_data(FCServerConfig *ctx,
+        IniContext *ini_context, const char *config_filename)
 {
 	int result;
+    bool have_rdma;
+    IniFullContext full_ini_ctx;
+    FCSmartPollingConfig default_smart_polling;
+    FCServerGroupInfo *group;
+    FCServerGroupInfo *end;
 
-    if ((result=fc_server_load_groups(ctx, config_filename,
-                    ini_context)) != 0)
+    FAST_INI_SET_FULL_CTX_EX(full_ini_ctx,
+            config_filename, NULL, ini_context);
+    default_smart_polling.enabled = true;
+    default_smart_polling.switch_on_iops = 10240;
+    default_smart_polling.switch_on_count = 3;
+    if ((result=load_comm_type_and_smart_polling(&full_ini_ctx,
+                    &ctx->comm_type, &ctx->smart_polling,
+                    fc_comm_type_sock, &default_smart_polling)) != 0)
     {
         return result;
     }
 
+    ctx->buffer_size = load_buffer_size(&full_ini_ctx, 256 * 1024);
+    if ((result=fc_server_load_groups(ctx, &full_ini_ctx)) != 0) {
+        return result;
+    }
+
+    have_rdma = false;
+    end = ctx->group_array.groups + ctx->group_array.count;
+    for (group=ctx->group_array.groups; group<end; group++) {
+        if (group->comm_type != fc_comm_type_sock) {
+            have_rdma = true;
+            break;
+        }
+    }
+
+    if (!have_rdma) {
+        ctx->buffer_size = 0;
+    }
+    load_connection_thread_local(ctx, ini_context, config_filename);
+
     if ((result=fc_server_load_servers(ctx, config_filename,
                     ini_context)) != 0)
     {
@@ -1193,8 +1371,7 @@ int fc_server_load_from_file_ex(FCServerConfig *ctx,
     FC_SERVER_INIT_CONTEXT(ctx, default_port, min_hosts_each_group,
             share_between_groups);
 
-    if ((result=iniLoadFromFileEx(config_filename, &ini_context,
-            FAST_INI_ANNOTATION_WITH_BUILTIN, NULL, 0,
+    if ((result=iniLoadFromFile1(config_filename, &ini_context,
             FAST_INI_FLAGS_DISABLE_SAME_SECTION_MERGE)) != 0)
     {
         return result;
@@ -1214,8 +1391,7 @@ int fc_server_load_from_buffer_ex(FCServerConfig *ctx, char *content,
 
     FC_SERVER_INIT_CONTEXT(ctx, default_port, min_hosts_each_group,
             share_between_groups);
-    if ((result=iniLoadFromBufferEx(content, &ini_context,
-            FAST_INI_ANNOTATION_WITH_BUILTIN, NULL, 0,
+    if ((result=iniLoadFromBuffer1(content, &ini_context,
             FAST_INI_FLAGS_DISABLE_SAME_SECTION_MERGE)) != 0)
     {
         return result;
@@ -1226,6 +1402,16 @@ int fc_server_load_from_buffer_ex(FCServerConfig *ctx, char *content,
 	return result;
 }
 
+int fc_server_load_from_ini_context_ex(FCServerConfig *ctx,
+        IniContext *ini_context, const char *config_filename,
+        const int default_port, const int min_hosts_each_group,
+        const bool share_between_groups)
+{
+    FC_SERVER_INIT_CONTEXT(ctx, default_port, min_hosts_each_group,
+            share_between_groups);
+    return fc_server_load_data(ctx, ini_context, config_filename);
+}
+
 static void fc_server_free_addresses(FCServerConfig *ctx)
 {
 	FCServerInfo *server;
@@ -1310,13 +1496,31 @@ static int fc_groups_to_string(FCServerConfig *ctx, FastBuffer *buffer)
 
         fast_buffer_append(buffer,
                 "[%s%.*s]\n"
-                "port = %d\n"
-                "net_type = %s\n"
-                "ip_prefix = %.*s\n\n",
+                "port = %d\n",
                 GROUP_SECTION_PREFIX_STR,
                 group->group_name.len, group->group_name.str,
-                group->port, net_type_caption,
-                group->filter.ip_prefix.len,
+                group->port);
+
+        if (group->comm_type != fc_comm_type_sock) {
+            fast_buffer_append(buffer,
+                    "communication = %s\n"
+                    "smart_polling = %d\n"
+                    "polling_switch_on_iops = %d\n"
+                    "polling_switch_on_count = %d\n",
+                    fc_comm_type_str(group->comm_type),
+                    group->smart_polling.enabled,
+                    group->smart_polling.switch_on_iops,
+                    group->smart_polling.switch_on_count);
+            if (group->buffer_size != ctx->buffer_size) {
+                fast_buffer_append(buffer, "buffer_size = %d KB\n",
+                        group->buffer_size / 1024);
+            }
+        }
+
+        fast_buffer_append(buffer,
+                "net_type = %s\n"
+                "ip_prefix = %.*s\n\n",
+                net_type_caption, group->filter.ip_prefix.len,
                 group->filter.ip_prefix.str);
     }
     return 0;
@@ -1327,6 +1531,7 @@ static void fc_group_servers_to_string(FCServerConfig *ctx,
 {
     FCAddressInfo **addr;
     FCAddressInfo **end;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
     end = gaddr->address_array.addrs + gaddr->address_array.count;
     for (addr=gaddr->address_array.addrs; addr<end; addr++) {
@@ -1340,7 +1545,8 @@ static void fc_group_servers_to_string(FCServerConfig *ctx,
                     SERVER_ITEM_HOST_AFFIX_STR);
         }
         fast_buffer_append(buffer, " = %s:%u\n",
-                (*addr)->conn.ip_addr, (*addr)->conn.port);
+                format_ip_address((*addr)->conn.ip_addr, formatted_ip),
+                (*addr)->conn.port);
     }
 }
 
@@ -1393,6 +1599,14 @@ int fc_server_to_config_string(FCServerConfig *ctx, FastBuffer *buffer)
 {
     int result;
 
+    if (ctx->buffer_size > 0) {
+        if ((result=fast_buffer_check(buffer, 1024)) != 0) {
+            return result;
+        }
+        fast_buffer_append(buffer, "buffer_size = %d KB\n",
+                ctx->buffer_size / 1024);
+    }
+
     fc_server_clear_server_port(&ctx->group_array);
     if ((result=fc_groups_to_string(ctx, buffer)) != 0) {
         return result;
@@ -1405,13 +1619,31 @@ static void fc_server_log_groups(FCServerConfig *ctx)
 {
     FCServerGroupInfo *group;
     FCServerGroupInfo *end;
+    char buff[1024];
+    char *p;
 
     end = ctx->group_array.groups + ctx->group_array.count;
     for (group=ctx->group_array.groups; group<end; group++) {
-        logInfo("group_name: %.*s, port: %d, net_type: %s, ip_prefix: %.*s",
-                group->group_name.len, group->group_name.str, group->port,
+        p = buff + sprintf(buff, "group_name: %.*s, port: %d",
+                group->group_name.len, group->group_name.str,
+                group->port);
+        if (group->comm_type != fc_comm_type_sock) {
+            p += sprintf(p, ", communication: %s, smart_polling: %d, "
+                    "polling_switch_on_iops: %d, polling_switch_on_count: %d",
+                    fc_comm_type_str(group->comm_type),
+                    group->smart_polling.enabled,
+                    group->smart_polling.switch_on_iops,
+                    group->smart_polling.switch_on_count);
+            if (group->buffer_size != ctx->buffer_size) {
+                p += sprintf(p, ", buffer_size = %d KB",
+                        group->buffer_size / 1024);
+            }
+        }
+        p += sprintf(p, ", net_type: %s, ip_prefix: %.*s",
                 get_net_type_caption(group->filter.net_type),
                 group->filter.ip_prefix.len, group->filter.ip_prefix.str);
+
+        log_it1(LOG_INFO, buff, p - buff);
     }
 }
 
@@ -1419,11 +1651,13 @@ static void fc_server_log_group_servers(FCGroupAddresses *gaddr)
 {
     FCAddressInfo **addr;
     FCAddressInfo **end;
+    char formatted_ip[FORMATTED_IP_SIZE];
 
     end = gaddr->address_array.addrs + gaddr->address_array.count;
     for (addr=gaddr->address_array.addrs; addr<end; addr++) {
         logInfo("    %d. %s:%u", (int)(addr - gaddr->address_array.addrs + 1),
-                (*addr)->conn.ip_addr, (*addr)->conn.port);
+                format_ip_address((*addr)->conn.ip_addr, formatted_ip),
+                (*addr)->conn.port);
     }
 }
 
@@ -1461,69 +1695,24 @@ static void fc_server_log_servers(FCServerConfig *ctx)
 
 void fc_server_to_log(FCServerConfig *ctx)
 {
+    char buff[256];
+    char *p;
+
+    p = buff + sprintf(buff, "connection_thread_local: %s",
+            fc_connection_thread_local_str(ctx->connection_thread_local));
+    if (ctx->buffer_size > 0) {
+        p += sprintf(p, ", buffer_size: %d KB", ctx->buffer_size / 1024);
+    }
+    log_it1(LOG_INFO, buff, p - buff);
+
     fc_server_log_groups(ctx);
     fc_server_log_servers(ctx);
 }
 
-ConnectionInfo *fc_server_check_connect_ex(FCAddressPtrArray *addr_array,
-        const int connect_timeout, const char *bind_ipaddr,
-        const bool log_connect_error, int *err_no)
-{
-    FCAddressInfo **current;
-    FCAddressInfo **addr;
-    FCAddressInfo **end;
-
-    if (addr_array->count <= 0) {
-        *err_no = ENOENT;
-        return NULL;
-    }
-
-    current = addr_array->addrs + addr_array->index;
-    if ((*current)->conn.sock >= 0) {
-        return &(*current)->conn;
-    }
-
-    if ((*err_no=conn_pool_connect_server_ex(&(*current)->conn,
-                    connect_timeout, bind_ipaddr, log_connect_error)) == 0)
-    {
-        return &(*current)->conn;
-    }
-
-    if (addr_array->count == 1) {
-        return NULL;
-    }
-
-    end = addr_array->addrs + addr_array->count;
-    for (addr=addr_array->addrs; addr<end; addr++) {
-        if (addr == current) {
-            continue;
-        }
-        if ((*err_no=conn_pool_connect_server_ex(&(*addr)->conn,
-                        connect_timeout, bind_ipaddr,
-                        log_connect_error)) == 0)
-        {
-            addr_array->index = addr - addr_array->addrs;
-            return &(*addr)->conn;
-        }
-    }
-
-    return NULL;
-}
-
-void fc_server_disconnect(FCAddressPtrArray *addr_array)
-{
-    FCAddressInfo **current;
-
-    current = addr_array->addrs + addr_array->index;
-    if ((*current)->conn.sock >= 0) {
-        close((*current)->conn.sock);
-        (*current)->conn.sock = -1;
-    }
-}
-
 int fc_server_make_connection_ex(FCAddressPtrArray *addr_array,
-        ConnectionInfo *conn, const int connect_timeout,
-        const char *bind_ipaddr, const bool log_connect_error)
+        ConnectionInfo *conn, const char *service_name,
+        const int connect_timeout, const char *bind_ipaddr,
+        const bool log_connect_error)
 {
     FCAddressInfo **current;
     FCAddressInfo **addr;
@@ -1535,9 +1724,11 @@ int fc_server_make_connection_ex(FCAddressPtrArray *addr_array,
     }
 
     current = addr_array->addrs + addr_array->index;
-    *conn = (*current)->conn;
-    conn->sock = -1;
-    if ((result=conn_pool_connect_server_ex(conn, connect_timeout,
+    conn_pool_set_server_info(conn, (*current)->conn.ip_addr,
+            (*current)->conn.port);
+    conn->comm_type = (*current)->conn.comm_type;
+    if ((result=G_COMMON_CONNECTION_CALLBACKS[conn->comm_type].
+                make_connection(conn, service_name, connect_timeout * 1000,
                     bind_ipaddr, log_connect_error)) == 0)
     {
         return 0;
@@ -1553,9 +1744,11 @@ int fc_server_make_connection_ex(FCAddressPtrArray *addr_array,
             continue;
         }
 
-        *conn = (*addr)->conn;
-        conn->sock = -1;
-        if ((result=conn_pool_connect_server_ex(conn, connect_timeout,
+        conn_pool_set_server_info(conn, (*addr)->conn.ip_addr,
+                (*addr)->conn.port);
+        conn->comm_type = (*addr)->conn.comm_type;
+        if ((result=G_COMMON_CONNECTION_CALLBACKS[conn->comm_type].
+                make_connection(conn, service_name, connect_timeout * 1000,
                         bind_ipaddr, log_connect_error)) == 0)
         {
             addr_array->index = addr - addr_array->addrs;
@@ -1590,3 +1783,36 @@ const FCAddressInfo *fc_server_get_address_by_peer(
 
     return *(addr_array->addrs);
 }
+
+struct ibv_pd *fc_alloc_rdma_pd(fc_alloc_pd_callback alloc_pd,
+        FCAddressPtrArray *address_array, int *result)
+{
+    char *ip_addrs[FC_MAX_SERVER_IP_COUNT];
+    char **ip_addr;
+    FCAddressInfo **addr;
+    FCAddressInfo **end;
+    struct ibv_pd *pd;
+    int port;
+
+    if (address_array->count == 0) {
+        port = 0;
+    } else {
+        port = address_array->addrs[0]->conn.port;
+    }
+
+    end = address_array->addrs + address_array->count;
+    for (addr=address_array->addrs, ip_addr=ip_addrs;
+            addr<end; addr++, ip_addr++)
+    {
+        *ip_addr = (*addr)->conn.ip_addr;
+    }
+
+    if ((pd=alloc_pd((const char **)ip_addrs, address_array->
+                    count, port)) != NULL)
+    {
+        *result = 0;
+    } else {
+        *result = ENODEV;
+    }
+    return pd;
+}

src/server_id_func.h

@@ -52,11 +52,21 @@ typedef struct {
     FCAddressInfo **addrs;
 } FCAddressPtrArray;
 
+typedef struct
+{
+    bool enabled;
+    int switch_on_iops;
+    int switch_on_count;
+} FCSmartPollingConfig;
+
 typedef struct
 {
     string_t group_name;
     int port;          //default port
     int server_port;   //port in server section
+    int buffer_size;  //for RDMA
+    FCCommunicationType comm_type;
+    FCSmartPollingConfig smart_polling;
     struct {
         int net_type;
         string_t ip_prefix;
@@ -111,11 +121,21 @@ typedef struct
     FCServerMap *maps;
 } FCServerMapArray;
 
-typedef struct
+typedef enum {
+    fc_connection_thread_local_auto,
+    fc_connection_thread_local_yes,
+    fc_connection_thread_local_no
+} FCServerConnThreadLocal;
+
+typedef struct fc_server_config
 {
     int default_port;
     int min_hosts_each_group;
     bool share_between_groups;  //if an address shared between different groups
+    int buffer_size;  //for RDMA
+    FCCommunicationType comm_type;
+    FCSmartPollingConfig smart_polling;
+    FCServerConnThreadLocal connection_thread_local;
     FCServerGroupArray group_array;
     struct {
         FCServerInfoArray by_id;     //sorted by server id
@@ -140,6 +160,16 @@ static inline FCServerInfo *fc_server_get_by_ip_port(FCServerConfig *ctx,
 FCServerGroupInfo *fc_server_get_group_by_name(FCServerConfig *ctx,
         const string_t *group_name);
 
+static inline FCServerGroupInfo *fc_server_get_group_by_index(
+        FCServerConfig *ctx, const int index)
+{
+    if (index < 0 || index >= ctx->group_array.count) {
+        return NULL;
+    }
+
+    return ctx->group_array.groups + index;
+}
+
 static inline int fc_server_get_group_index_ex(FCServerConfig *ctx,
         const string_t *group_name)
 {
@@ -189,30 +219,69 @@ static inline int fc_server_load_from_buffer(FCServerConfig *ctx,
             default_port, min_hosts_each_group, share_between_groups);
 }
 
+int fc_server_load_from_ini_context_ex(FCServerConfig *ctx,
+        IniContext *ini_context, const char *config_filename,
+        const int default_port, const int min_hosts_each_group,
+        const bool share_between_groups);
+
+static inline int fc_server_load_from_ini_context(FCServerConfig *ctx,
+        IniContext *ini_context, const char *config_filename)
+{
+    const int default_port = 0;
+    const int min_hosts_each_group = 1;
+    const bool share_between_groups = false;
+    return fc_server_load_from_ini_context_ex(ctx, ini_context,
+            config_filename, default_port, min_hosts_each_group,
+            share_between_groups);
+}
+
 void fc_server_destroy(FCServerConfig *ctx);
 
 int fc_server_to_config_string(FCServerConfig *ctx, FastBuffer *buffer);
 
 void fc_server_to_log(FCServerConfig *ctx);
 
-ConnectionInfo *fc_server_check_connect_ex(FCAddressPtrArray *addr_array,
-        const int connect_timeout, const char *bind_ipaddr,
-        const bool log_connect_error, int *err_no);
-
-#define fc_server_check_connect(addr_array, connect_timeout, err_no) \
-    fc_server_check_connect_ex(addr_array, connect_timeout, NULL, true, err_no)
-
-void fc_server_disconnect(FCAddressPtrArray *addr_array);
-
 const FCAddressInfo *fc_server_get_address_by_peer(
         FCAddressPtrArray *addr_array, const char *peer_ip);
 
 int fc_server_make_connection_ex(FCAddressPtrArray *addr_array,
-        ConnectionInfo *conn, const int connect_timeout,
-        const char *bind_ipaddr, const bool log_connect_error);
+        ConnectionInfo *conn, const char *service_name,
+        const int connect_timeout, const char *bind_ipaddr,
+        const bool log_connect_error);
 
-#define fc_server_make_connection(addr_array, conn, connect_timeout) \
-    fc_server_make_connection_ex(addr_array, conn, connect_timeout, NULL, true)
+#define fc_server_make_connection(addr_array, \
+        conn, service_name, connect_timeout)  \
+    fc_server_make_connection_ex(addr_array, conn, \
+            service_name, connect_timeout, NULL, true)
+
+static inline void fc_server_close_connection(ConnectionInfo *conn)
+{
+    G_COMMON_CONNECTION_CALLBACKS[conn->comm_type].close_connection(conn);
+}
+
+static inline void fc_server_destroy_connection(ConnectionInfo *conn)
+{
+    fc_server_close_connection(conn);
+    conn_pool_free_connection(conn);
+}
+
+struct ibv_pd *fc_alloc_rdma_pd(fc_alloc_pd_callback alloc_pd,
+        FCAddressPtrArray *address_array, int *result);
+
+static inline const char *fc_connection_thread_local_str(
+        const FCServerConnThreadLocal value)
+{
+    switch (value) {
+        case fc_connection_thread_local_auto:
+            return "auto";
+        case fc_connection_thread_local_yes:
+            return "yes";
+        case fc_connection_thread_local_no:
+            return "no";
+        default:
+            return "unkown";
+    }
+}
 
 #ifdef __cplusplus
 }

src/shared_buffer.c

@@ -42,7 +42,7 @@ int shared_buffer_init_ex(SharedBufferContext *context,
     int result;
 
     context->buffer_init_capacity = buffer_init_capacity;
-    if ((result=fast_mblock_init_ex1(&context->allocator, "shared_buffer",
+    if ((result=fast_mblock_init_ex1(&context->allocator, "shared-buffer",
                     sizeof(SharedBuffer), alloc_elements_once,
                     alloc_elements_limit, shared_buffer_alloc_init,
                     context, need_lock)) != 0)

src/sockopt.h

@@ -18,16 +18,18 @@
 #ifndef _SOCKETOPT_H_
 #define _SOCKETOPT_H_
 
-#include <net/if.h>
+#include <stdio.h>
 #include <string.h>
 #include <fcntl.h>
+#include <net/if.h>
 #include <sys/types.h>
-#include <sys/stat.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <netinet/tcp.h>
+#include <netdb.h>
 #include "common_define.h"
+#include "shared_func.h"
 
 #define FC_NET_TYPE_NONE          0
 #define FC_NET_TYPE_OUTER         1   //extranet IP
@@ -54,14 +56,14 @@
 
 typedef struct fast_if_config {
     char name[IF_NAMESIZE];    //if name
-    char mac[32];
+    char mac[64];
     char ipv4[IP_ADDRESS_SIZE];
-    char ipv6[48];
+    char ipv6[IP_ADDRESS_SIZE];
 } FastIFConfig;
 
 typedef struct ip_addr_s {
-    char ip_addr[INET6_ADDRSTRLEN];
-    int socket_domain;
+    char ip_addr[IP_ADDRESS_SIZE];
+    int af;
 } ip_addr_t;
 
 typedef struct sockaddr_convert_s {
@@ -107,13 +109,13 @@ extern "C" {
     extern bool g_tcp_quick_ack;
 #endif
 
-typedef int (*getnamefunc)(int socket, struct sockaddr *address, \
+typedef int (*getnamefunc)(int socket, struct sockaddr *address,
 		socklen_t *address_len);
 
-typedef int (*tcpsenddatafunc)(int sock, void* data, const int size, \
+typedef int (*tcpsenddatafunc)(int sock, void *data, const int size,
 		const int timeout);
 
-typedef int (*tcprecvdata_exfunc)(int sock, void *data, const int size, \
+typedef int (*tcprecvdata_exfunc)(int sock, void *data, const int size,
 		const int timeout, int *count);
 
 #define getSockIpaddr(sock, buff, bufferSize) \
@@ -144,7 +146,7 @@ int tcpgets(int sock, char *s, const int size, const int timeout);
  *          data: the buffer
  *          size: buffer size (max bytes can receive)
  *          timeout: read timeout
- *          count: store the bytes recveived
+ *          count: store the bytes received
  *  return: error no, 0 success, != 0 fail
 */
 int tcprecvdata_ex(int sock, void *data, const int size, \
@@ -156,10 +158,10 @@ int tcprecvdata_ex(int sock, void *data, const int size, \
  *          data: the buffer
  *          size: buffer size (max bytes can receive)
  *          timeout: read timeout in seconds
- *          count: store the bytes recveived
+ *          count: store the bytes received
  *  return: error no, 0 success, != 0 fail
 */
-int tcprecvdata_nb_ex(int sock, void *data, const int size, \
+int tcprecvdata_nb_ex(int sock, void *data, const int size,
 		const int timeout, int *count);
 
 /** recv data (non-block mode) in ms
@@ -167,13 +169,45 @@ int tcprecvdata_nb_ex(int sock, void *data, const int size, \
  *          sock: the socket
  *          data: the buffer
  *          size: buffer size (max bytes can receive)
- *          timeout: read timeout in milliseconds
- *          count: store the bytes recveived
+ *          timeout_ms: read timeout in milliseconds
+ *          count: store the bytes received
  *  return: error no, 0 success, != 0 fail
 */
-int tcprecvdata_nb_ms(int sock, void *data, const int size, \
+int tcprecvdata_nb_ms(int sock, void *data, const int size,
 		const int timeout_ms, int *count);
 
+/** recv data by readv (non-block mode) in ms
+ *  parameters:
+ *          sock: the socket
+ *          size: the expect size
+ *          iov: the iov to send
+ *          iovcnt: the iov count
+ *          timeout_ms: read timeout in milliseconds
+ *          total_bytes: store the bytes received
+ *  return: error no, 0 success, != 0 fail
+*/
+int tcpreadv_nb_ms(int sock, const int size, const struct iovec *iov,
+        const int iovcnt, const int timeout_ms, int *total_bytes);
+
+
+/** recv data by readv (non-block mode)
+ *  parameters:
+ *          sock: the socket
+ *          size: the expect size
+ *          iov: the iov to send
+ *          iovcnt: the iov count
+ *          timeout: read timeout in seconds
+ *          total_bytes: store the bytes received
+ *  return: error no, 0 success, != 0 fail
+*/
+static inline int tcpreadv_nb_ex(int sock, const int size,
+        const struct iovec *iov, const int iovcnt,
+        const int timeout, int *total_bytes)
+{
+    return tcpreadv_nb_ms(sock, size, iov, iovcnt,
+            timeout * 1000, total_bytes);
+}
+
 /** send data (block mode)
  *  parameters:
  *          sock: the socket
@@ -182,7 +216,7 @@ int tcprecvdata_nb_ms(int sock, void *data, const int size, \
  *          timeout: write timeout
  *  return: error no, 0 success, != 0 fail
 */
-int tcpsenddata(int sock, void* data, const int size, const int timeout);
+int tcpsenddata(int sock, void *data, const int size, const int timeout);
 
 /** send data (non-block mode)
  *  parameters:
@@ -192,7 +226,18 @@ int tcpsenddata(int sock, void* data, const int size, const int timeout);
  *          timeout: write timeout
  *  return: error no, 0 success, != 0 fail
 */
-int tcpsenddata_nb(int sock, void* data, const int size, const int timeout);
+int tcpsenddata_nb(int sock, void *data, const int size, const int timeout);
+
+/** send data by writev (non-block mode)
+ *  parameters:
+ *          sock: the socket
+ *          iov: the iov to send
+ *          iovcnt: the iov count
+ *          timeout: write timeout
+ *  return: error no, 0 success, != 0 fail
+*/
+int tcpwritev_nb(int sock, const struct iovec *iov,
+        const int iovcnt, const int timeout);
 
 /** connect to server by block mode
  *  parameters:
@@ -302,9 +347,9 @@ int tcpprintkeepalive(int fd);
  *          sock: the socket
  *          buff: buffer to store the ip address
  *          bufferSize: the buffer size (max bytes)
- *  return: in_addr_t, INADDR_NONE for fail
+ *  return: in_addr_64_t, INADDR_NONE for fail
 */
-in_addr_t getIpaddr(getnamefunc getname, int sock, \
+in_addr_64_t getIpaddr(getnamefunc getname, int sock, \
 		char *buff, const int bufferSize);
 
 /** get ip address
@@ -328,14 +373,23 @@ int getIpAndPort(getnamefunc getname, int sock,
 */
 char *getHostnameByIp(const char *szIpAddr, char *buff, const int bufferSize);
 
-/** get by IPv4 address by it's hostname
+/** get by IPv4 or IPv6 address by it's hostname
  *  parameters:
  *          name: the hostname 
  *          buff: buffer to store the ip address
  *          bufferSize: the buffer size (max bytes)
- *  return: in_addr_t, INADDR_NONE for fail
+ *          af: store the address family
+ *  return: in_addr_64_t, INADDR_NONE for fail
 */
-in_addr_t getIpaddrByName(const char *name, char *buff, const int bufferSize);
+in_addr_64_t getIpaddrByNameEx(const char *name, char *buff,
+        const int bufferSize, uint8_t *af);
+
+static inline in_addr_64_t getIpaddrByName(const char *name,
+        char *buff, const int bufferSize)
+{
+    uint8_t af;
+    return getIpaddrByNameEx(name, buff, bufferSize, &af);
+}
 
 /** get by ip addresses by it's hostname
  *  parameters:
@@ -544,6 +598,9 @@ static inline int socketClientIPv6(const char *server_ip,
 #define tcprecvdata_nb(sock, data, size, timeout) \
 	tcprecvdata_nb_ex(sock, data, size, timeout, NULL)
 
+#define tcpreadv_nb(sock, size, iov, iovcnt, timeout) \
+    tcpreadv_nb_ex(sock, size, iov, iovcnt, timeout, NULL)
+
 /** send a file
  *  parameters:
  *          sock: the socket
@@ -641,13 +698,64 @@ int getifconfigs(FastIFConfig *if_configs, const int max_count, int *count);
  *          convert: the convert struct for IPv4 and IPv6 compatibility
  *  return: error no, 0 success, != 0 fail
 */
-int setsockaddrbyip(const char *ip, const uint16_t port, sockaddr_convert_t *convert);
+int setsockaddrbyip(const char *ip, const uint16_t port,
+        sockaddr_convert_t *convert);
 
 static inline bool is_ipv6_addr(const char *ip)
 {
     return (*ip == ':' || strchr(ip, ':') != NULL); //ipv6
 }
 
+static inline const char *format_ip_address(const char *ip, char *buff)
+{
+    if (is_ipv6_addr(ip))
+    {
+        int ip_len;
+        char *p;
+
+        ip_len = strlen(ip);
+        p = buff;
+        *p++ = '[';
+        memcpy(p, ip, ip_len);
+        p += ip_len;
+        *p++ = ']';
+        *p = '\0';
+    }
+    else
+    {
+        strcpy(buff, ip);
+    }
+
+    return buff;
+}
+
+static inline const char *format_ip_port(const char *ip,
+        const int port, char *buff)
+{
+    int ip_len;
+    bool is_ipv6;
+    char *p;
+
+    is_ipv6 = is_ipv6_addr(ip);
+    ip_len = strlen(ip);
+    p = buff;
+    if (is_ipv6)
+    {
+        *p++ = '[';
+    }
+    memcpy(p, ip, ip_len);
+    p += ip_len;
+    if (is_ipv6)
+    {
+        *p++ = ']';
+    }
+    *p++ = ':';
+    p += fc_itoa(port, p);
+    *p = '\0';
+
+    return buff;
+}
+
 void tcp_set_try_again_when_interrupt(const bool value);
 
 static inline void tcp_dont_try_again_when_interrupt()
@@ -657,10 +765,15 @@ static inline void tcp_dont_try_again_when_interrupt()
 
 void tcp_set_quick_ack(const bool value);
 
+bool tcp_socket_connected(int sock);
+
 int fc_get_net_type_by_name(const char *net_type);
 
 int fc_get_net_type_by_ip(const char *ip);
 
+const char *fc_inet_ntop(const struct sockaddr *addr,
+        char *buff, const int bufferSize);
+
 static inline bool is_network_error(const int err_no)
 {
     switch (err_no)

src/sorted_array.c

@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 2020 YuQing <384681@qq.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include "sorted_array.h"
+
+void sorted_array_init(SortedArrayContext *ctx,
+        const int element_size, const bool allow_duplication,
+        int (*compare_func)(const void *, const void *))
+{
+    ctx->element_size = element_size;
+    ctx->allow_duplication = allow_duplication;
+    ctx->compare_func = compare_func;
+}
+
+static char *sorted_array_bsearch(SortedArrayContext *ctx, char *base,
+        const int count, const void *elt, int *insert_pos)
+{
+    int low;
+    int high;
+    int mid;
+    int compr;
+    char *current;
+
+    *insert_pos = 0;
+    low = 0;
+    high = count - 1;
+    while (low <= high) {
+        mid = (low + high) / 2;
+        current = base + ctx->element_size * mid;
+        compr = ctx->compare_func(current, elt);
+        if (compr < 0) {
+            low = mid + 1;
+            *insert_pos = low;
+        } else if (compr == 0) {
+            *insert_pos = mid;
+            return current;
+        } else {
+            high = mid - 1;
+            *insert_pos = mid;
+        }
+    }
+
+    return NULL;
+}
+
+int sorted_array_insert(SortedArrayContext *ctx,
+        void *base, int *count, const void *elt)
+{
+    char *current;
+
+    if (*count == 0 || ctx->compare_func((char *)base +
+                ctx->element_size * (*count - 1), elt) < 0)
+    {  //fast path
+        current = (char *)base + ctx->element_size * (*count);
+    } else {
+        int insert_pos;
+        int move_count;
+        char *found;
+        char *end;
+
+        found = sorted_array_bsearch(ctx, base, *count, elt, &insert_pos);
+        if (found != NULL) {
+            if (!ctx->allow_duplication) {
+                return EEXIST;
+            }
+
+            found += ctx->element_size;
+            end = (char *)base + ctx->element_size * (*count);
+            while (found < end && ctx->compare_func(found, elt) == 0) {
+                insert_pos++;
+                found += ctx->element_size;
+            }
+        }
+
+        current = (char *)base + ctx->element_size * insert_pos;
+        move_count = *count - insert_pos;
+        if (move_count > 0) {
+            memmove((char *)base + ctx->element_size * (insert_pos + 1),
+                    current, ctx->element_size * move_count);
+        }
+    }
+
+    switch (ctx->element_size) {
+        case 1:
+            *current = *((char *)elt);
+            break;
+        case 2:
+            *((short *)current) = *((short *)elt);
+            break;
+        case 4:
+            *((int32_t *)current) = *((int32_t *)elt);
+            break;
+        case 8:
+            *((int64_t *)current) = *((int64_t *)elt);
+            break;
+        default:
+            memcpy(current, elt, ctx->element_size);
+            break;
+    }
+
+    (*count)++;
+    return 0;
+}
+
+void sorted_array_delete_by_index(SortedArrayContext *ctx,
+        void *base, int *count, const int index)
+{
+    int move_count;
+    char *start;
+
+    start = (char *)base + ctx->element_size * index;
+    move_count = *count - (index + 1);
+    if (move_count > 0) {
+        memmove(start, start + ctx->element_size,
+                ctx->element_size * move_count);
+    }
+    (*count)--;
+}
+
+int sorted_array_delete(SortedArrayContext *ctx,
+        void *base, int *count, const void *elt)
+{
+    int move_count;
+    struct {
+        char *current;
+        char *start;
+        char *end;
+    } found;
+    char *array_end;
+
+    if ((found.current=bsearch(elt, base, *count, ctx->element_size,
+                    ctx->compare_func)) == NULL)
+    {
+        return ENOENT;
+    }
+
+    array_end = (char *)base + ctx->element_size * (*count);
+    if (ctx->allow_duplication) {
+        found.start = found.current;
+        while (found.start > (char *)base && ctx->compare_func(
+                    found.start - ctx->element_size, elt) == 0)
+        {
+            found.start -= ctx->element_size;
+        }
+
+        found.end = found.current + ctx->element_size;
+        while (found.end < array_end && ctx->compare_func(
+                    found.end, elt) == 0)
+        {
+            found.end += ctx->element_size;
+        }
+        *count -= (found.end - found.start) / ctx->element_size;
+    } else {
+        found.start = found.current;
+        found.end = found.start + ctx->element_size;
+        (*count)--;
+    }
+
+    move_count = (array_end - found.end) / ctx->element_size;
+    if (move_count > 0) {
+        memmove(found.start, found.end, ctx->
+                element_size * move_count);
+    }
+    return 0;
+}

src/sorted_array.h

@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) 2020 YuQing <384681@qq.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the GNU Affero General Public License, version 3
+ * or later ("AGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef SORTED_ARRAY_H
+#define SORTED_ARRAY_H
+
+#include "array_allocator.h"
+
+typedef struct sorted_array_context
+{
+    int element_size;
+    bool allow_duplication;
+    int (*compare_func)(const void *, const void *);
+} SortedArrayContext;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+    /** init the context for sorted array
+     *  parameters:
+     *      ctx: the context to init
+     *      element_size: the size of one array element
+     *      allow_duplication: if allow duplication
+     *      compare_func: the compare function (comparator)
+     *  return: none
+     */
+    void sorted_array_init(SortedArrayContext *ctx,
+            const int element_size, const bool allow_duplication,
+            int (*compare_func)(const void *, const void *));
+
+
+    /** insert an element into the sorted array
+     *  parameters:
+     *      ctx: the context for sorted array
+     *      base: the pointer of the sorted array (the first array element)
+     *      count: the count of the sorted array (for input and output)
+     *      elt: the element to insert
+     *  return: 0 for success, != 0 for error
+     */
+    int sorted_array_insert(SortedArrayContext *ctx,
+            void *base, int *count, const void *elt);
+
+
+    /** delete an element from the sorted array
+     *  parameters:
+     *      ctx: the context for sorted array
+     *      base: the pointer of the sorted array (the first array element)
+     *      count: the count of the sorted array (for input and output)
+     *      elt: the element to delete
+     *  return: 0 for success, != 0 for error
+     */
+    int sorted_array_delete(SortedArrayContext *ctx,
+            void *base, int *count, const void *elt);
+
+    /** delete an element by index
+     *  parameters:
+     *      ctx: the context for sorted array
+     *      base: the pointer of the sorted array (the first array element)
+     *      count: the count of the sorted array (for input and output)
+     *      index: the element index to delete
+     *  return: 0 for success, != 0 for error
+     */
+    void sorted_array_delete_by_index(SortedArrayContext *ctx,
+            void *base, int *count, const int index);
+
+    /** find element from the sorted array
+     *  parameters:
+     *      ctx: the context for sorted array
+     *      base: the pointer of the sorted array (the first array element)
+     *      count: the count of the sorted array
+     *      key: the element to find
+     *  return: 0 for success, != 0 for error
+     */
+    static inline void *sorted_array_find(SortedArrayContext *ctx,
+            void *base, const int count, const void *key)
+    {
+        return bsearch(key, base, count, ctx->
+                element_size, ctx->compare_func);
+    }
+
+#define sorted_i64_array_init(ctx, allow_duplication) \
+    sorted_array_init(ctx, sizeof(int64_t), allow_duplication, \
+            (int (*)(const void *, const void *))array_compare_element_int64)
+
+#define sorted_i32_array_init(ctx, allow_duplication) \
+    sorted_array_init(ctx, sizeof(int32_t), allow_duplication, \
+            (int (*)(const void *, const void *))array_compare_element_int32)
+
+#define sorted_id_name_array_init(ctx, allow_duplication) \
+    sorted_array_init(ctx, sizeof(id_name_pair_t), allow_duplication, \
+            (int (*)(const void *, const void *)) \
+            array_compare_element_id_name)
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/sorted_queue.c

@@ -0,0 +1,194 @@
+/*
+ * Copyright (c) 2020 YuQing <384681@qq.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the Lesser GNU General Public License, version 3
+ * or later ("LGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//sorted_queue.c
+
+#include "pthread_func.h"
+#include "sorted_queue.h"
+
+int sorted_queue_init(struct sorted_queue *sq, const int dlink_offset,
+        int (*push_compare_func)(const void *data1, const void *data2),
+        int (*pop_compare_func)(const void *data, const
+            void *less_equal, void *arg), void *arg)
+{
+    int result;
+
+    if ((result=init_pthread_lock_cond_pair(&sq->lcp)) != 0) {
+        return result;
+    }
+
+    FC_INIT_LIST_HEAD(&sq->head);
+    sq->dlink_offset = dlink_offset;
+    sq->arg = arg;
+    sq->push_compare_func = push_compare_func;
+    sq->pop_compare_func = pop_compare_func;
+    return 0;
+}
+
+void sorted_queue_destroy(struct sorted_queue *sq)
+{
+    destroy_pthread_lock_cond_pair(&sq->lcp);
+}
+
+void sorted_queue_push_ex(struct sorted_queue *sq, void *data, bool *notify)
+{
+    struct fc_list_head *dlink;
+    struct fc_list_head *current;
+
+    dlink = FC_SORTED_QUEUE_DLINK_PTR(sq, data);
+    PTHREAD_MUTEX_LOCK(&sq->lcp.lock);
+    if (fc_list_empty(&sq->head)) {
+        fc_list_add(dlink, &sq->head);
+        *notify = true;
+    } else {
+        if (sq->push_compare_func(data, FC_SORTED_QUEUE_DATA_PTR(
+                        sq, sq->head.prev)) >= 0)
+        {
+            fc_list_add_tail(dlink, &sq->head);
+            *notify = false;
+        } else if (sq->push_compare_func(data, FC_SORTED_QUEUE_DATA_PTR(
+                        sq, sq->head.next)) < 0)
+        {
+            fc_list_add(dlink, &sq->head);
+            *notify = true;
+        } else {
+            current = sq->head.prev->prev;
+            while (sq->push_compare_func(data, FC_SORTED_QUEUE_DATA_PTR(
+                        sq, current)) < 0)
+            {
+                current = current->prev;
+            }
+            fc_list_add_after(dlink, current);
+            *notify = false;
+        }
+    }
+
+    PTHREAD_MUTEX_UNLOCK(&sq->lcp.lock);
+}
+
+void *sorted_queue_pop_ex(struct sorted_queue *sq,
+        void *less_equal, const bool blocked)
+{
+    void *data;
+    struct fc_list_head *current;
+
+    PTHREAD_MUTEX_LOCK(&sq->lcp.lock);
+    do {
+        if (fc_list_empty(&sq->head)) {
+            if (!blocked) {
+                data = NULL;
+                break;
+            }
+
+            pthread_cond_wait(&sq->lcp.cond,
+                    &sq->lcp.lock);
+            if (fc_list_empty(&sq->head)) {
+                data = NULL;
+                break;
+            }
+        }
+
+        current = sq->head.next;
+        data = FC_SORTED_QUEUE_DATA_PTR(sq, current);
+        if (sq->pop_compare_func(data, less_equal, sq->arg) <= 0) {
+            fc_list_del_init(current);
+        } else {
+            data = NULL;
+        }
+    } while (0);
+    PTHREAD_MUTEX_UNLOCK(&sq->lcp.lock);
+
+    return data;
+}
+
+void sorted_queue_pop_to_chain_ex(struct sorted_queue *sq,
+        void *less_equal, struct fc_list_head *head,
+        const bool blocked)
+{
+    struct fc_list_head *current;
+
+    PTHREAD_MUTEX_LOCK(&sq->lcp.lock);
+    do {
+        if (fc_list_empty(&sq->head)) {
+            if (!blocked) {
+                FC_INIT_LIST_HEAD(head);
+                break;
+            }
+
+            pthread_cond_wait(&sq->lcp.cond,
+                    &sq->lcp.lock);
+        }
+
+        if (fc_list_empty(&sq->head)) {
+            FC_INIT_LIST_HEAD(head);
+        } else {
+            current = sq->head.next;
+            if (sq->pop_compare_func(FC_SORTED_QUEUE_DATA_PTR(
+                        sq, current), less_equal, sq->arg) <= 0)
+            {
+                head->next = current;
+                current->prev = head;
+                current = current->next;
+                while (current != &sq->head && sq->pop_compare_func(
+                            FC_SORTED_QUEUE_DATA_PTR(sq, current),
+                            less_equal, sq->arg) <= 0)
+                {
+                    current = current->next;
+                }
+
+                head->prev = current->prev;
+                current->prev->next = head;
+                if (current == &sq->head) {
+                    FC_INIT_LIST_HEAD(&sq->head);
+                } else {
+                    sq->head.next = current;
+                    current->prev = &sq->head;
+                }
+            } else {
+                FC_INIT_LIST_HEAD(head);
+            }
+        }
+    } while (0);
+
+    PTHREAD_MUTEX_UNLOCK(&sq->lcp.lock);
+}
+
+int sorted_queue_free_chain(struct sorted_queue *sq,
+        struct fast_mblock_man *mblock, struct fc_list_head *head)
+{
+    struct fast_mblock_node *previous;
+    struct fast_mblock_node *current;
+    struct fast_mblock_chain chain;
+    struct fc_list_head *node;
+
+    if (fc_list_empty(&sq->head)) {
+        return 0;
+    }
+
+    node = head->next;
+    chain.head = previous = fast_mblock_to_node_ptr(
+            FC_SORTED_QUEUE_DATA_PTR(sq, node));
+    node = node->next;
+    while (node != head) {
+        current = fast_mblock_to_node_ptr(FC_SORTED_QUEUE_DATA_PTR(sq, node));
+        previous->next = current;
+        previous = current;
+        node = node->next;
+    }
+
+    previous->next = NULL;
+    chain.tail = previous;
+    return fast_mblock_batch_free(mblock, &chain);
+}

src/sorted_queue.h

@@ -0,0 +1,128 @@
+/*
+ * Copyright (c) 2020 YuQing <384681@qq.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the Lesser GNU General Public License, version 3
+ * or later ("LGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+//sorted_queue.h
+
+#ifndef _FC_SORTED_QUEUE_H
+#define _FC_SORTED_QUEUE_H
+
+#include "fast_mblock.h"
+#include "fc_list.h"
+#include "pthread_func.h"
+
+struct sorted_queue
+{
+    struct fc_list_head head;
+    pthread_lock_cond_pair_t lcp;
+    int dlink_offset;
+    void *arg;
+    int (*push_compare_func)(const void *data1, const void *data2);
+    int (*pop_compare_func)(const void *data,
+            const void *less_equal, void *arg);
+};
+
+#define FC_SORTED_QUEUE_DLINK_PTR(sq, data) \
+    ((void *)(((char *)data) + (sq)->dlink_offset))
+
+#define FC_SORTED_QUEUE_DATA_PTR(sq, dlink) \
+    ((void *)((char *)(dlink) - (sq)->dlink_offset))
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int sorted_queue_init(struct sorted_queue *sq, const int dlink_offset,
+        int (*push_compare_func)(const void *data1, const void *data2),
+        int (*pop_compare_func)(const void *data, const
+            void *less_equal, void *arg), void *arg);
+
+void sorted_queue_destroy(struct sorted_queue *sq);
+
+static inline void sorted_queue_terminate(struct sorted_queue *sq)
+{
+    pthread_cond_signal(&sq->lcp.cond);
+}
+
+static inline void sorted_queue_terminate_all(
+        struct sorted_queue *sq, const int count)
+{
+    int i;
+    for (i=0; i<count; i++) {
+        pthread_cond_signal(&(sq->lcp.cond));
+    }
+}
+
+//notify by the caller
+void sorted_queue_push_ex(struct sorted_queue *sq, void *data, bool *notify);
+
+static inline void sorted_queue_push(struct sorted_queue *sq, void *data)
+{
+    bool notify;
+
+    sorted_queue_push_ex(sq, data, &notify);
+    if (notify) {
+        pthread_cond_signal(&(sq->lcp.cond));
+    }
+}
+
+static inline void sorted_queue_push_silence(
+        struct sorted_queue *sq, void *data)
+{
+    bool notify;
+    sorted_queue_push_ex(sq, data, &notify);
+}
+
+void *sorted_queue_pop_ex(struct sorted_queue *sq,
+        void *less_equal, const bool blocked);
+
+#define sorted_queue_pop(sq, less_equal) \
+    sorted_queue_pop_ex(sq, less_equal, true)
+
+#define sorted_queue_try_pop(sq, less_equal) \
+    sorted_queue_pop_ex(sq, less_equal, false)
+
+void sorted_queue_pop_to_chain_ex(struct sorted_queue *sq,
+        void *less_equal, struct fc_list_head *head,
+        const bool blocked);
+
+#define sorted_queue_pop_to_chain(sq, less_equal, head) \
+    sorted_queue_pop_to_chain_ex(sq, less_equal, head, true)
+
+#define sorted_queue_try_pop_to_chain(sq, less_equal, head) \
+    sorted_queue_pop_to_chain_ex(sq, less_equal, head, false)
+
+static inline bool sorted_queue_empty(struct sorted_queue *sq)
+{
+    return fc_list_empty(&sq->head);
+}
+
+int sorted_queue_free_chain(struct sorted_queue *sq,
+        struct fast_mblock_man *mblock, struct fc_list_head *head);
+
+static inline void sorted_queue_lock(struct sorted_queue *sq)
+{
+    PTHREAD_MUTEX_LOCK(&sq->lcp.lock);
+}
+
+static inline void sorted_queue_unlock(struct sorted_queue *sq)
+{
+    PTHREAD_MUTEX_UNLOCK(&sq->lcp.lock);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/spinlock.c

@@ -0,0 +1,116 @@
+/*
+ * Copyright (c) 2025 YuQing <384681@qq.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the Lesser GNU General Public License, version 3
+ * or later ("LGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include "common_define.h"
+#ifdef OS_LINUX
+#include <sys/syscall.h>
+#include <linux/futex.h>
+#define FUTEX(ptr, op, val) syscall(SYS_futex, ptr, op, val, NULL, NULL, 0)
+#else
+#include "pthread_func.h"
+#endif
+
+#include "logger.h"
+#include "spinlock.h"
+
+#ifdef OS_LINUX
+static inline int fc_futex(int *ptr, int op, int val)
+{
+    if (FUTEX(ptr, op, val) == 0) {
+        return 0;
+    } else {
+        return errno != 0 ? errno : EBUSY;
+    }
+}
+#endif
+
+int fc_spinlock_init(FCSpinlock *lock, int *cond)
+{
+#ifdef OS_LINUX
+    lock->cond = cond;
+    return pthread_spin_init(&lock->mutex, 0);
+#else
+    return init_pthread_lock_cond_pair(&lock->lcp);
+#endif
+}
+
+void fc_spinlock_destroy(FCSpinlock *lock)
+{
+#ifdef OS_LINUX
+#else
+    destroy_pthread_lock_cond_pair(&lock->lcp);
+#endif
+}
+
+int fc_spinlock_lock(FCSpinlock *lock)
+{
+#ifdef OS_LINUX
+    return pthread_spin_lock(&lock->mutex);
+#else
+    return pthread_mutex_lock(&lock->lcp.lock);
+#endif
+}
+
+int fc_spinlock_trylock(FCSpinlock *lock)
+{
+#ifdef OS_LINUX
+    return pthread_spin_trylock(&lock->mutex);
+#else
+    return pthread_mutex_trylock(&lock->lcp.lock);
+#endif
+}
+
+int fc_spinlock_unlock(FCSpinlock *lock)
+{
+#ifdef OS_LINUX
+    return pthread_spin_unlock(&lock->mutex);
+#else
+    return pthread_mutex_unlock(&lock->lcp.lock);
+#endif
+}
+
+int fc_spinlock_wait(FCSpinlock *lock, const int expected)
+{
+#ifdef OS_LINUX
+    int result;
+    int lock_ret;
+
+    if ((result=pthread_spin_unlock(&lock->mutex)) != 0) {
+        return result;
+    }
+    result = fc_futex(lock->cond, FUTEX_WAIT_PRIVATE, expected);
+    lock_ret = pthread_spin_lock(&lock->mutex);
+    return result == 0 ? lock_ret : result;
+#else
+    return pthread_cond_wait(&lock->lcp.cond, &lock->lcp.lock);
+#endif
+}
+
+int fc_spinlock_wake_ex(FCSpinlock *lock, const int count)
+{
+#ifdef OS_LINUX
+    if (FUTEX(lock->cond, FUTEX_WAKE_PRIVATE, count) >= 0) {
+        return 0;
+    } else {
+        return errno != 0 ? errno : EBUSY;
+    }
+#else
+    if (count == 1) {
+        return pthread_cond_signal(&lock->lcp.cond);
+    } else {
+        return pthread_cond_broadcast(&lock->lcp.cond);
+    }
+#endif
+}

src/spinlock.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2025 YuQing <384681@qq.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the Lesser GNU General Public License, version 3
+ * or later ("LGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#ifndef FC_SPINLOCK_H
+#define FC_SPINLOCK_H
+
+#include <pthread.h>
+#include "common_define.h"
+
+typedef struct fc_spinlock_t {
+#ifdef OS_LINUX
+    pthread_spinlock_t mutex;
+    int *cond;
+#else
+    pthread_lock_cond_pair_t lcp;
+#endif
+} FCSpinlock;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int fc_spinlock_init(FCSpinlock *lock, int *cond);
+
+void fc_spinlock_destroy(FCSpinlock *lock);
+
+int fc_spinlock_lock(FCSpinlock *lock);
+
+int fc_spinlock_trylock(FCSpinlock *lock);
+
+int fc_spinlock_unlock(FCSpinlock *lock);
+
+int fc_spinlock_wait(FCSpinlock *lock, const int expected);
+
+int fc_spinlock_wake_ex(FCSpinlock *lock, const int count);
+
+static inline int fc_spinlock_wake(FCSpinlock *lock)
+{
+    const int count = 1;
+    return fc_spinlock_wake_ex(lock, count);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

src/system_info.c

@@ -23,6 +23,7 @@
 #include <inttypes.h>
 #include <sys/types.h>
 #include <sys/stat.h>
+#include <sys/utsname.h>
 #include <netinet/in.h>
 #include <fcntl.h>
 #include <errno.h>
@@ -35,6 +36,7 @@
 #ifdef OS_LINUX
 #include <sys/sysinfo.h>
 #include <sys/vfs.h>
+#include <sys/sysmacros.h>
 #else
 #ifdef OS_FREEBSD
 #include <sys/sysctl.h>
@@ -70,7 +72,11 @@ int get_sys_total_mem_size(int64_t *mem_size)
    size_t len;
 
    mib[0] = CTL_HW;
+#ifdef DARWIN
    mib[1] = HW_MEMSIZE;
+#else
+   mib[1] = HW_PHYSMEM;
+#endif
    len = sizeof(*mem_size);
    if (sysctl(mib, 2, mem_size, &len, NULL, 0) != 0)
    {
@@ -188,11 +194,54 @@ int get_boot_time(struct timeval *boot_time)
 
 #define SET_MNT_FIELDS(left, fstypename, mntfromname, mntonname) \
     do { \
-        snprintf(left.f_fstypename, sizeof(left.f_fstypename), "%s", fstypename); \
-        snprintf(left.f_mntfromname, sizeof(left.f_mntfromname), "%s", mntfromname); \
-        snprintf(left.f_mntonname, sizeof(left.f_mntonname), "%s", mntonname); \
+        fc_safe_strcpy(left.f_fstypename, fstypename);   \
+        fc_safe_strcpy(left.f_mntfromname, mntfromname); \
+        fc_safe_strcpy(left.f_mntonname, mntonname); \
     } while (0)
 
+#ifdef OS_LINUX
+static int get_device_type(const char *type_name, FastDeviceType *device_type)
+{
+    int i;
+    const char *disk_ftypes[] = {"ext2", "ext3", "ext4", "xfs",
+        "btrfs", "f2fs", "jfs", "reiserfs", "nilfs", "zfs",
+        "ufs", "ntfs", "vfat", "udf", "romfs", "squashfs"};
+    const int disk_ftype_count = sizeof(disk_ftypes) / sizeof(char *);
+
+    for (i=0; i<disk_ftype_count; i++)
+    {
+        if (strcmp(type_name, disk_ftypes[i]) == 0)
+        {
+            *device_type = fast_device_type_disk;
+            return 0;
+        }
+    }
+
+    if (strcmp(type_name, "tmpfs") == 0 || strcmp(type_name, "devtmpfs") == 0
+            || strcmp(type_name, "ramfs") == 0)
+    {
+        *device_type = fast_device_type_memory;
+        return 0;
+    }
+
+    if (strcmp(type_name, "nfs") == 0 || strcmp(type_name, "smb") == 0 ||
+            strcmp(type_name, "cifs") == 0 || strcmp(type_name, "afp") == 0)
+    {
+        *device_type = fast_device_type_network;
+        return 0;
+    }
+
+    if (strcmp(type_name, "fuse") == 0)
+    {
+        *device_type = fast_device_type_fuse;
+        return 0;
+    }
+
+    *device_type = fast_device_type_unkown;
+    return ENOENT;
+}
+#endif
+
 int get_mounted_filesystems(struct fast_statfs *stats,
         const int size, int *count)
 {
@@ -234,15 +283,14 @@ int get_mounted_filesystems(struct fast_statfs *stats,
         mntfromname = strsep(&p, " \t");
         mntonname = strsep(&p, " \t");
         fstypename = strsep(&p, " \t");
-
-        snprintf(stats[*count].f_mntfromname,
-                sizeof(stats[*count].f_mntfromname), "%s", mntfromname);
-        snprintf(stats[*count].f_mntonname,
-                sizeof(stats[*count].f_mntonname), "%s", mntonname);
-        snprintf(stats[*count].f_fstypename,
-                sizeof(stats[*count].f_fstypename), "%s", fstypename);
-
-        (*count)++;
+        toLowercase(fstypename);
+        if (get_device_type(fstypename, &stats[*count].device_type) == 0)
+        {
+            fc_safe_strcpy(stats[*count].f_mntfromname, mntfromname);
+            fc_safe_strcpy(stats[*count].f_mntonname, mntonname);
+            fc_safe_strcpy(stats[*count].f_fstypename, fstypename);
+            (*count)++;
+        }
     }
     fclose(fp);
 
@@ -273,7 +321,7 @@ int get_mounted_filesystems(struct fast_statfs *stats,
     int i;
 
     mnts = NULL;
-    *count = getmntinfo(&mnts, 0);
+    *count = getmntinfo(&mnts, MNT_NOWAIT);
     if (*count == 0)
     {
         result = errno != 0 ? errno : EPERM;
@@ -300,6 +348,7 @@ int get_mounted_filesystems(struct fast_statfs *stats,
 #ifdef HAVE_FILE_SYSTEM_ID
         stats[i].f_fsid = mnts[i].f_fsid;
 #endif
+        stats[i].device_type = fast_device_type_unkown;
         SET_MNT_FIELDS(stats[i], mnts[i].f_fstypename,
                 mnts[i].f_mntfromname, mnts[i].f_mntonname);
     }
@@ -312,6 +361,114 @@ int get_mounted_filesystems(struct fast_statfs *stats,
 #endif
 }
 
+int get_statfs_by_path(const char *path, FastStatFS *statfs)
+{
+#define MAX_STATFS_COUNT  256
+    int result;
+    int count;
+    int path_len;
+    int mnt_len;
+    int matched_len;
+    char resolved_path[PATH_MAX];
+    struct fast_statfs stats[MAX_STATFS_COUNT];
+    struct fast_statfs *entry;
+    struct fast_statfs *end;
+
+    if ((result=get_mounted_filesystems(stats, MAX_STATFS_COUNT,
+                    &count)) != 0)
+    {
+        return result;
+    }
+
+    if (realpath(path, resolved_path) == NULL)
+    {
+        return errno != 0 ? errno : ENOENT;
+    }
+    path_len = strlen(resolved_path);
+    matched_len = 0;
+    end = stats + count;
+    for (entry=stats; entry<end; entry++)
+    {
+        mnt_len = strlen(entry->f_mntonname);
+        if (mnt_len <= path_len && memcmp(resolved_path, entry->
+                    f_mntonname, mnt_len) == 0)
+        {
+            if ((mnt_len > 1 && mnt_len < path_len) &&
+                    *(resolved_path + mnt_len) != '/')
+            {
+                continue;
+            }
+
+            if (mnt_len > matched_len)
+            {
+                matched_len = mnt_len;
+                *statfs = *entry;
+            }
+        }
+    }
+
+    return (matched_len > 0 ? 0 : ENOENT);
+}
+
+bool is_rotational_device_by_path(const char *path)
+{
+#if defined(OS_LINUX)
+#define DEV_PATH_PREFIX_STR  "/dev/"
+#define DEV_PATH_PREFIX_LEN  (sizeof(DEV_PATH_PREFIX_STR) - 1)
+
+    int result;
+    int fd;
+    int len;
+    FastStatFS statfs;
+    char resolved_path[PATH_MAX];
+    char filename[PATH_MAX];
+    char buff[8];
+    char *device_name;
+
+    if ((result=get_statfs_by_path(path, &statfs)) != 0) {
+        return true;
+    }
+
+    if (statfs.device_type == fast_device_type_memory) {
+        return false;
+    }
+
+    if (!(statfs.device_type == fast_device_type_disk &&
+                strncmp(statfs.f_mntfromname, DEV_PATH_PREFIX_STR,
+                    DEV_PATH_PREFIX_LEN) == 0))
+    {
+        return true;
+    }
+
+    if (realpath(statfs.f_mntfromname, resolved_path) == NULL) {
+        return true;
+    }
+    if (strncmp(resolved_path, DEV_PATH_PREFIX_STR,
+                DEV_PATH_PREFIX_LEN) != 0)
+    {
+        return true;
+    }
+    device_name = resolved_path + DEV_PATH_PREFIX_LEN;
+    sprintf(filename, "/sys/class/block/%s/queue/rotational", device_name);
+    if ((fd=open(filename, O_RDONLY)) < 0) {
+        sprintf(filename, "/sys/class/block/%s/../queue/rotational", device_name);
+        if ((fd=open(filename, O_RDONLY)) < 0) {
+            return true;
+        }
+    }
+
+    len = read(fd, buff, sizeof(buff));
+    close(fd);
+    if (len == 1 || len == 2) {
+        return (buff[0] != '0');
+    } else {
+        return true;
+    }
+#else
+    return true;
+#endif
+}
+
 #if defined(OS_LINUX) || defined(OS_FREEBSD)
 
 typedef struct fast_process_array {
@@ -546,7 +703,7 @@ int get_processes(struct fast_process_info **processes, int *count)
     return result;
 }
 
-int get_sysinfo(struct fast_sysinfo*info)
+int get_sysinfo(struct fast_sysinfo *info)
 {
     struct sysinfo si;
 
@@ -611,7 +768,7 @@ int get_processes(struct fast_process_info **processes, int *count)
     mib[0] = CTL_KERN;
     mib[1] = KERN_PROC;
     mib[2] = KERN_PROC_ALL;
-    mib[3] =  0;
+    mib[3] = 0;
     size = 0;
     if (sysctl(mib, 4, NULL, &size, NULL, 0) < 0)
     {
@@ -681,8 +838,7 @@ int get_processes(struct fast_process_info **processes, int *count)
     for (i=0; i<nproc; i++)
     {
         process->field_count = 9;
-        snprintf(process->comm, sizeof(process->comm),
-                "%s", procs[i].ki_comm);
+        fc_safe_strcpy(process->comm, procs[i].ki_comm);
         process->pid = procs[i].ki_pid;
         process->ppid = procs[i].ki_ppid;
         process->starttime = procs[i].ki_start;
@@ -704,7 +860,7 @@ int get_processes(struct fast_process_info **processes, int *count)
     return 0;
 }
 
-int get_sysinfo(struct fast_sysinfo*info)
+int get_sysinfo(struct fast_sysinfo *info)
 {
         int mib[4];
         size_t size;
@@ -774,7 +930,6 @@ int get_sysinfo(struct fast_sysinfo*info)
 		page_size = sysconf(_SC_PAGESIZE);
 		info->freeram = vm.t_free * page_size;
 		info->sharedram = vm.t_rmshr * page_size;
-		//info->bufferram = vm.   //TODO:
 	}
 #endif
 
@@ -785,7 +940,7 @@ int get_sysinfo(struct fast_sysinfo*info)
 	if (sysctl(mib, 2, &sw_usage, &size, NULL, 0) != 0)
 	{
 		logError("file: "__FILE__", line: %d, " \
-			"call sysctl  fail, " \
+			"call sysctl fail, " \
 			"errno: %d, error info: %s", \
 			__LINE__, errno, STRERROR(errno));
 	}
@@ -802,3 +957,247 @@ int get_sysinfo(struct fast_sysinfo*info)
 #endif
 #endif
 
+int get_kernel_version(Version *version)
+{
+    struct utsname name;
+    char *p;
+    int numbers[2];
+    int i;
+
+    if (uname(&name) < 0)
+    {
+		logError("file: "__FILE__", line: %d, "
+			"call uname fail, errno: %d, error info: %s",
+			__LINE__, errno, STRERROR(errno));
+        return errno != 0 ? errno : EFAULT;
+    }
+
+    numbers[0] = numbers[1] = 0;
+    p = name.release;
+    for (i=0; i<2; i++) {
+        p = strchr(p, '.');
+        if (p == NULL) {
+            break;
+        }
+
+        p++;
+        numbers[i] = strtol(p, NULL, 10);
+    }
+
+    version->major = strtol(name.release, NULL, 10);
+    version->minor = numbers[0];
+    version->patch = numbers[1];
+    return 0;
+}
+
+#ifdef OS_LINUX
+int get_device_block_size(const char *device, int *block_size)
+{
+    int result;
+    int fd;
+    size_t bs;
+
+    if ((fd=open(device, O_RDONLY | O_CLOEXEC)) < 0) {
+        result = errno != 0 ? errno : ENOENT;
+        logError("file: "__FILE__", line: %d, "
+                "open device %s fail, errno: %d, error info: %s",
+                __LINE__, device, result, strerror(result));
+        return result;
+    }
+
+    if (ioctl(fd, BLKSSZGET, &bs) == 0) {
+        *block_size = bs;
+        result = 0;
+    } else {
+        result = errno != 0 ? errno : EPERM;
+        logError("file: "__FILE__", line: %d, "
+                "ioctl device %s fail, errno: %d, error info: %s",
+                __LINE__, device, result, strerror(result));
+    }
+
+    close(fd);
+    return result;
+}
+
+static int get_block_size_by_write(const char *path, int *block_size)
+{
+#define MAX_BLK_SIZE  (128 * 1024)
+    char tmp_filename[PATH_MAX];
+    char *buff;
+    int result;
+    int fd;
+
+    if ((result=posix_memalign((void **)&buff,
+                    MAX_BLK_SIZE, MAX_BLK_SIZE)) != 0)
+    {
+        logError("file: "__FILE__", line: %d, "
+                "posix_memalign %d bytes fail, "
+                "errno: %d, error info: %s", __LINE__,
+                MAX_BLK_SIZE, result, STRERROR(result));
+        return result;
+    }
+
+    fc_combine_full_filename(path, ".blksize-test.tmp", tmp_filename);
+    if ((fd=open(tmp_filename, O_WRONLY | O_CREAT |
+                    O_DIRECT | O_CLOEXEC, 0755)) < 0)
+    {
+        result = errno != 0 ? errno : ENOENT;
+        logError("file: "__FILE__", line: %d, "
+                "open file %s fail, errno: %d, error info: %s",
+                __LINE__, tmp_filename, result, strerror(result));
+        free(buff);
+        return result;
+    }
+
+    result = EINVAL;
+    *block_size = 512;
+    while (*block_size <= MAX_BLK_SIZE) {
+        if (write(fd, buff, *block_size) == *block_size) {
+            result = 0;
+            break;
+        }
+        result = errno != 0 ? errno : EINTR;
+        if (result == EINTR) {
+            continue;
+        }
+
+        if (result != EINVAL) {
+            logError("file: "__FILE__", line: %d, "
+                    "write to file %s fail, errno: %d, error info: %s",
+                    __LINE__, tmp_filename, result, strerror(result));
+            break;
+        }
+
+        *block_size *= 2;
+    }
+
+    free(buff);
+    close(fd);
+    unlink(tmp_filename);
+    return result;
+}
+
+int get_path_block_size(const char *path, int *block_size)
+{
+    char dev_path[64];
+    struct stat statbuf;
+    int result;
+
+    if (stat(path, &statbuf) != 0) {
+        result = errno != 0 ? errno : EPERM;
+        logError("file: "__FILE__", line: %d, "
+                "stat %s fail, errno: %d, error info: %s",
+                __LINE__, path, result, strerror(result));
+        return result;
+    }
+
+    if (S_ISBLK(statbuf.st_mode)) {
+        return get_device_block_size(path, block_size);
+    }
+    if (!S_ISDIR(statbuf.st_mode)) {
+        logError("file: "__FILE__", line: %d, "
+                "%s is NOT a directory!", __LINE__, path);
+        return ENOTDIR;
+    }
+
+    sprintf(dev_path, "/dev/block/%d:%d", (int)major(statbuf.st_dev),
+            (int)minor(statbuf.st_dev));
+    if (access(dev_path, R_OK) == 0) {
+        if ((result=get_device_block_size(dev_path, block_size)) == 0) {
+            return 0;
+        }
+    }
+
+    return get_block_size_by_write(path, block_size);
+}
+
+int get_groups(const pid_t pid, const gid_t gid, const int size, gid_t *list)
+{
+#define GROUPS_TAG_STR   "\nGroups:"
+#define GROUPS_TAG_LEN   (sizeof(GROUPS_TAG_STR) - 1)
+
+    char filename[64];
+    char buff[1024];
+    char *p;
+    char *end;
+    int fd;
+    int len;
+    gid_t val;
+    int count;
+
+    sprintf(filename, "/proc/%d/status", pid);
+    fd = open(filename, O_RDONLY);
+    if (fd < 0) {
+        return 0;
+    }
+
+    len = read(fd, buff, sizeof(buff));
+    close(fd);
+    if (len <= 0) {
+        return 0;
+    }
+
+    buff[len - 1] = '\0';
+    if ((p=strstr(buff, GROUPS_TAG_STR)) == NULL) {
+        return 0;
+    }
+
+    p += GROUPS_TAG_LEN;
+    count = 0;
+    while (count < size) {
+        val = strtoul(p, &end, 10);
+        if (end == p) {
+            break;
+        }
+
+        if (val != gid) {
+            list[count++] = val;
+        }
+        p = end;
+    }
+
+    return count;
+}
+
+#elif defined(OS_FREEBSD)
+
+int get_groups(const pid_t pid, const gid_t gid, const int size, gid_t *list)
+{
+    int mibpath[4];
+    struct kinfo_proc kp;
+    size_t kplen;
+    int count;
+    int i;
+
+#if defined(CTL_KERN) && defined(KERN_PROC) && defined(KERN_PROC_PID)
+    mibpath[0] = CTL_KERN;
+    mibpath[1] = KERN_PROC;
+    mibpath[2] = KERN_PROC_PID;
+#else
+    kplen = 4;
+    sysctlnametomib("kern.proc.pid", mibpath, &kplen);
+#endif
+    mibpath[3] = pid;
+
+    kplen = sizeof(kp);
+    memset(&kp,0,sizeof(kp));
+    if (sysctl(mibpath, 4, &kp, &kplen, NULL, 0) != 0) {
+        return 0;
+    }
+
+#if defined(DARWIN)
+#define ki_ngroups kp_eproc.e_ucred.cr_ngroups
+#define ki_groups  kp_eproc.e_ucred.cr_groups
+#endif
+
+    count = 0;
+    for (i=0; i<kp.ki_ngroups && count<size; i++) {
+        if (kp.ki_groups[i] != gid) {
+            list[count++] = kp.ki_groups[i];
+        }
+    }
+
+    return count;
+}
+
+#endif

src/system_info.h

@@ -42,6 +42,14 @@ extern "C" {
 #define MNAMELEN 128
 #endif
 
+    typedef enum fast_device_type {
+        fast_device_type_unkown = 0,
+        fast_device_type_disk,
+        fast_device_type_memory,
+        fast_device_type_fuse,
+        fast_device_type_network
+    } FastDeviceType;
+
    typedef struct fast_statfs {
         long    f_type;     /* type of file system (see below) */
         long    f_bsize;    /* optimal transfer block size */
@@ -56,6 +64,7 @@ extern "C" {
         char    f_fstypename[MFSNAMELEN]; /* fs type name */
         char    f_mntfromname[MNAMELEN];  /* mounted file system */
         char    f_mntonname[MNAMELEN];    /* directory on which mounted */
+        FastDeviceType device_type;
     } FastStatFS;
 
 #if defined(OS_LINUX) || defined(OS_FREEBSD)
@@ -120,24 +129,41 @@ extern "C" {
    } FastProcessInfo;
 #endif
 
+   static inline const char *get_device_type_caption(
+           const FastDeviceType device_type)
+   {
+       switch (device_type) {
+           case fast_device_type_disk:
+               return "disk";
+           case fast_device_type_memory:
+               return "memory";
+           case fast_device_type_fuse:
+               return "fuse";
+           case fast_device_type_network:
+               return "network";
+           default:
+               return "unkown";
+       }
+   }
+
 /** get system total memory size
  *  parameters:
  *  	mem_size: return the total memory size
- *  return: error no , 0 success, != 0 fail
+ *  return: error no, 0 success, != 0 fail
 */
 int get_sys_total_mem_size(int64_t *mem_size);
 
 
 /** get system CPU count
  *  parameters:
- *  return: error no , 0 success, != 0 fail
+ *  return: error no, 0 success, != 0 fail
 */
 int get_sys_cpu_count();
 
 /** get system boot time
  *  parameters:
  *      uptime: store the up time
- *  return: error no , 0 success, != 0 fail
+ *  return: error no, 0 success, != 0 fail
 */
 int get_boot_time(struct timeval *boot_time);
 
@@ -146,21 +172,46 @@ int get_boot_time(struct timeval *boot_time);
  *      stats: the stat array
  *      size:  max size of the array
  *      count: return the count of the array
- *  return: error no , 0 success, != 0 fail
+ *  return: error no, 0 success, != 0 fail
 */
 int get_mounted_filesystems(struct fast_statfs *stats,
         const int size, int *count);
 
+/** get statfs by path
+ *  parameters:
+ *      path: the path
+ *      statfs: return the statfs
+ *  return: error no, 0 success, != 0 fail
+*/
+int get_statfs_by_path(const char *path, FastStatFS *statfs);
+
+/** is rotational device by path
+ *  parameters:
+ *      path: the path
+ *  return: true for rotational device, otherwise false
+*/
+bool is_rotational_device_by_path(const char *path);
+
 #if defined(OS_LINUX) || defined(OS_FREEBSD)
 /** get processes
  *  parameters:
  *      processes: return the processes
  *      count: return the count of the processes
- *  return: error no , 0 success, != 0 fail
+ *  return: error no, 0 success, != 0 fail
 */
 int get_processes(struct fast_process_info **processes, int *count);
 
-int get_sysinfo(struct fast_sysinfo*info);
+int get_sysinfo(struct fast_sysinfo *info);
+
+int get_kernel_version(Version *version);
+
+int get_groups(const pid_t pid, const gid_t gid, const int size, gid_t *list);
+
+#ifdef OS_LINUX
+int get_device_block_size(const char *device, int *block_size);
+int get_path_block_size(const char *path, int *block_size);
+#endif
+
 #endif
 
 #ifdef __cplusplus

src/tests/Makefile.in

@@ -1,17 +1,20 @@
 .SUFFIXES: .c .o
 
-COMPILE = $(CC) -g -O3 -Wall -D_FILE_OFFSET_BITS=64 -g -DDEBUG_FLAG
-INC_PATH = -I/usr/local/include
-LIB_PATH = -lfastcommon -lpthread
+COMPILE = $(CC) -g -O3 -Wall -D_FILE_OFFSET_BITS=64 -D_GNU_SOURCE -g -DDEBUG_FLAG
+INC_PATH = $(INCS)
+LIB_PATH = -lfastcommon $(LIBS)
 
 ALL_PRGS = test_allocator test_skiplist test_multi_skiplist test_mblock test_blocked_queue \
            test_id_generator test_ini_parser test_char_convert test_char_convert_loader \
            test_logger test_skiplist_set test_crc32 test_thourands_seperator test_sched_thread \
            test_json_parser test_pthread_lock test_uniq_skiplist test_split_string \
            test_server_id_func test_pipe test_atomic test_file_write_hole test_file_lock \
-           test_thread_pool test_data_visible
+           test_pthread_wait test_thread_pool test_data_visible test_mutex_lock_perf \
+           test_queue_perf test_normalize_path test_sorted_array test_sorted_queue   \
+           test_thread_local test_memcpy test_fast_buffer mblock_benchmark cpool_benchmark
 
 all: $(ALL_PRGS)
+
 .c:
 	$(COMPILE) -o $@ $< $(LIB_PATH) $(INC_PATH)
 .c.o:

src/tests/cpool_benchmark.c

@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2025 YuQing <384681@qq.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the Lesser GNU General Public License, version 3
+ * or later ("LGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <time.h>
+#include <inttypes.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#include "fastcommon/logger.h"
+#include "fastcommon/shared_func.h"
+#include "fastcommon/pthread_func.h"
+#include "fastcommon/connection_pool.h"
+
+#define USE_CONN_POOL  1
+//#define USE_CAS_LOCK   1
+
+static int thread_count = 16;
+static int64_t loop_count = 10000000;
+static ConnectionPool cpool;
+static char buff[1024];
+static pthread_mutex_t lock;
+volatile int mutex = 0;
+
+#ifndef USE_CONN_POOL
+static int64_t test_var1 = 0;
+static int64_t test_var2 = 0;
+#endif
+
+static inline void conn_pool_get_key(const ConnectionInfo *conn,
+        char *key, int *key_len)
+{
+    *key_len = strlen(conn->ip_addr);
+    memcpy(key, conn->ip_addr, *key_len);
+    *(key + (*key_len)++) = '-';
+    *(key + (*key_len)++) = (conn->port >> 8) & 0xFF;
+    *(key + (*key_len)++) = conn->port & 0xFF;
+}
+
+static void *thread_run(void *args)
+{
+    int thread_index;
+    int result;
+    int64_t i;
+    ConnectionInfo cinfo;
+#ifdef USE_CONN_POOL
+    ConnectionInfo *conn;
+#endif
+
+    thread_index = (long)args;
+    printf("thread #%d start\n", thread_index);
+    
+    if ((result=conn_pool_parse_server_info("127.0.0.1", &cinfo, 23000)) != 0) {
+        return NULL;
+    }
+    for (i=0; i<loop_count; i++) {
+#ifdef USE_CONN_POOL
+        if ((conn=conn_pool_get_connection_ex(&cpool, &cinfo,
+                        NULL, true, &result)) == NULL)
+        {
+            break;
+        }
+        //fc_sleep_us(1);
+        conn_pool_close_connection(&cpool, conn);
+#else
+        char key_buff[INET6_ADDRSTRLEN + 8];
+        string_t key;
+        uint32_t hash_code;
+        for (int j=0; j<2; j++) {
+            key.str = key_buff;
+            conn_pool_get_key(&cinfo, key.str, &key.len);
+            hash_code = fc_simple_hash(key.str, key.len);
+#ifdef USE_CAS_LOCK
+            while (!__sync_bool_compare_and_swap(&mutex, 0, 1)) {
+                sched_yield();
+            }
+            __sync_fetch_and_add(&test_var1, 1);
+            __sync_fetch_and_add(&test_var2, 1);
+#else
+            PTHREAD_MUTEX_LOCK(&lock);
+            test_var1++;
+            test_var2++;
+#endif
+#ifdef USE_CAS_LOCK
+            __sync_bool_compare_and_swap(&mutex, 1, 0);
+#else
+            PTHREAD_MUTEX_UNLOCK(&lock);
+#endif
+        }
+#endif
+
+    }
+
+    if (i == loop_count) {
+        printf("thread #%d done\n", thread_index);
+    } else {
+        printf("thread #%d loop count: %"PRId64"\n", thread_index, i);
+    }
+
+    return NULL;
+}
+
+int main(int argc, char *argv[])
+{
+    const int stack_size = 64 * 1024;
+    const int connect_timeout = 2;
+    const int max_count_per_entry = 0;
+    const int max_idle_time = 3600;
+    const int htable_capacity = 163;
+    const int extra_data_size = 0;
+    int result;
+    int i;
+    int64_t qps;
+    pthread_t *tids;
+    pthread_attr_t thread_attr;
+    int64_t start_time;
+    int64_t end_time;
+    int64_t time_used;
+    ConnectionExtraParams params;
+
+    log_init();
+    g_log_context.log_level = LOG_INFO;
+    g_schedule_flag = true;
+    g_current_time = time(NULL);
+
+    memset(&params, 0, sizeof(params));
+    params.tls.enabled = false;
+    params.tls.htable_capacity = 13;
+    if ((result=conn_pool_init_ex1(&cpool, connect_timeout, max_count_per_entry,
+                    max_idle_time, htable_capacity, NULL, NULL, NULL, NULL,
+                    extra_data_size, &params)) != 0)
+    {
+        return result;
+    }
+
+
+    memset(buff, 0, sizeof(buff));
+    if ((result=init_pthread_lock(&lock)) != 0) {
+        return result;
+    }
+
+    if ((result=pthread_attr_init(&thread_attr)) != 0) {
+        logError("file: "__FILE__", line: %d, "
+                "call pthread_attr_init fail, "
+                "errno: %d, error info: %s",
+                __LINE__, result, STRERROR(result));
+        return result;
+    }
+    if ((result=pthread_attr_setstacksize(&thread_attr,
+                stack_size)) != 0)
+    {
+        logError("file: "__FILE__", line: %d, "
+                "call pthread_attr_setstacksize to %d fail, "
+                "errno: %d, error info: %s", __LINE__,
+                stack_size, result, STRERROR(result));
+        return result;
+    }
+
+    tids = fc_malloc(sizeof(pthread_t) * thread_count);
+
+    start_time = get_current_time_us();
+    for (i=0; i<thread_count; i++) {
+        if ((result=pthread_create(tids + i, &thread_attr,
+                        thread_run, (void *)((long)i))) != 0)
+        {
+            logError("file: "__FILE__", line: %d, "
+                    "create thread failed, "
+                    "errno: %d, error info: %s",
+                    __LINE__, result, STRERROR(result));
+            return result;
+        }
+    }
+
+    for (i=0; i<thread_count; i++) {
+        pthread_join(tids[i], NULL);
+    }
+
+    end_time = get_current_time_us();
+    time_used = end_time - start_time;
+    qps = (thread_count * loop_count * 1000 * 1000) / time_used;
+    printf("time used: %"PRId64" ms, QPS: %"PRId64"\n", time_used / 1000, qps);
+
+    {
+        ConnectionPoolStat stat;
+        conn_pool_stat(&cpool, &stat);
+        printf("htable_capacity: %d, bucket_used: %d, server_count: %d, "
+                "connection {total_count: %d, free_count: %d}\n",
+                stat.htable_capacity, stat.bucket_used, stat.server_count,
+                stat.connection.total_count, stat.connection.free_count);
+    }
+
+    free(tids);
+    conn_pool_destroy(&cpool);
+
+    return 0;
+}

src/tests/mblock_benchmark.c

@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2025 YuQing <384681@qq.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the Lesser GNU General Public License, version 3
+ * or later ("LGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <time.h>
+#include <inttypes.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#include "fastcommon/logger.h"
+#include "fastcommon/shared_func.h"
+#include "fastcommon/pthread_func.h"
+#include "fastcommon/fast_mblock.h"
+
+static int thread_count = 4;
+static int64_t loop_count = 10000000;
+static struct fast_mblock_man mblock;
+
+static void *thread_run(void *args)
+{
+    int thread_index;
+    int i;
+    void *obj;
+
+    thread_index = (long)args;
+    printf("thread #%d start\n", thread_index);
+
+    for (i=0; i<loop_count; i++) {
+        obj = fast_mblock_alloc_object(&mblock);
+        fast_mblock_free_object(&mblock, obj);
+    }
+
+    printf("thread #%d done\n", thread_index);
+
+    return NULL;
+}
+
+int main(int argc, char *argv[])
+{
+    const int stack_size = 64 * 1024;
+    int result;
+    int limit;
+    int i;
+    bool continue_flag = true;
+    int64_t qps;
+    pthread_t *tids;
+    pthread_attr_t thread_attr;
+    int64_t start_time;
+    int64_t end_time;
+    int64_t time_used;
+
+    log_init();
+    g_log_context.log_level = LOG_DEBUG;
+
+    limit = (thread_count + 1) / 2;
+    fast_mblock_manager_init();
+    if ((result=fast_mblock_init_ex1(&mblock, "mblock", 1024,
+                    limit, limit, NULL, NULL, true)) != 0)
+    {
+        return result;
+    }
+    fast_mblock_set_need_wait(&mblock, true, &continue_flag);
+
+    if ((result=pthread_attr_init(&thread_attr)) != 0) {
+        logError("file: "__FILE__", line: %d, "
+                "call pthread_attr_init fail, "
+                "errno: %d, error info: %s",
+                __LINE__, result, STRERROR(result));
+        return result;
+    }
+    if ((result=pthread_attr_setstacksize(&thread_attr,
+                stack_size)) != 0)
+    {
+        logError("file: "__FILE__", line: %d, "
+                "call pthread_attr_setstacksize to %d fail, "
+                "errno: %d, error info: %s", __LINE__,
+                stack_size, result, STRERROR(result));
+        return result;
+    }
+
+    tids = fc_malloc(sizeof(pthread_t) * thread_count);
+
+    start_time = get_current_time_us();
+    for (i=0; i<thread_count; i++) {
+        if ((result=pthread_create(tids + i, &thread_attr,
+                        thread_run, (void *)((long)i))) != 0)
+        {
+            logError("file: "__FILE__", line: %d, "
+                    "create thread failed, "
+                    "errno: %d, error info: %s",
+                    __LINE__, result, STRERROR(result));
+            return result;
+        }
+    }
+
+    for (i=0; i<thread_count; i++) {
+        pthread_join(tids[i], NULL);
+    }
+
+    end_time = get_current_time_us();
+    time_used = end_time - start_time;
+    qps = (thread_count * loop_count * 1000 * 1000) / time_used;
+    printf("time used: %"PRId64" ms, QPS: %"PRId64"\n", time_used / 1000, qps);
+
+    free(tids);
+    fast_mblock_manager_stat_print(false);
+    fast_mblock_destroy(&mblock);
+
+    return 0;
+}

src/tests/test_blocked_queue.c

@@ -30,6 +30,7 @@
 static bool g_continue_flag = true;
 static int64_t produce_count = 0;
 static int64_t consume_count = 0;
+static struct fast_task_queue free_queue;
 static struct fast_blocked_queue blocked_queue;
 
 #define MAX_USLEEP 10000
@@ -51,7 +52,7 @@ void *producer_thread(void *arg)
             printf("produce count: %"PRId64"\n", count);
         }
 
-        pTask = free_queue_pop();
+        pTask = free_queue_pop(&free_queue);
         if (pTask != NULL) {
             blocked_queue_push(&blocked_queue, pTask);
         }
@@ -99,7 +100,7 @@ int main(int argc, char *argv[])
         return errno;
     }
 
-    result = free_queue_init(1024, min_buff_size, \
+    result = free_queue_init(&free_queue, 1024, min_buff_size,
             max_buff_size, arg_size);
     if (result != 0) {
         return result;

src/tests/test_data_visible.c

@@ -127,7 +127,7 @@ int main(int argc, char *argv[])
     {
         return result;
     }
-    allocator.exceed_log_level = LOG_NOTHING;
+    allocator.alloc_elements.exceed_log_level = LOG_NOTHING;
 
     if ((result=init_pthread_lock(&lock)) != 0) {
         return result;

src/tests/test_fast_buffer.c

@@ -0,0 +1,331 @@
+/*
+ * Copyright (c) 2020 YuQing <384681@qq.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the Lesser GNU General Public License, version 3
+ * or later ("LGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <time.h>
+#include <inttypes.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <sys/stat.h>
+#include "fastcommon/logger.h"
+#include "fastcommon/fast_buffer.h"
+#include "fastcommon/sched_thread.h"
+
+typedef enum {
+    TEST_TYPE_NONE = 0,
+    TEST_TYPE_ITOA,
+    TEST_TYPE_FTOA,
+    TEST_TYPE_INT2HEX,
+    TEST_TYPE_APPEND
+} TestType;
+
+typedef enum {
+    DA_SLICE_TYPE_FILE  = 'F', /* in file slice */
+    DA_SLICE_TYPE_CACHE = 'C', /* in memory cache */
+    DA_SLICE_TYPE_ALLOC = 'A'  /* allocate slice (index and space allocate only) */
+} DASliceType;
+
+typedef struct {
+    int64_t version;
+    uint64_t trunk_id; //0 for not inited
+    uint32_t length;   //data length
+    uint32_t offset;   //space offset
+    uint32_t size;     //space size
+} DAPieceFieldStorage;
+
+typedef struct {
+    int64_t version; //for stable sort only
+    uint64_t oid;    //object ID
+    uint64_t fid;    //field ID (key)
+    uint32_t extra;       //such as slice offset
+    char op_type;
+    DASliceType slice_type;
+    DAPieceFieldStorage storage;
+} DATrunkSpaceLogRecord;
+
+static inline void log_pack_by_append(const DATrunkSpaceLogRecord
+        *record, FastBuffer *buffer, const bool have_extra_field)
+{
+    fast_buffer_append_int64(buffer, (uint32_t)g_current_time);
+    fast_buffer_append_char(buffer, ' ');
+    fast_buffer_append_int64(buffer, record->storage.version);
+    fast_buffer_append_char(buffer, ' ');
+    fast_buffer_append_int64(buffer, record->oid);
+    fast_buffer_append_char(buffer, ' ');
+    fast_buffer_append_int64(buffer, record->fid);
+    fast_buffer_append_char(buffer, ' ');
+    fast_buffer_append_char(buffer, record->op_type);
+    fast_buffer_append_char(buffer, ' ');
+    fast_buffer_append_int64(buffer, record->storage.trunk_id);
+    fast_buffer_append_char(buffer, ' ');
+    fast_buffer_append_int64(buffer, record->storage.length);
+    fast_buffer_append_char(buffer, ' ');
+    fast_buffer_append_int64(buffer, record->storage.offset);
+    fast_buffer_append_char(buffer, ' ');
+    fast_buffer_append_int64(buffer, record->storage.size);
+    fast_buffer_append_char(buffer, ' ');
+    fast_buffer_append_char(buffer, record->slice_type);
+
+    if (have_extra_field) {
+        fast_buffer_append_char(buffer, ' ');
+        fast_buffer_append_char(buffer, record->extra);
+        fast_buffer_append_char(buffer, '\n');
+    } else {
+        fast_buffer_append_char(buffer, '\n');
+    }
+}
+
+static inline void log_pack_by_sprintf(const DATrunkSpaceLogRecord
+        *record, FastBuffer *buffer, const bool have_extra_field)
+{
+    buffer->length += sprintf(buffer->data + buffer->length,
+            "%u %"PRId64" %"PRId64" %"PRId64" %c %"PRId64" %u %u %u %c",
+            (uint32_t)g_current_time, record->storage.version,
+            record->oid, record->fid, record->op_type,
+            record->storage.trunk_id, record->storage.length,
+            record->storage.offset, record->storage.size,
+            record->slice_type);
+    if (have_extra_field) {
+        buffer->length += sprintf(buffer->data + buffer->length,
+                " %u\n", record->extra);
+    } else {
+        *(buffer->data + buffer->length++) = '\n';
+    }
+}
+
+#define BINLOG_FILENAME_PREFIX_STR  "binlog."
+#define BINLOG_FILENAME_PREFIX_LEN  (sizeof(BINLOG_FILENAME_PREFIX_STR) - 1)
+
+static inline int cache_binlog_filename_by_sprintf(
+        const char *data_path, const char *subdir_name,
+        const uint32_t subdirs, const uint64_t id,
+        char *full_filename, const int size)
+{
+    int path_index;
+    path_index = id % subdirs;
+    return sprintf(full_filename, "%s/%s/%02X/%02X/%s%08"PRIX64,
+            data_path, subdir_name, path_index, path_index,
+            BINLOG_FILENAME_PREFIX_STR, id);
+}
+
+static inline int cache_binlog_filename_by_append(
+        const char *data_path, const char *subdir_name,
+        const uint32_t subdirs, const uint64_t id,
+        char *full_filename, const int size)
+{
+    int path_index;
+    int path_len;
+    int subdir_len;
+    char *p;
+
+    path_index = id % subdirs;
+    path_len = strlen(data_path);
+    subdir_len = strlen(subdir_name);
+    p = full_filename;
+    memcpy(p, data_path, path_len);
+    p += path_len;
+    *p++ = '/';
+    memcpy(p, subdir_name, subdir_len);
+    p += subdir_len;
+    *p++ = '/';
+    *p++ = g_upper_hex_chars[(path_index >> 4) & 0x0F];
+    *p++ = g_upper_hex_chars[path_index & 0x0F];
+    *p++ = '/';
+    *p++ = g_upper_hex_chars[(path_index >> 4) & 0x0F];
+    *p++ = g_upper_hex_chars[path_index & 0x0F];
+    *p++ = '/';
+    memcpy(p, BINLOG_FILENAME_PREFIX_STR, BINLOG_FILENAME_PREFIX_LEN);
+    p += BINLOG_FILENAME_PREFIX_LEN;
+    if (id <= UINT32_MAX) {
+        p += int2HEX(id, p, 8);
+    } else {
+        p += long2HEX(id, p, 8);
+    }
+
+    return p - full_filename;
+}
+
+static void usage(const char *program)
+{
+    fprintf(stderr, "Usage: %s [-t {itoa | ftoa | int2hex | append | all}]\n",
+            program);
+}
+
+int main(int argc, char *argv[])
+{
+    const bool binary_mode = true;
+    const bool check_capacity = false;
+    const bool have_extra_field = false;
+    const int LOOP = 10 * 1000 * 1000;
+    const char *data_path = "/opt/fastcfs/fdir/data";
+    const char *subdir_name = "binlog";
+    const uint32_t subdirs = 256;
+
+    int result;
+    TestType test_type = TEST_TYPE_ITOA;
+    TestType type_start;
+    TestType type_last;
+    uint64_t id = 123456;
+    double d = 123.456;
+    int ch;
+    int i;
+    int len;
+    int64_t start_time_us;
+    int convert_time_us;
+    int sprintf_time_us;
+    double ratio;
+    FastBuffer buffer;
+    DATrunkSpaceLogRecord record;
+    char full_filename1[PATH_MAX];
+    char full_filename2[PATH_MAX];
+    char buff[32] = {0};
+    char *caption;
+
+	log_init();
+    g_current_time = time(NULL);
+    if ((result=fast_buffer_init_ex(&buffer, 256,
+                    binary_mode, check_capacity)) != 0)
+    {
+        return result;
+    }
+
+    type_start = type_last = TEST_TYPE_ITOA;
+    while ((ch=getopt(argc, argv, "ht:")) != -1) {
+        switch (ch) {
+            case 'h':
+                usage(argv[0]);
+                return 0;
+            case 't':
+                if (strcasecmp(optarg, "itoa") == 0) {
+                    type_start = type_last = TEST_TYPE_ITOA;
+                } else if (strcasecmp(optarg, "ftoa") == 0) {
+                    type_start = type_last = TEST_TYPE_FTOA;
+                } else if (strcasecmp(optarg, "int2hex") == 0) {
+                    type_start = type_last = TEST_TYPE_INT2HEX;
+                } else if (strcasecmp(optarg, "append") == 0) {
+                    type_start = type_last = TEST_TYPE_APPEND;
+                } else if (strcasecmp(optarg, "all") == 0) {
+                    type_start = TEST_TYPE_ITOA;
+                    type_last = TEST_TYPE_APPEND;
+                } else {
+                    fprintf(stderr, "invalid type: %s\n", optarg);
+                    return EINVAL;
+                }
+                break;
+            default:
+                usage(argv[0]);
+                return EINVAL;
+        }
+    }
+
+    for (test_type=type_start; test_type<=type_last; test_type++) {
+        if (test_type == TEST_TYPE_APPEND) {
+            memset(&record, 0, sizeof(record));
+            record.op_type = 'C';
+            record.slice_type = DA_SLICE_TYPE_FILE;
+            record.storage.version = 1111;
+            record.oid = 9007211709265131LL;
+            record.fid = 0;
+            record.storage.trunk_id = 61;
+            record.storage.length = 62;
+            record.storage.offset = 12345;
+            record.storage.size = 64;
+        }
+
+        start_time_us = get_current_time_us();
+        for (i=0; i<LOOP; i++) {
+            switch (test_type) {
+                case TEST_TYPE_APPEND:
+                    cache_binlog_filename_by_sprintf(data_path, subdir_name,
+                            subdirs, ++id, full_filename1, sizeof(full_filename1));
+                    fast_buffer_reset(&buffer);
+                    log_pack_by_sprintf(&record, &buffer, have_extra_field);
+                    break;
+                case TEST_TYPE_ITOA:
+                    sprintf(buff, "%"PRId64, id);
+                    break;
+                case TEST_TYPE_FTOA:
+                    sprintf(buff, "%.2f", d);
+                    break;
+                case TEST_TYPE_INT2HEX:
+                    sprintf(buff, "%x", (int)id);
+                    break;
+                default:
+                    break;
+            }
+        }
+        sprintf_time_us = (get_current_time_us() - start_time_us);
+
+        start_time_us = get_current_time_us();
+        for (i=0; i<LOOP; i++) {
+            switch (test_type) {
+                case TEST_TYPE_APPEND:
+                    cache_binlog_filename_by_append(data_path, subdir_name,
+                            subdirs, ++id, full_filename2, sizeof(full_filename2));
+                    fast_buffer_reset(&buffer);
+                    log_pack_by_append(&record, &buffer, have_extra_field);
+                    break;
+                case TEST_TYPE_ITOA:
+                    len = fc_itoa(id, buff);
+                    *(buff + len) = '\0';
+                    break;
+                case TEST_TYPE_FTOA:
+                    len = fc_ftoa(d, 2, buff);
+                    *(buff + len) = '\0';
+                    break;
+                case TEST_TYPE_INT2HEX:
+                    int2hex(id, buff, 0);
+                    break;
+                default:
+                    break;
+            }
+        }
+        convert_time_us = (get_current_time_us() - start_time_us);
+
+        if (convert_time_us > 0) {
+            ratio = (double)sprintf_time_us / (double)convert_time_us;
+        } else {
+            ratio = 1.0;
+        }
+
+        switch (test_type) {
+            case TEST_TYPE_ITOA:
+                caption = "itoa";
+                break;
+            case TEST_TYPE_FTOA:
+                caption = "ftoa";
+                break;
+            case TEST_TYPE_INT2HEX:
+                caption = "int2hex";
+                break;
+            case TEST_TYPE_APPEND:
+                caption = "append";
+                break;
+            default:
+                caption = "unkown";
+                break;
+        }
+        printf("sprintf time: %d ms, %s time: %d ms, "
+                "sprintf time / %s time: %d%%\n",
+                sprintf_time_us / 1000, caption, convert_time_us / 1000,
+                caption, (int)(ratio * 100.00));
+    }
+
+    fast_buffer_destroy(&buffer);
+	return 0;
+}

src/tests/test_file_lock.c

@@ -25,6 +25,7 @@
 #include <sys/file.h>
 #include "fastcommon/logger.h"
 #include "fastcommon/shared_func.h"
+#include "fastcommon/pthread_func.h"
 
 #define OneArgument(a) printf("One Argument func is called!\n")
 #define TwoArguments(a, b) printf("Two Arguments func is called!\n")
@@ -36,7 +37,6 @@ static inline int get_lock_info(int fd, struct flock *lock)
 {
     int result;
 
-    memset(lock, 0, sizeof(struct flock));
     lock->l_whence = SEEK_SET;
     lock->l_type = F_WRLCK;
     lock->l_pid = getpid();
@@ -53,6 +53,69 @@ static inline int get_lock_info(int fd, struct flock *lock)
     return result;
 }
 
+static inline int set_lock(int fd, const int operation,
+        const int start, const int length)
+{
+    int result;
+     struct flock lock;
+
+    memset(&lock, 0, sizeof(struct flock));
+    lock.l_whence = SEEK_SET;
+    lock.l_type = operation;
+    lock.l_start = start;
+    lock.l_len = length;
+    lock.l_pid = getpid();
+    do {
+        if ((result=fcntl(fd, F_SETLKW, &lock)) != 0)
+        {
+            result = errno != 0 ? errno : ENOMEM;
+            fprintf(stderr, "line: %d, call fcntl fail, "
+                   "errno: %d, error info: %s\n", __LINE__,
+                   result, STRERROR(result));
+        } else {
+            printf("line: %d, call fcntl %d result: %d\n",
+                    __LINE__, operation, result);
+        }
+    } while (result == EINTR);
+
+    return result;
+}
+
+static void *unlock_thread(void *args)
+{
+    char *filename;
+    int result;
+    int fd;
+    struct flock lock;
+
+    filename = (char *)args;
+    fd = open(filename, O_RDWR | O_CREAT, 0644);
+    if (fd < 0) {
+        result = errno != 0 ? errno : EIO;
+        logError("file: "__FILE__", line: %d, "
+                "open file %s fail, "
+                "errno: %d, error info: %s",
+                __LINE__, filename,
+                result, STRERROR(result));
+        return NULL;
+    }
+
+    memset(&lock, 0, sizeof(struct flock));
+    lock.l_start = 100;
+    if ((result=get_lock_info(fd, &lock)) == 0) {
+        logInfo("lock info: { type: %d, whence: %d, start: %"PRId64", "
+                "len: %"PRId64", pid: %d }",
+                lock.l_type, lock.l_whence, (int64_t)lock.l_start,
+                (int64_t)lock.l_len, lock.l_pid);
+    }
+
+    //set_lock(fd, F_WRLCK, 0, 0);
+    sleep(5);
+    //set_lock(fd, F_UNLCK, 0, 0);
+    close(fd);
+    return NULL;
+}
+
 int main(int argc, char *argv[])
 {
 #define SEEK_POS   (2 * 1024)
@@ -60,13 +123,16 @@ int main(int argc, char *argv[])
     int fd;
     int result;
     int sleep_seconds;
-    int n;
+    int n = 0;
+    pthread_t tid;
     char buf[1024];
     struct flock lock;
 
     Macro(1);
     Macro(1, 2);
     Macro(1, 2, 3);
+
+    printf("%0*d\n", 3, 1);
     if (argc < 2) {
         fprintf(stderr, "Usage: %s <filename>\n", argv[0]);
         return 1;
@@ -80,7 +146,7 @@ int main(int argc, char *argv[])
         sleep_seconds = 1;
     }
 
-    fd = open(filename, O_RDWR | O_CREAT, 0644);
+    fd = open(filename, O_RDWR | O_CREAT | O_CLOEXEC, 0644);
     if (fd < 0) {
         result = errno != 0 ? errno : EIO;
         logError("file: "__FILE__", line: %d, "
@@ -91,6 +157,61 @@ int main(int argc, char *argv[])
         return result;
     }
 
+    {
+    int flags;
+    flags = fcntl(fd, F_GETFD, 0);
+    if (flags < 0)
+    {
+        logError("file: "__FILE__", line: %d, " \
+            "fcntl failed, errno: %d, error info: %s.", \
+            __LINE__, errno, STRERROR(errno));
+        return errno != 0 ? errno : EACCES;
+    }
+
+    printf("flags: %d, on: %d\n", flags, (flags & FD_CLOEXEC));
+
+    if (fcntl(fd, F_SETFD, flags | FD_CLOEXEC) < 0)
+    {
+        logError("file: "__FILE__", line: %d, " \
+            "fcntl failed, errno: %d, error info: %s.", \
+            __LINE__, errno, STRERROR(errno));
+        return errno != 0 ? errno : EACCES;
+    }
+    flags = fcntl(fd, F_GETFD, 0);
+    printf("flags: %d, on: %d\n", flags, (flags & FD_CLOEXEC));
+    }
+
+
+    fork();
+
+    memset(&lock, 0, sizeof(struct flock));
+    lock.l_start = 1024;
+    if ((result=get_lock_info(fd, &lock)) == 0) {
+        logInfo("pid: %d, lock info: { type: %d, whence: %d, "
+                "start: %"PRId64", len: %"PRId64", pid: %d }", getpid(),
+                lock.l_type, lock.l_whence, (int64_t)lock.l_start,
+                (int64_t)lock.l_len, lock.l_pid);
+    }
+
+    set_lock(fd, F_WRLCK, 0, 10);
+    set_lock(fd, F_WRLCK, 10, 10);
+    set_lock(fd, F_WRLCK, 30, 10);
+    //set_lock(fd, F_WRLCK, 0, 0);
+    //set_lock(fd, F_UNLCK, 0, 10);
+    //set_lock(fd, F_UNLCK, 5, 35);
+
+    fc_create_thread(&tid, unlock_thread, filename, 64 * 1024);
+
+    sleep(100);
+    memset(&lock, 0, sizeof(struct flock));
+    lock.l_start = 100;
+    if ((result=get_lock_info(fd, &lock)) == 0) {
+        logInfo("lock info: { type: %d, whence: %d, start: %"PRId64", "
+                "len: %"PRId64", pid: %d }",
+                lock.l_type, lock.l_whence, (int64_t)lock.l_start,
+                (int64_t)lock.l_len, lock.l_pid);
+    }
+
     if (flock(fd, LOCK_EX) < 0) {
         logError("file: "__FILE__", line: %d, "
                 "flock file %s fail, "

src/tests/test_file_write_hole.c

@@ -32,6 +32,7 @@ int main(int argc, char *argv[])
     int fd;
     int result;
     int n;
+    int i;
     char buf[1024];
 
     if (argc < 2) {
@@ -50,7 +51,7 @@ int main(int argc, char *argv[])
     */
 
     //fd = open(filename, O_RDWR | O_CREAT | O_TRUNC, 0644);
-    fd = open(filename, O_RDWR | O_CREAT, 0644);
+    fd = open(filename, O_RDWR | O_CREAT | O_APPEND, 0644);
     if (fd < 0) {
         result = errno != 0 ? errno : EIO;
         logError("file: "__FILE__", line: %d, " \
@@ -69,7 +70,8 @@ int main(int argc, char *argv[])
         return errno != 0 ? errno : EIO;
     }
 
-    if (lseek(fd, SEEK_POS, SEEK_SET) < 0) {
+    for (i=0; i<5; i++) {
+    if (lseek(fd, 0, SEEK_SET) < 0) {
         logError("file: "__FILE__", line: %d, " \
             "lseek file %s fail, " \
             "errno: %d, error info: %s", __LINE__, \
@@ -86,6 +88,7 @@ int main(int argc, char *argv[])
         return errno != 0 ? errno : EIO;
     }
     printf("write bytes: %d\n", n);
+    }
 
     if (lseek(fd, 0, SEEK_SET) < 0) {
         logError("file: "__FILE__", line: %d, " \

src/tests/test_json_parser.c

@@ -28,11 +28,16 @@
 
 int main(int argc, char *argv[])
 {
-	int result;
+    const bool decode_use_mpool = false;
+    const int alloc_size_once = 1024;
+    const int init_buff_size = 1024;
+    int result;
     int json_type;
+    fc_json_context_t json_ctx;
     char error_info[256];
     string_t input;
-    string_t output;
+    BufferInfo buffer;
+    const BufferInfo *output;
 
     if (argc < 2) {
         fprintf(stderr, "Usage: %s <json_string | json_array | json_map>\n",
@@ -42,52 +47,70 @@ int main(int argc, char *argv[])
 	
 	log_init();
 
+    if ((result=fc_init_json_context_ex(&json_ctx, decode_use_mpool,
+                    alloc_size_once, init_buff_size, error_info,
+                    sizeof(error_info))) != 0)
+    {
+        return result;
+    }
+    memset(&buffer, 0, sizeof(buffer));
+
     input.str = argv[1];
     input.len = strlen(input.str);
-    json_type = detect_json_type(&input);
+    json_type = fc_detect_json_type(&input);
     if (json_type == FC_JSON_TYPE_ARRAY) {
-        json_array_t array;
+        const fc_json_array_t *array;
 
-        if ((result=decode_json_array(&input, &array, error_info,
-                        sizeof(error_info))) != 0)
-        {
+        if ((array=fc_decode_json_array(&json_ctx, &input)) == NULL) {
             fprintf(stderr, "decode json array fail, %s\n", error_info);
-            return result;
+            return fc_json_parser_get_error_no(&json_ctx);
         }
-                
-        if ((result=encode_json_array(&array, &output,
-                            error_info, sizeof(error_info))) != 0)
-        {
+
+        if (decode_use_mpool) {
+            output = fc_encode_json_array(&json_ctx,
+                    array->elements, array->count);
+            result = fc_json_parser_get_error_no(&json_ctx);
+        } else {
+            output = &buffer;
+            result = fc_encode_json_array_ex(&json_ctx,
+                    array->elements, array->count, &buffer);
+        }
+
+        if (result != 0) {
             fprintf(stderr, "encode json array fail, %s\n", error_info);
             return result;
         }
 
-        printf("%s\n", output.str);
-        free_json_string(&output);
-        free_json_array(&array);
+        printf("%.*s\n", output->length, output->buff);
+        fc_free_buffer(&buffer);
     } else if (json_type == FC_JSON_TYPE_MAP) {
-        json_map_t map;
+        const fc_json_map_t *map;
 
-        if ((result=decode_json_map(&input, &map, error_info,
-                        sizeof(error_info))) != 0)
-        {
+        if ((map=fc_decode_json_map(&json_ctx, &input)) == NULL) {
             fprintf(stderr, "decode json map fail, %s\n", error_info);
-            return result;
+            return fc_json_parser_get_error_no(&json_ctx);
         }
-                
-        if ((result=encode_json_map(&map, &output,
-                            error_info, sizeof(error_info))) != 0)
-        {
+
+        if (decode_use_mpool) {
+            output = fc_encode_json_map(&json_ctx,
+                    map->elements, map->count);
+            result = fc_json_parser_get_error_no(&json_ctx);
+        } else {
+            output = &buffer;
+            result = fc_encode_json_map_ex(&json_ctx,
+                    map->elements, map->count, &buffer);
+        }
+        if (result != 0) {
             fprintf(stderr, "encode json map fail, %s\n", error_info);
             return result;
         }
 
-        printf("%s\n", output.str);
-        free_json_string(&output);
-        free_json_map(&map);
+        printf("%.*s\n", output->length, output->buff);
+        fc_free_buffer(&buffer);
     } else {
         fprintf(stderr, "string\n");
     }
-
+ 
+    fc_destroy_json_context(&json_ctx);
 	return 0;
 }

src/tests/test_logger.c

@@ -22,6 +22,7 @@
 #include <sys/types.h>
 #include <sys/time.h>
 #include <sys/stat.h>
+#include <sys/file.h>
 #include "fastcommon/logger.h"
 
 int main(int argc, char *argv[])
@@ -35,6 +36,15 @@ int main(int argc, char *argv[])
     log_take_over_stderr();
     log_take_over_stdout();
     log_set_compress_log_flags(LOG_COMPRESS_FLAGS_ENABLED | LOG_COMPRESS_FLAGS_NEW_THREAD);
+
+    log_set_filename("/opt/fastcfs/fuse/test.log");
+
+
+    if (flock(g_log_context.log_fd, LOCK_EX) != 0) {
+        logError("flock fail");
+    }
+
+    flock(g_log_context.log_fd, LOCK_UN);
     
     printf("sizeof(LogContext): %d, time_precision: %d, compress_log_flags: %d, "
             "use_file_write_lock: %d\n", (int)sizeof(LogContext),
@@ -46,7 +56,7 @@ int main(int argc, char *argv[])
             "by log_it_ex, timestamp: %d", (int)time(NULL));
 
     len = sprintf(buff, "this is by log_it_ex1, "
-            "timestamp: %d", (int)time(NULL));
+            "timestamp: %ld", (long)time(NULL));
     log_it_ex1(&g_log_context, LOG_INFO, buff, len);
 
 	return 0;

src/tests/test_mblock.c

@@ -64,6 +64,8 @@ int main(int argc, char *argv[])
     volatile bool continue_flag = true;
     FastIFConfig if_configs[32];
     struct fast_statfs stats[32];
+    char *path;
+    FastStatFS statfs;
 
     start_time = get_current_time_ms();
     srand(time(NULL));
@@ -86,10 +88,19 @@ int main(int argc, char *argv[])
     printf("mounted fs count: %d\n", count);
     for (i=0; i<count; i++) {
         printf("%s => %s %s %ld %ld %ld %ld %ld %ld %ld\n",
-                stats[i].f_mntfromname, stats[i].f_mntonname, stats[i].f_fstypename,
-                stats[i].f_type, stats[i].f_bsize, stats[i].f_blocks,
-                stats[i].f_bfree, stats[i].f_bavail, stats[i].f_files,
-                stats[i].f_ffree);
+                stats[i].f_mntfromname, stats[i].f_mntonname,
+                stats[i].f_fstypename, stats[i].f_type, stats[i].f_bsize,
+                stats[i].f_blocks, stats[i].f_bfree, stats[i].f_bavail,
+                stats[i].f_files, stats[i].f_ffree);
+    }
+
+    path = "/";
+    if (get_statfs_by_path(path, &statfs) == 0) {
+        printf("\ninput path: %s, %s => %s, type: %s, category: %s, "
+                "rotational: %d\n\n", path, statfs.f_mntfromname,
+                statfs.f_mntonname, statfs.f_fstypename,
+                get_device_type_caption(statfs.device_type),
+                is_rotational_device_by_path(path));
     }
 
 #if defined(OS_LINUX) || defined(OS_FREEBSD)
@@ -139,31 +150,6 @@ int main(int argc, char *argv[])
 
 #endif
 
-    /*
-    {
-    int result;
-    char *filename;
-    IniContext iniContext;
-    if (argc > 1) {
-        filename  = argv[1];
-    } else {
-        filename = "/etc/mc/worker.conf";
-    }
-
-
-    if ((result=iniLoadFromFile(filename, &iniContext)) != 0) {
-        logError("file: "__FILE__", line: %d, "
-                "load conf file \"%s\" fail, ret code: %d",
-                __LINE__, filename, result);
-        return result;
-    }
-
-
-    //iniPrintItems(&iniContext);
-    iniFreeContext(&iniContext);
-    }
-    */
-
     sched_enable_delay_task();
     scheduleArray.entries = scheduleEntries;
     scheduleArray.count = 0;
@@ -176,7 +162,7 @@ int main(int argc, char *argv[])
     printf("cpu count: %d\n", get_sys_cpu_count());
 
     end_time = get_current_time_ms();
-    logInfo("time used: %d ms", (int)(end_time - start_time));
+    logInfo("time used: %d ms\n", (int)(end_time - start_time));
 
     fast_mblock_manager_init();
 
@@ -196,19 +182,33 @@ int main(int argc, char *argv[])
         sched_add_delay_task(test_delay, objs + i, delay, false);
     }
 
+    printf("mblock1 total count: %"PRId64", free count: %u\n",
+        fast_mblock_total_count(&mblock1),
+        fast_mblock_free_count(&mblock1));
+
     /*
     for (i=0; i<count; i++)
     {
-        fast_mblock_free_object(&mblock1, objs[i]);
+        fast_mblock_free_object(objs[i].mblock, objs[i].obj);
     }
     */
 
     obj1 = fast_mblock_alloc_object(&mblock1);
     obj2 = fast_mblock_alloc_object(&mblock1);
     fast_mblock_free_object(&mblock1, obj1);
+
+
+    printf("mblock1 total count: %"PRId64", free count: %u\n",
+        fast_mblock_total_count(&mblock1),
+        fast_mblock_free_count(&mblock1));
+
     //fast_mblock_delay_free_object(&mblock1, obj2, 10);
     fast_mblock_free_object(&mblock1, obj2);
 
+    printf("mblock1 total count: %"PRId64", free count: %u\n\n",
+        fast_mblock_total_count(&mblock1),
+        fast_mblock_free_count(&mblock1));
+
     obj1 = fast_mblock_alloc_object(&mblock2);
     obj2 = fast_mblock_alloc_object(&mblock2);
     fast_mblock_delay_free_object(&mblock2, obj1, 20);
@@ -220,6 +220,13 @@ int main(int argc, char *argv[])
     fast_mblock_reclaim(&mblock1, reclaim_target, &reclaim_count, NULL);
     fast_mblock_reclaim(&mblock2, reclaim_target, &reclaim_count, NULL);
 
+    printf("\nmblock1 total count: %"PRId64", free count: %u, "
+            "mblock2 total count: %"PRId64", free count: %u\n\n",
+            fast_mblock_total_count(&mblock1),
+            fast_mblock_free_count(&mblock1),
+            fast_mblock_total_count(&mblock2),
+            fast_mblock_free_count(&mblock2));
+
     fast_mblock_manager_stat_print(false);
 
     sleep(31);
@@ -231,11 +238,25 @@ int main(int argc, char *argv[])
     fast_mblock_reclaim(&mblock1, reclaim_target, &reclaim_count, NULL);
     fast_mblock_reclaim(&mblock2, reclaim_target, &reclaim_count, NULL);
 
+    printf("\nmblock1 total count: %"PRId64", free count: %u, "
+            "mblock2 total count: %"PRId64", free count: %u\n\n",
+            fast_mblock_total_count(&mblock1),
+            fast_mblock_free_count(&mblock1),
+            fast_mblock_total_count(&mblock2),
+            fast_mblock_free_count(&mblock2));
+
     fast_mblock_manager_stat_print(false);
 
     obj1 = fast_mblock_alloc_object(&mblock1);
     obj2 = fast_mblock_alloc_object(&mblock2);
 
+    printf("mblock1 total count: %"PRId64", free count: %u, "
+            "mblock2 total count: %"PRId64", free count: %u\n\n",
+            fast_mblock_total_count(&mblock1),
+            fast_mblock_free_count(&mblock1),
+            fast_mblock_total_count(&mblock2),
+            fast_mblock_free_count(&mblock2));
+
     fast_mblock_manager_stat_print(false);
 
     fast_mblock_destroy(&mblock1);

src/tests/test_memcpy.c

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2020 YuQing <384681@qq.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the Lesser GNU General Public License, version 3
+ * or later ("LGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "fastcommon/shared_func.h"
+
+#define BUFF_SIZE  (4 * 1024 * 1024)
+
+int main(int argc, char *argv[])
+{
+    char *buff1;
+    char *buff2;
+    char *dest;
+    int64_t start_time, end_time;
+    char time_buff[32];
+    int i;
+
+    buff1 = malloc(BUFF_SIZE);
+    buff2 = malloc(BUFF_SIZE);
+    dest = malloc(BUFF_SIZE);
+
+    memset(buff1, 'a', BUFF_SIZE);
+    memset(buff2, 'b', BUFF_SIZE);
+    memset(dest, 0, BUFF_SIZE);
+
+    start_time = get_current_time_us();
+    for (i=0; i<16 * 1024; i++) {
+        if (i % 2 == 0) {
+            memcpy(buff2, buff1, BUFF_SIZE);
+        } else {
+            memcpy(dest, buff2, BUFF_SIZE);
+        }
+    }
+
+    end_time = get_current_time_us();
+    printf("time used: %s us\n", long_to_comma_str(
+                end_time - start_time, time_buff));
+    return 0;
+}
+

src/tests/test_mutex_lock_perf.c

@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2020 YuQing <384681@qq.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the Lesser GNU General Public License, version 3
+ * or later ("LGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <time.h>
+#include <inttypes.h>
+#include <sys/time.h>
+#include "fastcommon/logger.h"
+#include "fastcommon/shared_func.h"
+#include "fastcommon/sched_thread.h"
+#include "fastcommon/pthread_func.h"
+#include "fastcommon/ini_file_reader.h"
+#include "fastcommon/fast_allocator.h"
+
+#define THREAD_COUNT 8
+#define LOOP_COUNT (100)
+
+static volatile int thread_count = THREAD_COUNT;
+static pthread_mutex_t lock;
+
+void *thread_func(void *arg)
+{
+    int64_t sum;
+    int k;
+
+    sum = 0;
+    for (k=1; k<=LOOP_COUNT; k++) {
+        pthread_mutex_lock(&lock);
+        usleep(100 * 1000);
+        sum += k;
+        pthread_mutex_unlock(&lock);
+    }
+
+    printf("sum: %"PRId64"\n", sum);
+
+    __sync_sub_and_fetch(&thread_count, 1);
+    return NULL;
+}
+
+int main(int argc, char *argv[])
+{
+	int result;
+    int count;
+	int64_t start_time;
+    int64_t time_used;
+    void *args[THREAD_COUNT];
+    pthread_t tids[THREAD_COUNT];
+    char time_buff[32];
+
+	log_init();
+	srand(time(NULL));
+	g_log_context.log_level = LOG_DEBUG;
+	
+    if ((result=init_pthread_lock(&lock)) != 0) {
+        logCrit("init_pthread_lock fail, result: %d", result);
+        return result;
+    }
+
+	start_time = get_current_time_ms();
+    memset(args, 0, sizeof(args));
+    count = THREAD_COUNT;
+    if ((result=create_work_threads(&count, thread_func,
+                    args, tids, 64 * 1024)) != 0)
+    {
+        return result;
+    }
+
+    while (__sync_add_and_fetch(&thread_count, 0) > 0) {
+        usleep(10 * 1000);
+    }
+
+    time_used = get_current_time_ms() - start_time;
+    printf("LOOP_COUNT: %d, time used: %s ms\n", LOOP_COUNT,
+            long_to_comma_str(time_used, time_buff));
+
+	return 0;
+}

src/tests/test_normalize_path.c

@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2020 YuQing <384681@qq.com>
+ *
+ * This program is free software: you can use, redistribute, and/or modify
+ * it under the terms of the Lesser GNU General Public License, version 3
+ * or later ("LGPL"), as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.
+ *
+ * You should have received a copy of the Lesser GNU General Public License
+ * along with this program. If not, see <https://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <time.h>
+#include <inttypes.h>
+#include <sys/time.h>
+#include "fastcommon/logger.h"
+#include "fastcommon/shared_func.h"
+#include "fastcommon/http_func.h"
+
+int main(int argc, char *argv[])
+{
+    char full_filename[PATH_MAX];
+    string_t from;
+    string_t filename;
+    int filename_len;
+    int result;
+
+    if (argc < 3) {
+        fprintf(stderr, "Usage: %s <base> <filename>\n", argv[0]);
+        return 1;
+    }
+
+    log_init();
+
+    FC_SET_STRING(from, argv[1]);
+    FC_SET_STRING(filename, argv[2]);
+    filename_len = normalize_path_ex(&from, &filename,
+            full_filename, sizeof(full_filename),
+            NORMALIZE_FLAGS_URL_ENABLED_AND_APPEND_PARAMS);
+    printf("%s => {len1: %d, len2: %d}\n", full_filename,
+            (int)strlen(full_filename), filename_len);
+
+    if (IS_URL_RESOURCE(full_filename)) {
+        const int connect_timeout = 2;
+        const int network_timeout = 30;
+        char *content;
+        int content_len;
+        int http_status;
+        char error_info[512];
+
+        content = NULL;
+        content_len = 0;
+        result = get_url_content_ex(full_filename, filename_len,
+                connect_timeout, network_timeout, &http_status,
+                &content, &content_len, error_info);
+        if (result == 0) {
+            printf("http status: %d, content length: %d\n",
+                    http_status, content_len);
+        } else if (*error_info != '\0') {
+            fprintf(stderr, "%s\n", error_info);
+        } else {
+            fprintf(stderr, "error code: %d\n", result);
+        }
+        return result;
+    }
+
+    return 0;
+}