Apply the review findings to the revoke path.

Only a created record is revoked, so the insert contract no longer calls the failed SYN-ACK an accepted trade-off; guard the backward shift against copying a slot onto itself and guard the 1 Hz delta the same way the flow-map block does.

Author: jfb8856606

freebsd/netinet/tcp_syncache.c

@@ -1899,11 +1899,11 @@ syncache_add(struct in_conninfo *inc, struct tcpopt *to, struct tcphdr *th,
 		TCPSTAT_INC(tcps_sndacks);
 		TCPSTAT_INC(tcps_sndtotal);
 	} else {
-		/* A1 trade-off: the four-tuple was recorded by the admission, so a
-		 * SYN-ACK that never went out leaves a "this generation" record for
-		 * a connection that was not established. The impact is bounded: the
-		 * client only retransmits the pure SYN, which the dispatcher keeps
-		 * locally anyway. */
+		/* The admission above recorded the four-tuple, so undo it here:
+		 * a leftover record would claim the client\'s retransmissions for
+		 * a connection this generation cannot complete, and the draining
+		 * generation\'s own half-open entry would never see them. A
+		 * duplicate four-tuple belongs to an earlier SYN and stays. */
 		V_syncache_synack_fail++;
 		if (created)
 			syncache_flow_map_revoke(sc);

lib/ff_dpdk_if.c

@@ -3522,8 +3522,8 @@ ff_reload_plane_housekeeping(uint64_t now_tsc)
         uint64_t synack_fail = 0, ack_mismatch = 0, inserted = 0, dup = 0;
 
         ff_syncache_counters(&synack_fail, &ack_mismatch);
-        if (synack_fail > last_synack_fail
-            || ack_mismatch > last_ack_mismatch) {
+        if (synack_fail != last_synack_fail
+            || ack_mismatch != last_ack_mismatch) {
             ff_flow_map_stats2(&inserted, &dup, NULL, NULL, NULL, NULL, NULL,
                 NULL);
             ff_log(FF_LOG_WARNING, FF_LOGTYPE_FSTACK_LIB,

lib/ff_flow_map.c

@@ -205,10 +205,12 @@ ff_flow_map_revoke(const struct ff_flow_key *key)
         d_home = (home - hole) & mask;
         if (d_home >= 1 && d_home <= ((j - hole) & mask))
             continue;
-        memcpy(&t[hole].key, &t[j].key, sizeof(t[j].key));
-        t[hole].hash = t[j].hash;
-        t[hole].state = FF_FLOW_SLOT_USED;
-        hole = j;
+        if (hole != j) {
+            memcpy(&t[hole].key, &t[j].key, sizeof(t[j].key));
+            t[hole].hash = t[j].hash;
+            t[hole].state = FF_FLOW_SLOT_USED;
+            hole = j;
+        }
     }
     t[hole].state = FF_FLOW_SLOT_EMPTY;
     g_revoked++;

lib/ff_flow_map.h

@@ -88,9 +88,9 @@ int ff_flow_map_revoke(const struct ff_flow_key *key);
  * never takes any stack lock (it runs under NET_EPOCH with the inp/syncache
  * locks already dropped).
  * Returns 0 recorded, 1 already present, <0 on error / table full.
- * The entry is visible to ff_flow_map_lookup() right away: a SYN-ACK that
- * fails to go out therefore leaves a record for a connection that was never
- * established, which is the accepted trade-off of the single-phase form. */
+ * The entry is visible to ff_flow_map_lookup() right away. A SYN-ACK that
+ * fails to go out is undone by the caller through ff_flow_map_revoke(),
+ * which is why admit() also reports whether it created the record. */
 int ff_flow_map_insert(const struct ff_flow_key *key);
 
 /* Counters for ff_top / drain observability; any output pointer may be NULL. */

tests/integration/common/orphan_capture_analyze.py

@@ -55,6 +55,8 @@ def packets(path):
         ts_sec, ts_frac, caplen, _origlen = struct.unpack(
             endian + "IIII", blob[off:off + 16])
         off += 16
+        if (caplen == 0 or off + caplen > n):
+            break
         data = blob[off:off + caplen]
         off += caplen
         yield linktype, ts_sec + (ts_frac / 1e9 if nano else ts_frac / 1e6), data
@@ -117,7 +119,7 @@ def main(argv):
             continue
         cur = live.get(cport)
         if from_client and flags & SYN and not flags & ACK:
-            if cur is not None and cur.isn == seq and not cur.synack:
+            if cur is not None and cur.isn == seq:
                 cur.retrans += 1                  # the SYN was retried
                 continue
             if cur is not None:

tests/integration/test_ff_dpdk_if_integration.c

@@ -151,6 +151,8 @@ int   ff_socket(int d, int t, int p) { (void)d;(void)t;(void)p; return -1; }
 int ff_socket_snd_pending(void) { return 0; }
 int ff_socket_drain_count(void) { return 0; }
 int ff_syncache_count(void) { return 0; }
+void  ff_syncache_counters(uint64_t *a, uint64_t *b)
+{ if (a) *a = 0; if (b) *b = 0; }
 int   ff_ioctl_freebsd(int f, unsigned long r, ...) { (void)f;(void)r; return -1; }
 int   ff_close(int f) { (void)f; return 0; }
 int   ff_rtioctl(int f, void *d, unsigned int *l, unsigned int al)

tests/integration/test_ff_gendir_mp_integration.c

@@ -194,6 +194,8 @@ int   ff_socket(int d, int t, int p) { (void)d;(void)t;(void)p; return -1; }
 int   ff_socket_snd_pending(void) { return 0; }
 int   ff_socket_drain_count(void) { return 0; }
 int   ff_syncache_count(void) { return 0; }
+void  ff_syncache_counters(uint64_t *a, uint64_t *b)
+{ if (a) *a = 0; if (b) *b = 0; }
 int   ff_ioctl_freebsd(int f, unsigned long r, ...) { (void)f;(void)r; return -1; }
 int   ff_close(int f) { (void)f; return 0; }
 int   ff_rtioctl(int f, void *d, unsigned int *l, unsigned int al)