2023-11-30 02:02:08 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-or-later
|
|
|
|
* Copyright Red Hat
|
|
|
|
* Author: David Gibson <david@gibson.dropbear.id.au>
|
|
|
|
*
|
|
|
|
* Tracking for logical "flows" of packets.
|
|
|
|
*/
|
|
|
|
#ifndef FLOW_H
|
|
|
|
#define FLOW_H
|
|
|
|
|
2024-01-16 00:50:36 +00:00
|
|
|
#define FLOW_TIMER_INTERVAL 1000 /* ms */
|
|
|
|
|
2023-11-30 02:02:08 +00:00
|
|
|
/**
|
|
|
|
* enum flow_type - Different types of packet flows we track
|
|
|
|
*/
|
|
|
|
enum flow_type {
|
|
|
|
/* Represents an invalid or unused flow */
|
|
|
|
FLOW_TYPE_NONE = 0,
|
|
|
|
/* A TCP connection between a socket and tap interface */
|
|
|
|
FLOW_TCP,
|
|
|
|
/* A TCP connection between a host socket and ns socket */
|
|
|
|
FLOW_TCP_SPLICE,
|
2024-02-29 04:15:32 +00:00
|
|
|
/* ICMP echo requests from guest to host and matching replies back */
|
|
|
|
FLOW_PING4,
|
|
|
|
/* ICMPv6 echo requests from guest to host and matching replies back */
|
|
|
|
FLOW_PING6,
|
2023-11-30 02:02:08 +00:00
|
|
|
|
|
|
|
FLOW_NUM_TYPES,
|
|
|
|
};
|
|
|
|
|
|
|
|
extern const char *flow_type_str[];
|
|
|
|
#define FLOW_TYPE(f) \
|
|
|
|
((f)->type < FLOW_NUM_TYPES ? flow_type_str[(f)->type] : "?")
|
|
|
|
|
2024-02-28 11:25:07 +00:00
|
|
|
extern const uint8_t flow_proto[];
|
|
|
|
#define FLOW_PROTO(f) \
|
|
|
|
((f)->type < FLOW_NUM_TYPES ? flow_proto[(f)->type] : 0)
|
|
|
|
|
2023-11-30 02:02:08 +00:00
|
|
|
/**
|
|
|
|
* struct flow_common - Common fields for packet flows
|
|
|
|
* @type: Type of packet flow
|
|
|
|
*/
|
|
|
|
struct flow_common {
|
|
|
|
uint8_t type;
|
|
|
|
};
|
|
|
|
|
2023-11-30 02:02:09 +00:00
|
|
|
#define FLOW_INDEX_BITS 17 /* 128k - 1 */
|
|
|
|
#define FLOW_MAX MAX_FROM_BITS(FLOW_INDEX_BITS)
|
|
|
|
|
|
|
|
#define FLOW_TABLE_PRESSURE 30 /* % of FLOW_MAX */
|
|
|
|
#define FLOW_FILE_PRESSURE 30 /* % of c->nofile */
|
|
|
|
|
2024-02-28 11:25:10 +00:00
|
|
|
union flow *flow_start(union flow *flow, enum flow_type type,
|
|
|
|
unsigned iniside);
|
|
|
|
#define FLOW_START(flow_, t_, var_, i_) \
|
|
|
|
(&flow_start((flow_), (t_), (i_))->var_)
|
|
|
|
|
2023-11-30 02:02:14 +00:00
|
|
|
/**
|
|
|
|
* struct flow_sidx - ID for one side of a specific flow
|
|
|
|
* @side: Side referenced (0 or 1)
|
|
|
|
* @flow: Index of flow referenced
|
|
|
|
*/
|
|
|
|
typedef struct flow_sidx {
|
flow,tcp: Use epoll_ref type including flow and side
Currently TCP uses the 'flow' epoll_ref field for both connected
sockets and timers, which consists of just the index of the relevant
flow (connection).
This is just fine for timers, for while it obviously works, it's
subtly incomplete for sockets on spliced connections. In that case we
want to know which side of the connection the event is occurring on as
well as which connection. At present, we deduce that information by
looking at the actual fd, and comparing it to the fds of the sockets
on each side.
When we use the flow table for more things, we expect more cases where
something will need to know a specific side of a specific flow for an
event, but nothing more.
Therefore add a new 'flowside' epoll_ref field, with exactly that
information. We use it for TCP connected sockets. This allows us to
directly know the side for spliced connections. For "tap"
connections, it's pretty meaningless, since the side is always the
socket side. It still makes logical sense though, and it may become
important for future flow table work.
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Signed-off-by: Stefano Brivio <sbrivio@redhat.com>
2023-11-30 02:02:18 +00:00
|
|
|
unsigned side :1;
|
2023-11-30 02:02:14 +00:00
|
|
|
unsigned flow :FLOW_INDEX_BITS;
|
|
|
|
} flow_sidx_t;
|
|
|
|
static_assert(sizeof(flow_sidx_t) <= sizeof(uint32_t),
|
|
|
|
"flow_sidx_t must fit within 32 bits");
|
|
|
|
|
|
|
|
#define FLOW_SIDX_NONE ((flow_sidx_t){ .flow = FLOW_MAX })
|
|
|
|
|
2023-12-07 05:53:52 +00:00
|
|
|
/**
|
|
|
|
* flow_sidx_eq() - Test if two sidx values are equal
|
|
|
|
* @a, @b: sidx values
|
|
|
|
*
|
|
|
|
* Return: true iff @a and @b refer to the same side of the same flow
|
|
|
|
*/
|
|
|
|
static inline bool flow_sidx_eq(flow_sidx_t a, flow_sidx_t b)
|
|
|
|
{
|
|
|
|
return (a.flow == b.flow) && (a.side == b.side);
|
|
|
|
}
|
|
|
|
|
2023-11-30 02:02:09 +00:00
|
|
|
union flow;
|
|
|
|
|
2024-01-16 00:50:43 +00:00
|
|
|
void flow_init(void);
|
2024-01-16 00:50:40 +00:00
|
|
|
void flow_defer_handler(const struct ctx *c, const struct timespec *now);
|
2023-11-30 02:02:12 +00:00
|
|
|
|
2023-11-30 02:02:13 +00:00
|
|
|
void flow_log_(const struct flow_common *f, int pri, const char *fmt, ...)
|
|
|
|
__attribute__((format(printf, 3, 4)));
|
|
|
|
|
|
|
|
#define flow_log(f_, pri, ...) flow_log_(&(f_)->f, (pri), __VA_ARGS__)
|
|
|
|
|
|
|
|
#define flow_dbg(f, ...) flow_log((f), LOG_DEBUG, __VA_ARGS__)
|
|
|
|
#define flow_err(f, ...) flow_log((f), LOG_ERR, __VA_ARGS__)
|
|
|
|
|
|
|
|
#define flow_trace(f, ...) \
|
|
|
|
do { \
|
|
|
|
if (log_trace) \
|
|
|
|
flow_dbg((f), __VA_ARGS__); \
|
|
|
|
} while (0)
|
|
|
|
|
2023-11-30 02:02:08 +00:00
|
|
|
#endif /* FLOW_H */
|