Added the -Wextra compilation option and fixed compilation errors.

jfb8856606 · jfb8856606 · commit 9c996a6d1934 · 2025-10-29T19:58:45.000+08:00
diff --git a/lib/Makefile b/lib/Makefile
@@ -62,7 +62,7 @@ endif
 
 PKGCONF ?= pkg-config
 
-DPDK_CFLAGS= -Wall -Wno-deprecated-declarations -Werror $(shell $(PKGCONF) --cflags libdpdk)
+DPDK_CFLAGS= -Wall -Wextra -Wno-deprecated-declarations -Werror $(shell $(PKGCONF) --cflags libdpdk)
 
 KERNPREINCLUDES:= ${INCLUDES}
 INCLUDES= -I${OVERRIDE_INCLUDES_ROOT} ${KERNPREINCLUDES}
diff --git a/lib/ff_config.c b/lib/ff_config.c
@@ -71,7 +71,7 @@ static int
 parse_lcore_mask(struct ff_config *cfg, const char *coremask)
 {
     int i, j, idx = 0, shift = 0, zero_num = 0;
-    unsigned count = 0;
+    int count = 0;
     char c;
     int val;
     uint16_t *proc_lcore;
@@ -121,7 +121,7 @@ parse_lcore_mask(struct ff_config *cfg, const char *coremask)
                     snprintf(buf, sizeof(buf) - 1, "%llx%s",
                         (unsigned long long)1<<shift, zero);
                     cfg->dpdk.proc_mask = strdup(buf);
-		}
+        }
                 count++;
             }
         }
@@ -857,7 +857,7 @@ bond_cfg_handler(struct ff_config *cfg, const char *section,
 }
 
 static int
-rss_tbl_cfg_handler(struct ff_config *cfg, struct ff_rss_check_cfg *cur)
+rss_tbl_cfg_handler(struct ff_rss_check_cfg *cur)
 {
     //vip cfg
     int ret, nb_rss_tbl, i, j, k;
@@ -900,7 +900,7 @@ rss_tbl_cfg_handler(struct ff_config *cfg, struct ff_rss_check_cfg *cur)
 }
 
 static int
-rss_check_cfg_handler(struct ff_config *cfg, const char *section,
+rss_check_cfg_handler(struct ff_config *cfg, __rte_unused const char *section,
     const char *name, const char *value)
 {
     if (cfg->dpdk.port_cfgs == NULL && cfg->dpdk.vlan_cfgs == NULL) {
@@ -924,7 +924,7 @@ rss_check_cfg_handler(struct ff_config *cfg, const char *section,
     } else if (strcmp(name, "rss_tbl") == 0) {
         cur->rss_tbl_str = strdup(value);
         if (cur->rss_tbl_str) {
-            return rss_tbl_cfg_handler(cfg, cur);
+            return rss_tbl_cfg_handler(cur);
         }
     }
 
diff --git a/lib/ff_config.h b/lib/ff_config.h
@@ -241,7 +241,7 @@ struct ff_rss_tbl_cfg {
 
 struct ff_rss_check_cfg {
     int enable;
-    uint32_t nb_rss_tbl;
+    int nb_rss_tbl;
     char *rss_tbl_str;
     struct ff_rss_tbl_cfg rss_tbl_cfgs[FF_RSS_TBL_MAX_ENTRIES];
 };
diff --git a/lib/ff_dpdk_if.c b/lib/ff_dpdk_if.c
@@ -572,7 +572,7 @@ set_rss_table(uint16_t port_id, uint16_t reta_size, uint16_t nb_queues)
         return;
     }
 
-    int reta_conf_size = RTE_MAX(1, reta_size / RTE_ETH_RETA_GROUP_SIZE);
+    unsigned reta_conf_size = RTE_MAX(1, reta_size / RTE_ETH_RETA_GROUP_SIZE);
     struct rte_eth_rss_reta_entry64 reta_conf[reta_conf_size];
 
     /* config HW indirection table */
@@ -2249,9 +2249,9 @@ main_loop(void *arg)
 
                 ff_get_current_time(&sec, &nsec);
                 if (sec > last_sec) {
-                    if (kni_rate_limt.gerneal_packets > ff_global_cfg.kni.general_packets_ratelimit ||
-                        kni_rate_limt.console_packets > ff_global_cfg.kni.console_packets_ratelimit ||
-                        kni_rate_limt.kernel_packets > ff_global_cfg.kni.kernel_packets_ratelimit) {
+                    if (kni_rate_limt.gerneal_packets > (uint64_t)ff_global_cfg.kni.general_packets_ratelimit ||
+                        kni_rate_limt.console_packets > (uint64_t)ff_global_cfg.kni.console_packets_ratelimit ||
+                        kni_rate_limt.kernel_packets > (uint64_t)ff_global_cfg.kni.kernel_packets_ratelimit) {
                         printf("kni ratelimit, general:%lu/%d, console:%lu/%d, kernel:%lu/%d, last sec:%ld, sec:%ld\n",
                             kni_rate_limt.gerneal_packets, ff_global_cfg.kni.general_packets_ratelimit,
                             kni_rate_limt.console_packets, ff_global_cfg.kni.console_packets_ratelimit,
diff --git a/lib/ff_dpdk_kni.c b/lib/ff_dpdk_kni.c
@@ -143,7 +143,7 @@ kni_set_bitmap(const char *p, unsigned char *port_bitmap)
 #ifdef FF_KNI_KNI
 /* Currently we don't support change mtu. */
 static int
-kni_change_mtu(uint16_t port_id, unsigned new_mtu)
+kni_change_mtu(__rte_unused uint16_t port_id, __rte_unused unsigned new_mtu)
 {
     return 0;
 }
@@ -213,7 +213,7 @@ kni_config_mac_address(uint16_t port_id, uint8_t mac_addr[])
 #endif
 
 static int
-kni_process_tx(uint16_t port_id, uint16_t queue_id,
+kni_process_tx(uint16_t port_id, __rte_unused uint16_t queue_id,
     struct rte_mbuf **pkts_burst, unsigned count)
 {
     /* read packet from kni ring(phy port) and transmit to kni */
@@ -225,7 +225,7 @@ kni_process_tx(uint16_t port_id, uint16_t queue_id,
      * If there are too many processes, there is also the possibility that the control packet will be ratelimited.
      */
     if (ff_global_cfg.kni.kernel_packets_ratelimit) {
-        if (likely(kni_rate_limt.kernel_packets < ff_global_cfg.kni.kernel_packets_ratelimit)) {
+        if (likely(kni_rate_limt.kernel_packets < (uint64_t)ff_global_cfg.kni.kernel_packets_ratelimit)) {
             nb_to_tx = nb_tx;
         } else {
             nb_to_tx = 0;
@@ -526,8 +526,8 @@ ff_kni_init(uint16_t nb_ports, int type, const char *tcp_ports, const char *udp_
 }
 
 void
-ff_kni_alloc(uint16_t port_id, unsigned socket_id, int type, int port_idx,
-    struct rte_mempool *mbuf_pool, unsigned ring_queue_size)
+ff_kni_alloc(uint16_t port_id, unsigned socket_id, __rte_unused int type, int port_idx,
+    __rte_unused struct rte_mempool *mbuf_pool, unsigned ring_queue_size)
 {
     if (rte_eal_process_type() == RTE_PROC_PRIMARY) {
         struct rte_ether_addr addr = {{0}};
@@ -644,14 +644,14 @@ ff_kni_enqueue(enum FilterReturn filter, uint16_t port_id, struct rte_mbuf *pkt)
     if (filter >= FILTER_ARP) {
         if (ff_global_cfg.kni.console_packets_ratelimit) {
             kni_rate_limt.console_packets++;
-            if (kni_rate_limt.console_packets > ff_global_cfg.kni.console_packets_ratelimit) {
+            if (kni_rate_limt.console_packets > (uint64_t)ff_global_cfg.kni.console_packets_ratelimit) {
                 goto error;
             }
         }
     } else {
         if (ff_global_cfg.kni.general_packets_ratelimit) {
             kni_rate_limt.gerneal_packets++;
-            if (kni_rate_limt.gerneal_packets > ff_global_cfg.kni.general_packets_ratelimit) {
+            if (kni_rate_limt.gerneal_packets > (uint64_t)ff_global_cfg.kni.general_packets_ratelimit) {
                 goto error;
             }
         }
diff --git a/lib/ff_epoll.c b/lib/ff_epoll.c
@@ -103,7 +103,7 @@ ff_epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
     return ff_kevent(epfd, kev, changes, NULL, 0, NULL);
 }
 
-static void 
+static void
 ff_event_to_epoll(void **ev, struct kevent *kev)
 {
     unsigned int event_one = 0;
@@ -144,10 +144,11 @@ ff_event_to_epoll(void **ev, struct kevent *kev)
     (*ppev)++;
 }
 
-int 
+int
 ff_epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)
 {
     int i, ret;
+    (void)timeout;
     if (!events || maxevents < 1) {
         errno = EINVAL;
         return -1;
diff --git a/lib/ff_host_interface.c b/lib/ff_host_interface.c
@@ -76,7 +76,7 @@ ff_mmap(void *addr, uint64_t len, int prot, int flags, int fd, uint64_t offset)
 
     void *ret = (mmap(addr, len, host_prot, host_flags, fd, offset));
 
-    if ((uint64_t)ret == -1) {
+    if (ret == MAP_FAILED) {
         printf("fst mmap failed:%s\n", strerror(errno));
         exit(1);
     }
@@ -271,10 +271,10 @@ void ff_os_errno(int error)
         case ff_EPIPE:       errno = EPIPE; break;
         case ff_EDOM:        errno = EDOM; break;
         case ff_ERANGE:      errno = ERANGE; break;
-    
+
         /* case ff_EAGAIN:       same as EWOULDBLOCK */
         case ff_EWOULDBLOCK:     errno = EWOULDBLOCK; break;
-    
+
         case ff_EINPROGRESS:     errno = EINPROGRESS; break;
         case ff_EALREADY:        errno = EALREADY; break;
         case ff_ENOTSOCK:        errno = ENOTSOCK; break;

Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ static int`
`71`	`71`	`parse_lcore_mask(struct ff_config cfg, const char coremask)`
`72`	`72`	`{`
`73`	`73`	`int i, j, idx = 0, shift = 0, zero_num = 0;`
`74`		`- unsigned count = 0;`
	`74`	`+ int count = 0;`
`75`	`75`	`char c;`
`76`	`76`	`int val;`
`77`	`77`	`uint16_t *proc_lcore;`
`@@ -121,7 +121,7 @@ parse_lcore_mask(struct ff_config cfg, const char coremask)`
`121`	`121`	`snprintf(buf, sizeof(buf) - 1, "%llx%s",`
`122`	`122`	`(unsigned long long)1<<shift, zero);`
`123`	`123`	`cfg->dpdk.proc_mask = strdup(buf);`
`124`		`- }`
	`124`	`+ }`
`125`	`125`	`count++;`
`126`	`126`	`}`
`127`	`127`	`}`
`@@ -857,7 +857,7 @@ bond_cfg_handler(struct ff_config cfg, const char section,`
`857`	`857`	`}`
`858`	`858`
`859`	`859`	`static int`
`860`		`-rss_tbl_cfg_handler(struct ff_config cfg, struct ff_rss_check_cfg cur)`
	`860`	`+rss_tbl_cfg_handler(struct ff_rss_check_cfg *cur)`
`861`	`861`	`{`
`862`	`862`	`//vip cfg`
`863`	`863`	`int ret, nb_rss_tbl, i, j, k;`
`@@ -900,7 +900,7 @@ rss_tbl_cfg_handler(struct ff_config cfg, struct ff_rss_check_cfg cur)`
`900`	`900`	`}`
`901`	`901`
`902`	`902`	`static int`
`903`		`-rss_check_cfg_handler(struct ff_config cfg, const char section,`
	`903`	`+rss_check_cfg_handler(struct ff_config cfg, __rte_unused const char section,`
`904`	`904`	`const char name, const char value)`
`905`	`905`	`{`
`906`	`906`	`if (cfg->dpdk.port_cfgs == NULL && cfg->dpdk.vlan_cfgs == NULL) {`
`@@ -924,7 +924,7 @@ rss_check_cfg_handler(struct ff_config cfg, const char section,`
`924`	`924`	`} else if (strcmp(name, "rss_tbl") == 0) {`
`925`	`925`	`cur->rss_tbl_str = strdup(value);`
`926`	`926`	`if (cur->rss_tbl_str) {`
`927`		`- return rss_tbl_cfg_handler(cfg, cur);`
	`927`	`+ return rss_tbl_cfg_handler(cur);`
`928`	`928`	`}`
`929`	`929`	`}`
`930`	`930`
Original file line number	Diff line number	Diff line change
`@@ -143,7 +143,7 @@ kni_set_bitmap(const char p, unsigned char port_bitmap)`
`143`	`143`	`#ifdef FF_KNI_KNI`
`144`	`144`	`/* Currently we don't support change mtu. */`
`145`	`145`	`static int`
`146`		`-kni_change_mtu(uint16_t port_id, unsigned new_mtu)`
	`146`	`+kni_change_mtu(__rte_unused uint16_t port_id, __rte_unused unsigned new_mtu)`
`147`	`147`	`{`
`148`	`148`	`return 0;`
`149`	`149`	`}`
`@@ -213,7 +213,7 @@ kni_config_mac_address(uint16_t port_id, uint8_t mac_addr[])`
`213`	`213`	`#endif`
`214`	`214`
`215`	`215`	`static int`
`216`		`-kni_process_tx(uint16_t port_id, uint16_t queue_id,`
	`216`	`+kni_process_tx(uint16_t port_id, __rte_unused uint16_t queue_id,`
`217`	`217`	`struct rte_mbuf **pkts_burst, unsigned count)`
`218`	`218`	`{`
`219`	`219`	`/* read packet from kni ring(phy port) and transmit to kni */`
`@@ -225,7 +225,7 @@ kni_process_tx(uint16_t port_id, uint16_t queue_id,`
`225`	`225`	`* If there are too many processes, there is also the possibility that the control packet will be ratelimited.`
`226`	`226`	`*/`
`227`	`227`	`if (ff_global_cfg.kni.kernel_packets_ratelimit) {`
`228`		`- if (likely(kni_rate_limt.kernel_packets < ff_global_cfg.kni.kernel_packets_ratelimit)) {`
	`228`	`+ if (likely(kni_rate_limt.kernel_packets < (uint64_t)ff_global_cfg.kni.kernel_packets_ratelimit)) {`
`229`	`229`	`nb_to_tx = nb_tx;`
`230`	`230`	`} else {`
`231`	`231`	`nb_to_tx = 0;`
`@@ -526,8 +526,8 @@ ff_kni_init(uint16_t nb_ports, int type, const char tcp_ports, const char udp_`
`526`	`526`	`}`
`527`	`527`
`528`	`528`	`void`
`529`		`-ff_kni_alloc(uint16_t port_id, unsigned socket_id, int type, int port_idx,`
`530`		`- struct rte_mempool *mbuf_pool, unsigned ring_queue_size)`
	`529`	`+ff_kni_alloc(uint16_t port_id, unsigned socket_id, __rte_unused int type, int port_idx,`
	`530`	`+ __rte_unused struct rte_mempool *mbuf_pool, unsigned ring_queue_size)`
`531`	`531`	`{`
`532`	`532`	`if (rte_eal_process_type() == RTE_PROC_PRIMARY) {`
`533`	`533`	`struct rte_ether_addr addr = {{0}};`
`@@ -644,14 +644,14 @@ ff_kni_enqueue(enum FilterReturn filter, uint16_t port_id, struct rte_mbuf *pkt)`
`644`	`644`	`if (filter >= FILTER_ARP) {`
`645`	`645`	`if (ff_global_cfg.kni.console_packets_ratelimit) {`
`646`	`646`	`kni_rate_limt.console_packets++;`
`647`		`- if (kni_rate_limt.console_packets > ff_global_cfg.kni.console_packets_ratelimit) {`
	`647`	`+ if (kni_rate_limt.console_packets > (uint64_t)ff_global_cfg.kni.console_packets_ratelimit) {`
`648`	`648`	`goto error;`
`649`	`649`	`}`
`650`	`650`	`}`
`651`	`651`	`} else {`
`652`	`652`	`if (ff_global_cfg.kni.general_packets_ratelimit) {`
`653`	`653`	`kni_rate_limt.gerneal_packets++;`
`654`		`- if (kni_rate_limt.gerneal_packets > ff_global_cfg.kni.general_packets_ratelimit) {`
	`654`	`+ if (kni_rate_limt.gerneal_packets > (uint64_t)ff_global_cfg.kni.general_packets_ratelimit) {`
`655`	`655`	`goto error;`
`656`	`656`	`}`
`657`	`657`	`}`
Original file line number	Diff line number	Diff line change
`@@ -103,7 +103,7 @@ ff_epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)`
`103`	`103`	`return ff_kevent(epfd, kev, changes, NULL, 0, NULL);`
`104`	`104`	`}`
`105`	`105`
`106`		`-static void`
	`106`	`+static void`
`107`	`107`	`ff_event_to_epoll(void *ev, struct kevent kev)`
`108`	`108`	`{`
`109`	`109`	`unsigned int event_one = 0;`
`@@ -144,10 +144,11 @@ ff_event_to_epoll(void *ev, struct kevent kev)`
`144`	`144`	`(*ppev)++;`
`145`	`145`	`}`
`146`	`146`
`147`		`-int`
	`147`	`+int`
`148`	`148`	`ff_epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)`
`149`	`149`	`{`
`150`	`150`	`int i, ret;`
	`151`	`+ (void)timeout;`
`151`	`152`	`if (!events \|\| maxevents < 1) {`
`152`	`153`	`errno = EINVAL;`
`153`	`154`	`return -1;`