gh actions: upgrade to 1.0.83-1

HISTORY

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

INSTALL

@@ -21,5 +21,5 @@ Debian, Ubuntu etc.:
 # the command lines as:
 
    git clone https://github.com/happyfish100/libfastcommon.git
-   cd libfastcommon; git checkout V1.0.81
+   cd libfastcommon; git checkout V1.0.83
    ./make.sh clean && ./make.sh && sudo ./make.sh install

debian/changelog

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

libfastcommon.spec

@@ -3,7 +3,7 @@
 %define CommitVersion %(echo $COMMIT_VERSION)
 
 Name: libfastcommon
-Version: 1.0.81
+Version: 1.0.83
 Release: 1%{?dist}
 Summary: c common functions library extracted from my open source projects FastDFS
 License: LGPL
@@ -19,10 +19,10 @@ 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})
+%define kernel_ver_int %(expr %{kernel_major} \\* 100 + %{kernel_minor})
 %if %{kernel_ver_int} >= 514
-BuildRequires: liburing-devel >= 2.5
+BuildRequires: liburing-devel >= 2.4
-Requires: liburing >= 2.5
+Requires: liburing >= 2.4
 %endif
 
 %description

src/fast_task_queue.h

@@ -37,7 +37,6 @@ struct nio_thread_data;
 struct fast_task_info;
 
 typedef int (*ThreadLoopCallback) (struct nio_thread_data *pThreadData);
-typedef int (*TaskFinishCallback) (struct fast_task_info *task);
 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);
@@ -149,7 +148,6 @@ struct fast_task_info
         struct fc_list_head dlink;  //for polling queue
     } polling;  //for RDMA busy polling
     TaskContinueCallback continue_callback; //for continue stage
-    TaskFinishCallback finish_callback;
     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

src/ioevent.c

@@ -46,36 +46,40 @@ int kqueue_ev_convert(int16_t event, uint16_t flags)
 #endif
 
 int ioevent_init(IOEventPoller *ioevent, const char *service_name,
-        const int size, const int timeout_ms, const int extra_events)
+        const bool use_io_uring, const int size, const int timeout_ms,
+        const int extra_events)
 {
-#if IOEVENT_USE_URING
-    int result;
-#else
     int bytes;
 
     ioevent->iterator.index = 0;
     ioevent->iterator.count = 0;
-#endif
-
     ioevent->service_name = service_name;
     ioevent->size = size;
     ioevent->extra_events = extra_events;
 
-#if IOEVENT_USE_EPOLL
+#ifdef OS_LINUX
-    ioevent->poll_fd = epoll_create(ioevent->size);
+#if IOEVENT_USE_URING
-    if (ioevent->poll_fd < 0) {
+    ioevent->use_io_uring = use_io_uring;
-        return errno != 0 ? errno : ENOMEM;
+    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
     }
-    bytes = sizeof(struct epoll_event) * size;
+#endif
-    ioevent->events = (struct epoll_event *)fc_malloc(bytes);
-#elif IOEVENT_USE_URING
-    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;
 #elif IOEVENT_USE_KQUEUE
     ioevent->poll_fd = kqueue();
     if (ioevent->poll_fd < 0) {
@@ -93,12 +97,14 @@ int ioevent_init(IOEventPoller *ioevent, const char *service_name,
 #endif
 
 #if IOEVENT_USE_URING
-
+    if (!ioevent->use_io_uring) {
-#else
+#endif
-    if (ioevent->events == NULL) {
+        if (ioevent->events == NULL) {
-        close(ioevent->poll_fd);
+            close(ioevent->poll_fd);
-        ioevent->poll_fd = -1;
+            ioevent->poll_fd = -1;
-        return ENOMEM;
+            return ENOMEM;
+        }
+#if IOEVENT_USE_URING
     }
 #endif
 
@@ -109,38 +115,49 @@ int ioevent_init(IOEventPoller *ioevent, const char *service_name,
 void ioevent_destroy(IOEventPoller *ioevent)
 {
 #if IOEVENT_USE_URING
-    io_uring_queue_exit(&ioevent->ring);
+    if (ioevent->use_io_uring) {
-#else
+        io_uring_queue_exit(&ioevent->ring);
-  if (ioevent->events != NULL) {
+    } else {
-    free(ioevent->events);
+#endif
-    ioevent->events = NULL;
+        if (ioevent->events != NULL) {
-  }
+            free(ioevent->events);
+            ioevent->events = NULL;
+        }
 
-  if (ioevent->poll_fd >= 0) {
+        if (ioevent->poll_fd >= 0) {
-    close(ioevent->poll_fd);
+            close(ioevent->poll_fd);
-    ioevent->poll_fd = -1;
+            ioevent->poll_fd = -1;
-  }
+        }
+#if IOEVENT_USE_URING
+    }
 #endif
 }
 
 int ioevent_attach(IOEventPoller *ioevent, const int fd,
         const int e, void *data)
 {
-#if IOEVENT_USE_EPOLL
+#ifdef OS_LINUX
-  struct epoll_event ev;
+#if IOEVENT_USE_URING
-  memset(&ev, 0, sizeof(ev));
+    if (ioevent->use_io_uring) {
-  ev.events = e | ioevent->extra_events;
+        struct io_uring_sqe *sqe = io_uring_get_sqe(&ioevent->ring);
-  ev.data.ptr = data;
+        if (sqe == NULL) {
-  return epoll_ctl(ioevent->poll_fd, EPOLL_CTL_ADD, fd, &ev);
+            return ENOSPC;
-#elif IOEVENT_USE_URING
+        }
-  struct io_uring_sqe *sqe = io_uring_get_sqe(&ioevent->ring);
+        io_uring_prep_poll_multishot(sqe, fd, e | ioevent->extra_events);
-  if (sqe == NULL) {
+        sqe->user_data = (long)data;
-      return ENOSPC;
+        ioevent->submit_count++;
-  }
+        return 0;
-  io_uring_prep_poll_multishot(sqe, fd, e | ioevent->extra_events);
+    } else {
-  sqe->user_data = (long)data;
+#endif
-  ioevent->submit_count++;
+        struct epoll_event ev;
-  return 0;
+        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;
@@ -162,22 +179,29 @@ int ioevent_attach(IOEventPoller *ioevent, const int fd,
 int ioevent_modify(IOEventPoller *ioevent, const int fd,
         const int e, void *data)
 {
-#if IOEVENT_USE_EPOLL
+#ifdef OS_LINUX
-  struct epoll_event ev;
+#if IOEVENT_USE_URING
-  memset(&ev, 0, sizeof(ev));
+    if (ioevent->use_io_uring) {
-  ev.events = e | ioevent->extra_events;
+        struct io_uring_sqe *sqe = io_uring_get_sqe(&ioevent->ring);
-  ev.data.ptr = data;
+        if (sqe == NULL) {
-  return epoll_ctl(ioevent->poll_fd, EPOLL_CTL_MOD, fd, &ev);
+            return ENOSPC;
-#elif IOEVENT_USE_URING
+        }
-  struct io_uring_sqe *sqe = io_uring_get_sqe(&ioevent->ring);
+        io_uring_prep_poll_update(sqe, sqe->user_data, sqe->user_data,
-  if (sqe == NULL) {
+                e | ioevent->extra_events, IORING_POLL_UPDATE_EVENTS);
-      return ENOSPC;
+        sqe->user_data = (long)data;
-  }
+        ioevent->submit_count++;
-  io_uring_prep_poll_update(sqe, sqe->user_data, sqe->user_data,
+        return 0;
-          e | ioevent->extra_events, IORING_POLL_UPDATE_EVENTS);
+    } else {
-  sqe->user_data = (long)data;
+#endif
-  ioevent->submit_count++;
+        struct epoll_event ev;
-  return 0;
+        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;
@@ -212,18 +236,25 @@ int ioevent_modify(IOEventPoller *ioevent, const int fd,
 
 int ioevent_detach(IOEventPoller *ioevent, const int fd)
 {
-#if IOEVENT_USE_EPOLL
+#ifdef OS_LINUX
-  return epoll_ctl(ioevent->poll_fd, EPOLL_CTL_DEL, fd, NULL);
+#if IOEVENT_USE_URING
-#elif IOEVENT_USE_URING
+    if (ioevent->use_io_uring) {
-  struct io_uring_sqe *sqe = io_uring_get_sqe(&ioevent->ring);
+        struct io_uring_sqe *sqe = io_uring_get_sqe(&ioevent->ring);
-  if (sqe == NULL) {
+        if (sqe == NULL) {
-      return ENOSPC;
+            return ENOSPC;
-  }
+        }
-  io_uring_prep_cancel_fd(sqe, fd, 0);
+        io_uring_prep_cancel_fd(sqe, fd, 0);
-  /* set sqe->flags MUST after io_uring_prep_xxx */
+        /* set sqe->flags MUST after io_uring_prep_xxx */
-  sqe->flags = IOSQE_CQE_SKIP_SUCCESS;
+        sqe->flags = IOSQE_CQE_SKIP_SUCCESS;
-  ioevent->submit_count++;
+        ioevent->submit_count++;
-  return 0;
+        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;
@@ -242,18 +273,25 @@ int ioevent_detach(IOEventPoller *ioevent, const int fd)
 
 int ioevent_poll(IOEventPoller *ioevent)
 {
-#if IOEVENT_USE_EPOLL
+#ifdef OS_LINUX
-  return epoll_wait(ioevent->poll_fd, ioevent->events,
+#if IOEVENT_USE_URING
-          ioevent->size, ioevent->timeout);
+    if (ioevent->use_io_uring) {
-#elif IOEVENT_USE_URING
+        int result;
-  int result;
+        result = io_uring_wait_cqe_timeout(&ioevent->ring,
-  result = io_uring_wait_cqe_timeout(&ioevent->ring,
+                &ioevent->cqe, &ioevent->timeout);
-          &ioevent->cqe, &ioevent->timeout);
+        if (result < 0) {
-  if (result < 0) {
+            errno = -result;
-      errno = -result;
+            return -1;
-      return -1;
+        }
-  }
+        return 0;
-  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);

src/ioevent.h

@@ -25,10 +25,12 @@
 #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)
@@ -77,25 +79,30 @@ typedef struct ioevent_puller {
     const char *service_name;
     int size;  //max events (fd)
     int extra_events;
+
 #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
-#else
+    bool use_io_uring;
+#endif
+
     int poll_fd;
     struct {
         int index;
         int count;
     } iterator;  //for deal event loop
-#endif
 
-#if IOEVENT_USE_EPOLL
+#ifdef OS_LINUX
     struct epoll_event *events;
-    int timeout;  //in milliseconds
+    int timeout_ms;   //for epoll
-#elif IOEVENT_USE_URING
+#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;
@@ -104,17 +111,11 @@ typedef struct ioevent_puller {
     timespec_t timeout;
 #endif
 
-#ifdef OS_LINUX
-    bool zero_timeout;
-#endif
-
 } IOEventPoller;
 
-#if IOEVENT_USE_EPOLL
+#if OS_LINUX
   #define IOEVENT_GET_EVENTS(ioevent, index) \
       (ioevent)->events[index].events
-#elif IOEVENT_USE_URING
-
 #elif IOEVENT_USE_KQUEUE
   #define IOEVENT_GET_EVENTS(ioevent, index)  kqueue_ev_convert( \
       (ioevent)->events[index].filter, (ioevent)->events[index].flags)
@@ -125,11 +126,9 @@ 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_URING
-
 #elif IOEVENT_USE_KQUEUE
   #define IOEVENT_GET_DATA(ioevent, index)  \
       (ioevent)->events[index].udata
@@ -140,11 +139,9 @@ 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_URING
-
 #elif IOEVENT_USE_KQUEUE
   #define IOEVENT_CLEAR_DATA(ioevent, index)  \
       (ioevent)->events[index].udata = NULL
@@ -160,7 +157,8 @@ extern "C" {
 #endif
 
 int ioevent_init(IOEventPoller *ioevent, const char *service_name,
-        const int size, const int timeout_ms, const int extra_events);
+        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,
@@ -174,16 +172,24 @@ 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;
+#if IOEVENT_USE_URING
-  ioevent->timeout.tv_nsec = 1000000 * (timeout_ms % 1000);
+    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
-
 }
 
 static inline int ioevent_poll_ex(IOEventPoller *ioevent, const int timeout_ms)

src/ioevent_loop.c

@@ -18,7 +18,7 @@
 #include "ioevent_loop.h"
 
 #if IOEVENT_USE_URING
-static int ioevent_process(IOEventPoller *ioevent)
+static int ioevent_process_by_uring(IOEventPoller *ioevent)
 {
     int result;
     unsigned head;
@@ -85,7 +85,7 @@ static int ioevent_process(IOEventPoller *ioevent)
     return 0;
 }
 
-#else
+#endif
 
 static void deal_ioevents(IOEventPoller *ioevent)
 {
@@ -109,7 +109,7 @@ static void deal_ioevents(IOEventPoller *ioevent)
 	}
 }
 
-static int ioevent_process(IOEventPoller *ioevent)
+static int ioevent_process_by_poll(IOEventPoller *ioevent)
 {
     int result;
 
@@ -130,8 +130,6 @@ static int ioevent_process(IOEventPoller *ioevent)
     return 0;
 }
 
-#endif
-
 static void deal_timeouts(FastTimerEntry *head)
 {
 	FastTimerEntry *entry;
@@ -147,10 +145,7 @@ static void deal_timeouts(FastTimerEntry *head)
         /* 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);
-		}
 	}
 }
 
@@ -206,20 +201,38 @@ int ioevent_loop(struct nio_thread_data *thread_data,
 #endif
 
 #if IOEVENT_USE_URING
-        if (thread_data->ev_puller.submit_count > 0) {
+        if (thread_data->ev_puller.use_io_uring) {
-            if ((result=ioevent_uring_submit(&thread_data->ev_puller)) != 0) {
+            if (thread_data->ev_puller.submit_count > 0) {
-                logError("file: "__FILE__", line: %d, "
+                if ((result=ioevent_uring_submit(&thread_data->
-                        "io_uring_submit fail, errno: %d, error info: %s",
+                                ev_puller)) != 0)
-                        __LINE__, result, STRERROR(result));
+                {
-                return result;
+                    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 ((result=ioevent_process(&thread_data->ev_puller)) != 0) {
+#if IOEVENT_USE_URING
-                return result;
+            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) {
@@ -227,7 +240,7 @@ int ioevent_loop(struct nio_thread_data *thread_data,
         }
 
 		if (thread_data->deleted_list != NULL) {
-			count = 0;
+			//count = 0;
 			while (thread_data->deleted_list != NULL) {
 				task = thread_data->deleted_list;
 				thread_data->deleted_list = task->next;
@@ -241,7 +254,7 @@ int ioevent_loop(struct nio_thread_data *thread_data,
                     }
                 }
 				clean_up_callback(task);
-				count++;
+				//count++;
 			}
 			//logInfo("cleanup task count: %d", count);
 		}
@@ -280,7 +293,7 @@ int ioevent_loop(struct nio_thread_data *thread_data,
 
 int ioevent_set(struct fast_task_info *task, struct nio_thread_data *pThread,
         int sock, short event, IOEventCallback callback,
-        const int timeout, const bool use_iouring)
+        const int timeout)
 {
 	int result;
 
@@ -288,7 +301,7 @@ int ioevent_set(struct fast_task_info *task, struct nio_thread_data *pThread,
 	task->event.fd = sock;
 	task->event.callback = callback;
 #if IOEVENT_USE_URING
-    if (use_iouring) {
+    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, "

src/ioevent_loop.h

@@ -36,7 +36,7 @@ int ioevent_loop(struct nio_thread_data *thread_data,
 
 int ioevent_set(struct fast_task_info *task, struct nio_thread_data *pThread,
         int sock, short event, IOEventCallback callback,
-        const int timeout, const bool use_iouring);
+        const int timeout);
 
 int ioevent_reset(struct fast_task_info *task, int new_fd, short event);
 

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;
@@ -66,7 +67,7 @@ int fast_multi_sock_client_init_ex(FastMultiSockClient *client,
     }
 
     if ((result=ioevent_init(&client->ioevent, "client",
-                    entry_count, timeout_ms, 0)) != 0)
+                    use_io_uring, entry_count, timeout_ms, 0)) != 0)
     {
         logError("file: "__FILE__", line: %d, "
                 "ioevent_init fail, errno: %d, error info: %s",

src/shared_func.h

@@ -1636,16 +1636,29 @@ static inline int fc_ltostr_ex(int64_t n, char *buff, const int padding_len)
         return len;
     }
 
+#if defined(OS_LINUX) && defined(__GNUC__) && __GNUC__ >= 8
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wstringop-overflow"
+#endif
+
     fill_len = padding_len - len;
     memmove(buff + fill_len, buff, len + 1);
     memset(buff, '0', fill_len);
+
+#if defined(OS_LINUX) && defined(__GNUC__) && __GNUC__ >= 8
+#pragma GCC diagnostic pop
+#endif
+
     return padding_len;
 }
 
 static inline int fc_ltostr(int64_t n, char *buff)
 {
-    const int padding_len = 0;
+    int len;
-    return fc_ltostr_ex(n, buff, padding_len);
+
+    len = fc_itoa(n, buff);
+    *(buff + len) = '\0';
+    return len;
 }
 
 static inline size_t fc_strlcpy(char *dest, const char *src, const size_t size)