mirrors/passt
1
0
Fork 0
mirror of https://passt.top/passt synced 2025-06-06 07:56:38 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

udp: Always hash socket facing flowsides

Browse source 
For UDP packets from the tap interface (like TCP) we use a hash table to
look up which flow they belong to.  Unlike TCP, we sometimes also create a
hash table entry for the socket side of UDP flows.  We need that when we
receive a UDP packet from a "listening" socket which isn't specific to a
single flow.

At present we only do this for the initiating side of flows, which re-use
the listening socket.  For the target side we use a connected "reply"
socket specific to the single flow.

We have in mind changes that maye introduce some edge cases were we could
receive UDP packets on a non flow specific socket more often.  To allow for
those changes - and slightly simplifying things in the meantime - always
put both sides of a UDP flow - tap or socket - in the hash table.  It's
not that costly, and means we always have the option of falling back to a
hash lookup.

Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
Signed-off-by: Stefano Brivio <sbrivio@redhat.com>
This commit is contained in:
David Gibson 2025-03-26 14:44:06 +11:00 • committed by Stefano Brivio
parent f67c488b81
commit 37d78c9ef3
1 changed files with 20 additions and 21 deletions

41
udp_flow.c
View file

@ -41,25 +41,23 @@ struct udp_flow *udp_at_sidx(flow_sidx_t sidx)
*/ */
void udp_flow_close(const struct ctx *c, struct udp_flow *uflow) void udp_flow_close(const struct ctx *c, struct udp_flow *uflow)
{ {
unsigned sidei;
if (uflow->closed) if (uflow->closed)
return; /* Nothing to do */ return; /* Nothing to do */
if (uflow->s[INISIDE] >= 0) { flow_foreach_sidei(sidei) {
/* The listening socket needs to stay in epoll */ flow_hash_remove(c, FLOW_SIDX(uflow, sidei));
close(uflow->s[INISIDE]); if (uflow->s[sidei] >= 0) {
uflow->s[INISIDE] = -1; /* The listening socket needs to stay in epoll, but the
* flow specific one needs to be removed */
if (sidei == TGTSIDE)
epoll_del(c, uflow->s[sidei]);
close(uflow->s[sidei]);
uflow->s[sidei] = -1;
}
} }
if (uflow->s[TGTSIDE] >= 0) {
/* But the flow specific one needs to be removed */
epoll_del(c, uflow->s[TGTSIDE]);
close(uflow->s[TGTSIDE]);
uflow->s[TGTSIDE] = -1;
}
flow_hash_remove(c, FLOW_SIDX(uflow, INISIDE));
if (!pif_is_socket(uflow->f.pif[TGTSIDE]))
flow_hash_remove(c, FLOW_SIDX(uflow, TGTSIDE));
uflow->closed = true; uflow->closed = true;
} }
@ -77,6 +75,7 @@ static flow_sidx_t udp_flow_new(const struct ctx *c, union flow *flow,
{ {
struct udp_flow *uflow = NULL; struct udp_flow *uflow = NULL;
const struct flowside *tgt; const struct flowside *tgt;
unsigned sidei;
uint8_t tgtpif; uint8_t tgtpif;
if (!(tgt = flow_target(c, flow, IPPROTO_UDP))) if (!(tgt = flow_target(c, flow, IPPROTO_UDP)))
@ -143,14 +142,14 @@ static flow_sidx_t udp_flow_new(const struct ctx *c, union flow *flow,
} }
} }
flow_hash_insert(c, FLOW_SIDX(uflow, INISIDE)); /* Tap sides always need to be looked up by hash. Socket sides don't
* always, but sometimes do (receiving packets on a socket not specific
/* If the target side is a socket, it will be a reply socket that knows * to one flow). Unconditionally hash both sides so all our bases are
* its own flowside. But if it's tap, then we need to look it up by * covered
* hash.
*/ */
if (!pif_is_socket(tgtpif)) flow_foreach_sidei(sidei)
flow_hash_insert(c, FLOW_SIDX(uflow, TGTSIDE)); flow_hash_insert(c, FLOW_SIDX(uflow, sidei));
FLOW_ACTIVATE(uflow); FLOW_ACTIVATE(uflow);
return FLOW_SIDX(uflow, TGTSIDE); return FLOW_SIDX(uflow, TGTSIDE);