XDP-TCP: rename prefix 'knot_xdp_tcp' to 'knot_tcp', and 'knot_tcp_timeout' to 'knot_...

diff --git a/distro/pkg/deb/libknot11.symbols b/distro/pkg/deb/libknot11.symbols
index 00b15d07a11f6c9421b836b50674c55efb3e70ff..bd64c18b0926c480dbb8c07b57ea880aaf02cc55 100644 (file)
--- a/distro/pkg/deb/libknot11.symbols
+++ b/distro/pkg/deb/libknot11.symbols
@@ -188,8 +188,8 @@ libknot.so.11 libknot11 #MINVER#
  knot_xdp_send_free@Base 3.1.0
  knot_xdp_send_prepare@Base 3.0.0
  knot_xdp_socket_fd@Base 3.0.0
- knot_xdp_tcp_relay@Base 3.1.0
- knot_xdp_tcp_send@Base 3.1.0
+ knot_tcp_relay@Base 3.1.0
+ knot_tcp_send@Base 3.1.0
  yp_addr@Base 3.0.0
  yp_addr_noport@Base 3.0.0
  yp_addr_noport_to_bin@Base 3.0.0

diff --git a/src/knot/server/xdp-handler.c b/src/knot/server/xdp-handler.c
index bd2ff092a0d1a1c48dff9e950b53e51f9def2d8e..1837edd54e75c59426bf657742d856b386b3a3df 100644 (file)
--- a/src/knot/server/xdp-handler.c
+++ b/src/knot/server/xdp-handler.c
@@ -175,7 +175,7 @@ int xdp_handle_msgs(xdp_handle_ctx_t *ctx, knot_xdp_socket_t *sock,
        }
 
        // handle TCP messages
-       int ret = knot_xdp_tcp_relay(sock, ctx->msg_recv, ctx->msg_recv_count, ctx->tcp_table, NULL, &ctx->tcp_relays);
+       int ret = knot_tcp_relay(sock, ctx->msg_recv, ctx->msg_recv_count, ctx->tcp_table, NULL, &ctx->tcp_relays);
        if (ret == KNOT_EOK && ctx->tcp_relays.size > 0) {
                uint8_t ans_buf[KNOT_WIRE_MAX_PKTSIZE];
 
@@ -191,7 +191,7 @@ int xdp_handle_msgs(xdp_handle_ctx_t *ctx, knot_xdp_socket_t *sock,
                                                continue;
                                        }
 
-                                       ret = knot_xdp_tcp_send_data(&ctx->tcp_relays, rl, ans->wire, ans->size);
+                                       ret = knot_tcp_send_data(&ctx->tcp_relays, rl, ans->wire, ans->size);
                                        if (ret != KNOT_EOK) {
                                                layer->state = KNOT_STATE_FAIL;
                                        }
@@ -220,13 +220,13 @@ int xdp_handle_send(xdp_handle_ctx_t *ctx, knot_xdp_socket_t *xdp_sock)
        int ret = knot_xdp_send(xdp_sock, ctx->msg_send_udp, ctx->msg_udp_count, &unused);
        if (ret == KNOT_EOK) {
                if (ctx->tcp_relays.size > 0) {
-                       ret = knot_xdp_tcp_send(xdp_sock, knot_tcp_relay_dynarray_arr(&ctx->tcp_relays), ctx->tcp_relays.size);
+                       ret = knot_tcp_send(xdp_sock, knot_tcp_relay_dynarray_arr(&ctx->tcp_relays), ctx->tcp_relays.size);
                } else {
                        ret = knot_xdp_send_finish(xdp_sock);
                }
        }
 
-       knot_xdp_tcp_relay_free(&ctx->tcp_relays);
+       knot_tcp_relay_free(&ctx->tcp_relays);
 
        if (ret == KNOT_EOK) {
                ret = xdp_handle_timeout(ctx, xdp_sock);
@@ -240,10 +240,10 @@ int xdp_handle_timeout(xdp_handle_ctx_t *ctx, knot_xdp_socket_t *xdp_sock)
        uint32_t last_reset = 0, last_close = 0;
        int ret = KNOT_EOK;
        do {
-               ret = knot_xdp_tcp_timeout(ctx->tcp_table, xdp_sock, 20, ctx->tcp_idle_close, ctx->tcp_idle_reset,
-                                          overweight(ctx->tcp_table->usage, ctx->tcp_max_conns),
-                                          overweight(ctx->tcp_table->inbufs_total, ctx->tcp_max_inbufs),
-                                          &last_close, &last_reset);
+               ret = knot_tcp_sweep(ctx->tcp_table, xdp_sock, 20, ctx->tcp_idle_close, ctx->tcp_idle_reset,
+                                    overweight(ctx->tcp_table->usage, ctx->tcp_max_conns),
+                                    overweight(ctx->tcp_table->inbufs_total, ctx->tcp_max_inbufs),
+                                    &last_close, &last_reset);
        } while (last_reset > 0 && ret == KNOT_EOK);
 
        if (last_close > 0 || last_reset > 0) {

diff --git a/src/libknot/xdp/tcp.c b/src/libknot/xdp/tcp.c
index 49c7081a32946fdaa7f12da0e93b5a40ff6d47b4..7f4f0f0fa0c9941ccdfcf33206b6ada884eb7687 100644 (file)
--- a/src/libknot/xdp/tcp.c
+++ b/src/libknot/xdp/tcp.c
@@ -198,9 +198,9 @@ static bool check_seq_ack(const knot_xdp_msg_t *msg, const knot_tcp_conn_t *conn
 }
 
 _public_
-int knot_xdp_tcp_relay(knot_xdp_socket_t *socket, knot_xdp_msg_t msgs[], uint32_t msg_count,
-                       knot_tcp_table_t *tcp_table, knot_tcp_table_t *syn_table,
-                       knot_tcp_relay_dynarray_t *relays)
+int knot_tcp_relay(knot_xdp_socket_t *socket, knot_xdp_msg_t msgs[], uint32_t msg_count,
+                   knot_tcp_table_t *tcp_table, knot_tcp_table_t *syn_table,
+                   knot_tcp_relay_dynarray_t *relays)
 {
        if (msg_count == 0) {
                return KNOT_EOK;
@@ -371,8 +371,8 @@ int knot_xdp_tcp_relay(knot_xdp_socket_t *socket, knot_xdp_msg_t msgs[], uint32_
 }
 
 _public_
-int knot_xdp_tcp_send_data(knot_tcp_relay_dynarray_t *relays, const knot_tcp_relay_t *relay,
-                           void *data, size_t data_len)
+int knot_tcp_send_data(knot_tcp_relay_dynarray_t *relays, const knot_tcp_relay_t *relay,
+                       void *data, size_t data_len)
 {
        if (relays == NULL || relay == NULL || data == NULL) {
                return KNOT_EINVAL;
@@ -412,7 +412,7 @@ int knot_xdp_tcp_send_data(knot_tcp_relay_dynarray_t *relays, const knot_tcp_rel
 }
 
 _public_
-void knot_xdp_tcp_relay_free(knot_tcp_relay_dynarray_t *relays)
+void knot_tcp_relay_free(knot_tcp_relay_dynarray_t *relays)
 {
        if (relays == NULL) {
                return;
@@ -428,8 +428,7 @@ void knot_xdp_tcp_relay_free(knot_tcp_relay_dynarray_t *relays)
 }
 
 _public_
-int knot_xdp_tcp_send(knot_xdp_socket_t *socket, knot_tcp_relay_t relays[],
-                      uint32_t relay_count)
+int knot_tcp_send(knot_xdp_socket_t *socket, knot_tcp_relay_t relays[], uint32_t relay_count)
 {
        if (relay_count == 0) {
                return KNOT_EOK;
@@ -520,11 +519,10 @@ int knot_xdp_tcp_send(knot_xdp_socket_t *socket, knot_tcp_relay_t relays[],
 }
 
 _public_
-int knot_xdp_tcp_timeout(knot_tcp_table_t *tcp_table, knot_xdp_socket_t *socket,
-                         uint32_t max_at_once,
-                         uint32_t close_timeout, uint32_t reset_timeout,
-                         uint32_t reset_at_least, size_t reset_inbufs,
-                         uint32_t *close_count, uint32_t *reset_count)
+int knot_tcp_sweep(knot_tcp_table_t *tcp_table, knot_xdp_socket_t *socket,
+                   uint32_t max_at_once, uint32_t close_timeout, uint32_t reset_timeout,
+                   uint32_t reset_at_least, size_t reset_buf_size,
+                   uint32_t *close_count, uint32_t *reset_count)
 {
        if (tcp_table == NULL) {
                return KNOT_EINVAL;
@@ -541,14 +539,14 @@ int knot_xdp_tcp_timeout(knot_tcp_table_t *tcp_table, knot_xdp_socket_t *socket,
        WALK_LIST_DELSAFE(conn, next, *tcp_table_timeout(tcp_table)) {
                if (i++ < reset_at_least ||
                    now - conn->last_active >= reset_timeout ||
-                   (reset_inbufs > 0 && conn->inbuf.iov_len > 0)) {
+                   (reset_buf_size > 0 && conn->inbuf.iov_len > 0)) {
                        rl.answer = XDP_TCP_RESET;
 
                        // move this conn into to-remove list
                        rem_node((node_t *)conn);
                        add_tail(&to_remove, (node_t *)conn);
 
-                       reset_inbufs -= MIN(reset_inbufs, conn->inbuf.iov_len);
+                       reset_buf_size -= MIN(reset_buf_size, conn->inbuf.iov_len);
                } else if (now - conn->last_active >= close_timeout) {
                        if (conn->state != XDP_TCP_CLOSING) {
                                rl.answer = XDP_TCP_CLOSE;
@@ -556,7 +554,7 @@ int knot_xdp_tcp_timeout(knot_tcp_table_t *tcp_table, knot_xdp_socket_t *socket,
                                        (*close_count)++;
                                }
                        }
-               } else if (reset_inbufs == 0) {
+               } else if (reset_buf_size == 0) {
                        break;
                }
 
@@ -568,7 +566,7 @@ int knot_xdp_tcp_timeout(knot_tcp_table_t *tcp_table, knot_xdp_socket_t *socket,
        }
 
        if (ret == KNOT_EOK) {
-               ret = knot_xdp_tcp_send(socket, knot_tcp_relay_dynarray_arr(&relays), relays.size);
+               ret = knot_tcp_send(socket, knot_tcp_relay_dynarray_arr(&relays), relays.size);
        }
 
        // immediately remove resetted connections
@@ -581,6 +579,6 @@ int knot_xdp_tcp_timeout(knot_tcp_table_t *tcp_table, knot_xdp_socket_t *socket,
                }
        }
 
-       knot_xdp_tcp_relay_free(&relays);
+       knot_tcp_relay_free(&relays);
        return ret;
 }

diff --git a/src/libknot/xdp/tcp.h b/src/libknot/xdp/tcp.h
index 48c77160fb63dfffaaffdc3b0a60b2dddcd56649..2540e73d431af58520b515dbb0de7cbabd30edb6 100644 (file)
--- a/src/libknot/xdp/tcp.h
+++ b/src/libknot/xdp/tcp.h
@@ -51,7 +51,7 @@ typedef enum {
        XDP_TCP_FREE_PREFIX,
 } knot_tcp_relay_free_t;
 
-typedef struct knot_xdp_tcp_conn {
+typedef struct knot_tcp_conn {
        struct {
                void *list_node_placeholder1;
                void *list_node_placeholder2;
@@ -67,7 +67,7 @@ typedef struct knot_xdp_tcp_conn {
        uint32_t last_active;
        knot_tcp_state_t state;
        struct iovec inbuf;
-       struct knot_xdp_tcp_conn *next;
+       struct knot_tcp_conn *next;
 } knot_tcp_conn_t;
 
 typedef struct {
@@ -134,9 +134,9 @@ void knot_tcp_table_free(knot_tcp_table_t *table);
  *
  * \return KNOT_E*
  */
-int knot_xdp_tcp_relay(knot_xdp_socket_t *socket, knot_xdp_msg_t msgs[], uint32_t msg_count,
-                       knot_tcp_table_t *tcp_table, knot_tcp_table_t *syn_table,
-                       knot_tcp_relay_dynarray_t *relays);
+int knot_tcp_relay(knot_xdp_socket_t *socket, knot_xdp_msg_t msgs[], uint32_t msg_count,
+                   knot_tcp_table_t *tcp_table, knot_tcp_table_t *syn_table,
+                   knot_tcp_relay_dynarray_t *relays);
 
 /*!
  * \brief Answer one relay with one or more relays with data payload.
@@ -148,13 +148,13 @@ int knot_xdp_tcp_relay(knot_xdp_socket_t *socket, knot_xdp_msg_t msgs[], uint32_
  *
  * \return KNOT_EOK, KNOT_ENOMEM
  */
-int knot_xdp_tcp_send_data(knot_tcp_relay_dynarray_t *relays, const knot_tcp_relay_t *relay,
-                           void *data, size_t data_len);
+int knot_tcp_send_data(knot_tcp_relay_dynarray_t *relays, const knot_tcp_relay_t *relay,
+                       void *data, size_t data_len);
 
 /*!
  * \brief Free resources in 'relays'.
  */
-void knot_xdp_tcp_relay_free(knot_tcp_relay_dynarray_t *relays);
+void knot_tcp_relay_free(knot_tcp_relay_dynarray_t *relays);
 
 /*!
  * \brief Send TCP packets.
@@ -165,8 +165,7 @@ void knot_xdp_tcp_relay_free(knot_tcp_relay_dynarray_t *relays);
  *
  * \return KNOT_E*
  */
-int knot_xdp_tcp_send(knot_xdp_socket_t *socket, knot_tcp_relay_t relays[],
-                      uint32_t relay_count);
+int knot_tcp_send(knot_xdp_socket_t *socket, knot_tcp_relay_t relays[], uint32_t relay_count);
 
 /*!
  * \brief Cleanup old TCP connections, perform timeout checks.
@@ -178,17 +177,16 @@ int knot_xdp_tcp_send(knot_xdp_socket_t *socket, knot_tcp_relay_t relays[],
  * \param reset_timeout    Reset connections older than this (usecs).
  * \param reset_at_least   Reset at least this number of oldest conecctions, even
  *                         when not yet timeouted.
- * \param reset_inbufs     Reset oldest connection with buffered partial DNS messages
+ * \param reset_buf_size   Reset oldest connection with buffered partial DNS messages
  *                         to free up this amount of space.
  * \param close_count      Optional: Out: number of closed connections.
  * \param reset_count      Optional: Out: number of reset connections.
  *
  * \return  KNOT_E*
  */
-int knot_xdp_tcp_timeout(knot_tcp_table_t *tcp_table, knot_xdp_socket_t *socket,
-                         uint32_t max_at_once,
-                         uint32_t close_timeout, uint32_t reset_timeout,
-                         uint32_t reset_at_least, size_t reset_inbufs,
-                         uint32_t *close_count, uint32_t *reset_count);
+int knot_tcp_sweep(knot_tcp_table_t *tcp_table, knot_xdp_socket_t *socket,
+                   uint32_t max_at_once, uint32_t close_timeout, uint32_t reset_timeout,
+                   uint32_t reset_at_least, size_t reset_buf_size,
+                   uint32_t *close_count, uint32_t *reset_count);
 
 /*! @} */

diff --git a/src/utils/kxdpgun/main.c b/src/utils/kxdpgun/main.c
index f90cbf4973d8b2cbc71078c7f86bcf732065acd5..a9de6f31a3f96d09de4481cf600ac77bb55f5681 100644 (file)
--- a/src/utils/kxdpgun/main.c
+++ b/src/utils/kxdpgun/main.c
@@ -425,7 +425,7 @@ void *xdp_gun_thread(void *_ctx)
                                }
                                if (ctx->tcp) {
                                        knot_tcp_relay_dynarray_t relays = { 0 };
-                                       ret = knot_xdp_tcp_relay(xsk, pkts, recvd, tcp_table, NULL, &relays);
+                                       ret = knot_tcp_relay(xsk, pkts, recvd, tcp_table, NULL, &relays);
                                        if (ret != KNOT_EOK) {
                                                errors++;
                                                break;
@@ -440,7 +440,7 @@ void *xdp_gun_thread(void *_ctx)
                                                        local_stats.synack_recv++;
                                                        rl->answer = XDP_TCP_ANSWER | XDP_TCP_DATA;
                                                        put_dns_payload(&payl, true, ctx, &payload_ptr);
-                                                       (void)knot_xdp_tcp_send_data(&relays, rl, payl.iov_base, payl.iov_len);
+                                                       (void)knot_tcp_send_data(&relays, rl, payl.iov_base, payl.iov_len);
                                                        break;
                                                case XDP_TCP_DATA:
                                                        if (check_dns_payload(&rl->data, ctx, &local_stats)) {
@@ -458,12 +458,12 @@ void *xdp_gun_thread(void *_ctx)
                                                }
                                        }
 
-                                       ret = knot_xdp_tcp_send(xsk, knot_tcp_relay_dynarray_arr(&relays), relays.size);
+                                       ret = knot_tcp_send(xsk, knot_tcp_relay_dynarray_arr(&relays), relays.size);
                                        if (ret != KNOT_EOK) {
                                                errors++;
                                        }
 
-                                       knot_xdp_tcp_relay_free(&relays);
+                                       knot_tcp_relay_free(&relays);
                                } else {
                                        for (int i = 0; i < recvd; i++) {
                                                (void)check_dns_payload(&pkts[i].payload, ctx, &local_stats);

diff --git a/tests/libknot/test_xdp_tcp.c b/tests/libknot/test_xdp_tcp.c
index b43170e987b79bc0b0b402ce650332adc50efe47..784337eb571e7c60a730403051e70ee7e9cda1fd 100644 (file)
--- a/tests/libknot/test_xdp_tcp.c
+++ b/tests/libknot/test_xdp_tcp.c
@@ -197,7 +197,7 @@ void test_syn(void)
        knot_xdp_msg_t msg;
        knot_tcp_relay_dynarray_t relays = { 0 };
        prepare_msg(&msg, KNOT_XDP_MSG_SYN, 1, 2);
-       int ret = knot_xdp_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
+       int ret = knot_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
        is_int(KNOT_EOK, ret, "SYN: relay OK");
        is_int(msg.seqno + 1, sent_ackno, "SYN: ackno");
        check_sent(0, 0, 1, 0);
@@ -214,7 +214,7 @@ void test_syn(void)
        ok(memcmp(&conn->ip_rem, &msg.ip_from, sizeof(msg.ip_from)) == 0, "SYN: conn IP from");
        ok(memcmp(&conn->ip_loc, &msg.ip_to, sizeof(msg.ip_to)) == 0, "SYN: conn IP to");
 
-       knot_xdp_tcp_relay_free(&relays);
+       knot_tcp_relay_free(&relays);
        test_conn = conn;
 }
 
@@ -224,7 +224,7 @@ void test_establish(void)
        knot_tcp_relay_dynarray_t relays = { 0 };
        prepare_msg(&msg, KNOT_XDP_MSG_ACK, 1, 2);
        prepare_seqack(&msg, 0, 1);
-       int ret = knot_xdp_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
+       int ret = knot_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
        is_int(KNOT_EOK, ret, "establish: relay OK");
        check_sent(0, 0, 0, 0);
        is_int(0, relays.size, "establish: no relay");
@@ -234,7 +234,7 @@ void test_establish(void)
        ok(rl->conn == test_conn, "establish: same connection");
        is_int(XDP_TCP_NORMAL, rl->conn->state, "establish: connection state");*/
 
-       knot_xdp_tcp_relay_free(&relays);
+       knot_tcp_relay_free(&relays);
        clean_table();
 }
 
@@ -243,7 +243,7 @@ void test_syn_ack(void)
        knot_xdp_msg_t msg;
        knot_tcp_relay_dynarray_t relays = { 0 };
        prepare_msg(&msg, KNOT_XDP_MSG_SYN | KNOT_XDP_MSG_ACK, 1000, 2000);
-       int ret = knot_xdp_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
+       int ret = knot_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
        is_int(KNOT_EOK, ret, "SYN+ACK: relay OK");
        is_int(msg.seqno + 1, sent_ackno, "SYN+ACK: ackno");
        check_sent(1, 0, 0, 0);
@@ -253,7 +253,7 @@ void test_syn_ack(void)
        ok(rl->conn != NULL, "SYN+ACK: connection present");
 
        test_conn = rl->conn;
-       knot_xdp_tcp_relay_free(&relays);
+       knot_tcp_relay_free(&relays);
 }
 
 void test_data_fragments(void)
@@ -281,7 +281,7 @@ void test_data_fragments(void)
        prepare_seqack(&msgs[3], 15, 0);
        prepare_data(&msgs[3], "\x02""AB""\xff\xff""abcdefghijklmnopqrstuvwxyz...", 34);
 
-       int ret = knot_xdp_tcp_relay(test_sock, msgs, sizeof(msgs) / sizeof(msgs[0]), test_table, NULL, &relays);
+       int ret = knot_tcp_relay(test_sock, msgs, sizeof(msgs) / sizeof(msgs[0]), test_table, NULL, &relays);
        is_int(KNOT_EOK, ret, "fragments: relay OK");
        is_int(msgs[3].ackno, sent_seqno, "fragments: seqno");
        is_int(msgs[3].seqno + msgs[3].payload.iov_len, sent_ackno, "fragments: ackno");
@@ -310,7 +310,7 @@ void test_data_fragments(void)
        ok(memcmp("AB", rls[3].data.iov_base, rls[3].data.iov_len) == 0, "fragments3: data");
        ok(rls[3].conn == test_conn, "fragments3: same connection");
 
-       knot_xdp_tcp_relay_free(&relays);
+       knot_tcp_relay_free(&relays);
 }
 
 void test_close(void)
@@ -321,7 +321,7 @@ void test_close(void)
        knot_tcp_relay_dynarray_t relays = { 0 };
        prepare_msg(&msg, KNOT_XDP_MSG_FIN | KNOT_XDP_MSG_ACK, be16toh(test_conn->ip_rem.sin6_port), be16toh(test_conn->ip_loc.sin6_port));
        prepare_seqack(&msg, 0, 0);
-       int ret = knot_xdp_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
+       int ret = knot_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
        is_int(KNOT_EOK, ret, "close: relay 1 OK");
        check_sent(0, 0, 0, 1);
        is_int(1, relays.size, "close: one relay");
@@ -329,11 +329,11 @@ void test_close(void)
        is_int(XDP_TCP_CLOSE, rl->action, "close: relay action");
        ok(rl->conn == test_conn, "close: same connection");
        is_int(XDP_TCP_CLOSING, rl->conn->state, "close: conn state");
-       knot_xdp_tcp_relay_free(&relays);
+       knot_tcp_relay_free(&relays);
 
        msg.flags &= ~KNOT_XDP_MSG_FIN;
        prepare_seqack(&msg, 0, 0);
-       ret = knot_xdp_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
+       ret = knot_tcp_relay(test_sock, &msg, 1, test_table, NULL, &relays);
        is_int(KNOT_EOK, ret, "close: relay 2 OK");
        check_sent(0, 0, 0, 0);
        is_int(conns_pre - 1, test_table->usage, "close: connection removed");
@@ -353,33 +353,33 @@ void test_many(void)
        }
 
        knot_tcp_relay_dynarray_t relays = { 0 };
-       int ret = knot_xdp_tcp_relay(test_sock, msgs, CONNS, test_table, NULL, &relays);
+       int ret = knot_tcp_relay(test_sock, msgs, CONNS, test_table, NULL, &relays);
        is_int(KNOT_EOK, ret, "many: relay OK");
        check_sent(0, 0, CONNS, 0);
        is_int(CONNS, relays.size, "many: relays count");
        is_int(CONNS, test_table->usage, "many: table usage");
 
-       knot_xdp_tcp_relay_free(&relays);
+       knot_tcp_relay_free(&relays);
        usleep(timeout_time);
        knot_xdp_msg_t *survive = &msgs[i_survive];
        survive->flags = (KNOT_XDP_MSG_TCP | KNOT_XDP_MSG_ACK);
        knot_tcp_conn_t *surv_conn = tcp_table_find(test_table, survive);
        fix_seqack(survive);
        prepare_data(survive, "\x00\x00", 2);
-       (void)knot_xdp_tcp_relay(test_sock, survive, 1, test_table, NULL, &relays);
+       (void)knot_tcp_relay(test_sock, survive, 1, test_table, NULL, &relays);
        is_int(1, relays.size, "many/survivor: one relay");
        knot_tcp_relay_t *rl = &knot_tcp_relay_dynarray_arr(&relays)[0];
        clean_sent();
 
        uint32_t reset_count = 0, close_count = 0;
-       ret = knot_xdp_tcp_timeout(test_table, test_sock, UINT32_MAX, timeout_time, UINT32_MAX, 0, 0, &close_count, &reset_count);
+       ret = knot_tcp_sweep(test_table, test_sock, UINT32_MAX, timeout_time, UINT32_MAX, 0, 0, &close_count, &reset_count);
        is_int(KNOT_EOK, ret, "many/timeout1: OK");
        is_int(CONNS - 1, close_count, "many/timeout1: close count");
        is_int(0, reset_count, "may/timeout1: reset count");
        check_sent(0, 0, 0, CONNS - 1);
 
        close_count = 0;
-       ret = knot_xdp_tcp_timeout(test_table, test_sock, UINT32_MAX, UINT32_MAX, timeout_time, 0, 0, &close_count, &reset_count);
+       ret = knot_tcp_sweep(test_table, test_sock, UINT32_MAX, UINT32_MAX, timeout_time, 0, 0, &close_count, &reset_count);
        is_int(KNOT_EOK, ret, "many/timeout2: OK");
        is_int(0, close_count, "many/timeout2: close count");
        is_int(CONNS - 1, reset_count, "may/timeout2: reset count");
@@ -402,7 +402,7 @@ void test_ibufs_size(void)
        for (int i = 0; i < CONNS; i++) {
                prepare_msg(&msgs[i], KNOT_XDP_MSG_SYN, i + 2000, 1);
        }
-       int ret = knot_xdp_tcp_relay(test_sock, msgs, CONNS, test_table, NULL, &relays);
+       int ret = knot_tcp_relay(test_sock, msgs, CONNS, test_table, NULL, &relays);
        is_int(KNOT_EOK, ret, "ibufs: open OK");
        check_sent(0, 0, CONNS, 0);
        for (int i = 0; i < CONNS; i++) {
@@ -414,11 +414,11 @@ void test_ibufs_size(void)
        // first connection will start a fragment buf then finish it
        fix_seqack(&msgs[0]);
        prepare_data(&msgs[0], "\x00\x0a""lorem", 7);
-       ret = knot_xdp_tcp_relay(test_sock, &msgs[0], 1, test_table, NULL, &relays);
+       ret = knot_tcp_relay(test_sock, &msgs[0], 1, test_table, NULL, &relays);
        is_int(KNOT_EOK, ret, "ibufs: must be OK");
        check_sent(1, 0, 0, 0);
        is_int(7, test_table->inbufs_total, "inbufs: first inbuf");
-       knot_xdp_tcp_relay_free(&relays);
+       knot_tcp_relay_free(&relays);
 
        // other connection will just store fragments
        fix_seqacks(msgs, CONNS);
@@ -426,17 +426,17 @@ void test_ibufs_size(void)
        prepare_data(&msgs[1], "\x00\xff""12345", 7);
        prepare_data(&msgs[2], "\xff\xff""abcde", 7);
        prepare_data(&msgs[3], "\xff\xff""abcde", 7);
-       ret = knot_xdp_tcp_relay(test_sock, msgs, CONNS, test_table, NULL, &relays);
+       ret = knot_tcp_relay(test_sock, msgs, CONNS, test_table, NULL, &relays);
        is_int(KNOT_EOK, ret, "inbufs: relay OK");
        check_sent(CONNS, 0, 0, 0);
        is_int(21, test_table->inbufs_total, "inbufs: after change");
        is_int(1, relays.size, "inbufs: one relay");
        is_int(10, knot_tcp_relay_dynarray_arr(&relays)[0].data.iov_len, "inbufs: data length");
-       knot_xdp_tcp_relay_free(&relays);
+       knot_tcp_relay_free(&relays);
 
        // now free some
        uint32_t reset_count = 0, close_count = 0;
-       ret = knot_xdp_tcp_timeout(test_table, test_sock, UINT32_MAX, UINT32_MAX, UINT32_MAX, 0, 8, &close_count, &reset_count);
+       ret = knot_tcp_sweep(test_table, test_sock, UINT32_MAX, UINT32_MAX, UINT32_MAX, 0, 8, &close_count, &reset_count);
        is_int(KNOT_EOK, ret, "inbufs: timeout OK");
        check_sent(0, 2, 0, 0);
        is_int(0, close_count, "inbufs: close count");