From: David Gibson <david@gibson.dropbear.id.au>
To: passt-dev@passt.top, Stefano Brivio <sbrivio@redhat.com>
Cc: David Gibson <david@gibson.dropbear.id.au>
Subject: [PATCH v3 2/8] udp: Split sending to passt tap interface into separate function
Date: Wed, 4 Jan 2023 16:44:20 +1100 [thread overview]
Message-ID: <20230104054426.120668-3-david@gibson.dropbear.id.au> (raw)
In-Reply-To: <20230104054426.120668-1-david@gibson.dropbear.id.au>
The last part of udp_sock_handler() does the actual sending of frames
to the tap interface. For pasta that's just a call to
udp_tap_send_pasta() but for passt, it's moderately complex and open
coded.
For symmetry, move the passt send path into its own function,
udp_tap_send_passt(). This will make it easier to abstract the tap
interface in future (e.g. when we want to add vhost-user).
Signed-off-by: David Gibson <david@gibson.dropbear.id.au>
---
udp.c | 130 ++++++++++++++++++++++++++++++++--------------------------
1 file changed, 72 insertions(+), 58 deletions(-)
diff --git a/udp.c b/udp.c
index a27fe88..7281bc3 100644
--- a/udp.c
+++ b/udp.c
@@ -812,6 +812,73 @@ static void udp_tap_send_pasta(const struct ctx *c, struct mmsghdr *mmh,
}
}
+/**
+ * udp_tap_send_passt() - Send datagrams to the passt tap interface
+ * @c: Execution context
+ * @mmh: Array of message headers to send
+ * @n: Number of message headers to send
+ *
+ * #syscalls:passt sendmmsg sendmsg
+ */
+static void udp_tap_send_passt(const struct ctx *c, struct mmsghdr *mmh, int n)
+{
+ struct msghdr *last_mh;
+ ssize_t missing = 0;
+ size_t msg_len = 0;
+ unsigned int i;
+ int ret;
+
+ ret = sendmmsg(c->fd_tap, mmh, n, MSG_NOSIGNAL | MSG_DONTWAIT);
+ if (ret <= 0)
+ return;
+
+ /* If we lose some messages to sendmmsg() here, fine, it's UDP. However,
+ * the last message needs to be delivered completely, otherwise qemu
+ * will fail to reassemble the next message and close the connection. Go
+ * through headers from the last sent message, counting bytes, and, if
+ * and as soon as we see more bytes than sendmmsg() sent, re-send the
+ * rest with a blocking call.
+ *
+ * In pictures, given this example:
+ *
+ * iov #0 iov #1 iov #2 iov #3
+ * tap_mmh[ret - 1].msg_hdr: .... ...... ..... ......
+ * tap_mmh[ret - 1].msg_len: 7 .... ...
+ *
+ * when 'msglen' reaches: 10 ^
+ * and 'missing' below is: 3 ---
+ *
+ * re-send everything from here: ^-- ----- ------
+ */
+ last_mh = &mmh[ret - 1].msg_hdr;
+ for (i = 0; i < last_mh->msg_iovlen; i++) {
+ if (missing <= 0) {
+ msg_len += last_mh->msg_iov[i].iov_len;
+ missing = msg_len - mmh[ret - 1].msg_len;
+ }
+
+ if (missing > 0) {
+ uint8_t **iov_base;
+ int first_offset;
+
+ iov_base = (uint8_t **)&last_mh->msg_iov[i].iov_base;
+ first_offset = last_mh->msg_iov[i].iov_len - missing;
+ *iov_base += first_offset;
+ last_mh->msg_iov[i].iov_len = missing;
+
+ last_mh->msg_iov = &last_mh->msg_iov[i];
+
+ if (sendmsg(c->fd_tap, last_mh, MSG_NOSIGNAL) < 0)
+ debug("UDP: %li bytes to tap missing", missing);
+
+ *iov_base -= first_offset;
+ break;
+ }
+ }
+
+ pcapmm(mmh, ret);
+}
+
/**
* udp_sock_handler() - Handle new data from socket
* @c: Execution context
@@ -820,16 +887,14 @@ static void udp_tap_send_pasta(const struct ctx *c, struct mmsghdr *mmh,
* @now: Current timestamp
*
* #syscalls recvmmsg
- * #syscalls:passt sendmmsg sendmsg
*/
void udp_sock_handler(const struct ctx *c, union epoll_ref ref, uint32_t events,
const struct timespec *now)
{
in_port_t dstport = ref.r.p.udp.udp.port;
- ssize_t n, msg_len = 0, missing = 0;
struct mmsghdr *tap_mmh, *sock_mmh;
- int msg_bufs = 0, msg_i = 0, ret;
- struct msghdr *last_mh;
+ int msg_bufs = 0, msg_i = 0;
+ ssize_t n, msg_len = 0;
struct iovec *tap_iov;
unsigned int i;
@@ -879,61 +944,10 @@ void udp_sock_handler(const struct ctx *c, union epoll_ref ref, uint32_t events,
}
tap_mmh[msg_i].msg_hdr.msg_iovlen = msg_bufs;
- if (c->mode == MODE_PASTA) {
+ if (c->mode == MODE_PASTA)
udp_tap_send_pasta(c, tap_mmh, msg_i + 1);
- return;
- }
-
- ret = sendmmsg(c->fd_tap, tap_mmh, msg_i + 1,
- MSG_NOSIGNAL | MSG_DONTWAIT);
- if (ret <= 0)
- return;
-
- /* If we lose some messages to sendmmsg() here, fine, it's UDP. However,
- * the last message needs to be delivered completely, otherwise qemu
- * will fail to reassemble the next message and close the connection. Go
- * through headers from the last sent message, counting bytes, and, if
- * and as soon as we see more bytes than sendmmsg() sent, re-send the
- * rest with a blocking call.
- *
- * In pictures, given this example:
- *
- * iov #0 iov #1 iov #2 iov #3
- * tap_mmh[ret - 1].msg_hdr: .... ...... ..... ......
- * tap_mmh[ret - 1].msg_len: 7 .... ...
- *
- * when 'msglen' reaches: 10 ^
- * and 'missing' below is: 3 ---
- *
- * re-send everything from here: ^-- ----- ------
- */
- last_mh = &tap_mmh[ret - 1].msg_hdr;
- for (i = 0, msg_len = 0; i < last_mh->msg_iovlen; i++) {
- if (missing <= 0) {
- msg_len += last_mh->msg_iov[i].iov_len;
- missing = msg_len - tap_mmh[ret - 1].msg_len;
- }
-
- if (missing > 0) {
- uint8_t **iov_base;
- int first_offset;
-
- iov_base = (uint8_t **)&last_mh->msg_iov[i].iov_base;
- first_offset = last_mh->msg_iov[i].iov_len - missing;
- *iov_base += first_offset;
- last_mh->msg_iov[i].iov_len = missing;
-
- last_mh->msg_iov = &last_mh->msg_iov[i];
-
- if (sendmsg(c->fd_tap, last_mh, MSG_NOSIGNAL) < 0)
- debug("UDP: %li bytes to tap missing", missing);
-
- *iov_base -= first_offset;
- break;
- }
- }
-
- pcapmm(tap_mmh, ret);
+ else
+ udp_tap_send_passt(c, tap_mmh, msg_i + 1);
}
/**
--
@@ -812,6 +812,73 @@ static void udp_tap_send_pasta(const struct ctx *c, struct mmsghdr *mmh,
}
}
+/**
+ * udp_tap_send_passt() - Send datagrams to the passt tap interface
+ * @c: Execution context
+ * @mmh: Array of message headers to send
+ * @n: Number of message headers to send
+ *
+ * #syscalls:passt sendmmsg sendmsg
+ */
+static void udp_tap_send_passt(const struct ctx *c, struct mmsghdr *mmh, int n)
+{
+ struct msghdr *last_mh;
+ ssize_t missing = 0;
+ size_t msg_len = 0;
+ unsigned int i;
+ int ret;
+
+ ret = sendmmsg(c->fd_tap, mmh, n, MSG_NOSIGNAL | MSG_DONTWAIT);
+ if (ret <= 0)
+ return;
+
+ /* If we lose some messages to sendmmsg() here, fine, it's UDP. However,
+ * the last message needs to be delivered completely, otherwise qemu
+ * will fail to reassemble the next message and close the connection. Go
+ * through headers from the last sent message, counting bytes, and, if
+ * and as soon as we see more bytes than sendmmsg() sent, re-send the
+ * rest with a blocking call.
+ *
+ * In pictures, given this example:
+ *
+ * iov #0 iov #1 iov #2 iov #3
+ * tap_mmh[ret - 1].msg_hdr: .... ...... ..... ......
+ * tap_mmh[ret - 1].msg_len: 7 .... ...
+ *
+ * when 'msglen' reaches: 10 ^
+ * and 'missing' below is: 3 ---
+ *
+ * re-send everything from here: ^-- ----- ------
+ */
+ last_mh = &mmh[ret - 1].msg_hdr;
+ for (i = 0; i < last_mh->msg_iovlen; i++) {
+ if (missing <= 0) {
+ msg_len += last_mh->msg_iov[i].iov_len;
+ missing = msg_len - mmh[ret - 1].msg_len;
+ }
+
+ if (missing > 0) {
+ uint8_t **iov_base;
+ int first_offset;
+
+ iov_base = (uint8_t **)&last_mh->msg_iov[i].iov_base;
+ first_offset = last_mh->msg_iov[i].iov_len - missing;
+ *iov_base += first_offset;
+ last_mh->msg_iov[i].iov_len = missing;
+
+ last_mh->msg_iov = &last_mh->msg_iov[i];
+
+ if (sendmsg(c->fd_tap, last_mh, MSG_NOSIGNAL) < 0)
+ debug("UDP: %li bytes to tap missing", missing);
+
+ *iov_base -= first_offset;
+ break;
+ }
+ }
+
+ pcapmm(mmh, ret);
+}
+
/**
* udp_sock_handler() - Handle new data from socket
* @c: Execution context
@@ -820,16 +887,14 @@ static void udp_tap_send_pasta(const struct ctx *c, struct mmsghdr *mmh,
* @now: Current timestamp
*
* #syscalls recvmmsg
- * #syscalls:passt sendmmsg sendmsg
*/
void udp_sock_handler(const struct ctx *c, union epoll_ref ref, uint32_t events,
const struct timespec *now)
{
in_port_t dstport = ref.r.p.udp.udp.port;
- ssize_t n, msg_len = 0, missing = 0;
struct mmsghdr *tap_mmh, *sock_mmh;
- int msg_bufs = 0, msg_i = 0, ret;
- struct msghdr *last_mh;
+ int msg_bufs = 0, msg_i = 0;
+ ssize_t n, msg_len = 0;
struct iovec *tap_iov;
unsigned int i;
@@ -879,61 +944,10 @@ void udp_sock_handler(const struct ctx *c, union epoll_ref ref, uint32_t events,
}
tap_mmh[msg_i].msg_hdr.msg_iovlen = msg_bufs;
- if (c->mode == MODE_PASTA) {
+ if (c->mode == MODE_PASTA)
udp_tap_send_pasta(c, tap_mmh, msg_i + 1);
- return;
- }
-
- ret = sendmmsg(c->fd_tap, tap_mmh, msg_i + 1,
- MSG_NOSIGNAL | MSG_DONTWAIT);
- if (ret <= 0)
- return;
-
- /* If we lose some messages to sendmmsg() here, fine, it's UDP. However,
- * the last message needs to be delivered completely, otherwise qemu
- * will fail to reassemble the next message and close the connection. Go
- * through headers from the last sent message, counting bytes, and, if
- * and as soon as we see more bytes than sendmmsg() sent, re-send the
- * rest with a blocking call.
- *
- * In pictures, given this example:
- *
- * iov #0 iov #1 iov #2 iov #3
- * tap_mmh[ret - 1].msg_hdr: .... ...... ..... ......
- * tap_mmh[ret - 1].msg_len: 7 .... ...
- *
- * when 'msglen' reaches: 10 ^
- * and 'missing' below is: 3 ---
- *
- * re-send everything from here: ^-- ----- ------
- */
- last_mh = &tap_mmh[ret - 1].msg_hdr;
- for (i = 0, msg_len = 0; i < last_mh->msg_iovlen; i++) {
- if (missing <= 0) {
- msg_len += last_mh->msg_iov[i].iov_len;
- missing = msg_len - tap_mmh[ret - 1].msg_len;
- }
-
- if (missing > 0) {
- uint8_t **iov_base;
- int first_offset;
-
- iov_base = (uint8_t **)&last_mh->msg_iov[i].iov_base;
- first_offset = last_mh->msg_iov[i].iov_len - missing;
- *iov_base += first_offset;
- last_mh->msg_iov[i].iov_len = missing;
-
- last_mh->msg_iov = &last_mh->msg_iov[i];
-
- if (sendmsg(c->fd_tap, last_mh, MSG_NOSIGNAL) < 0)
- debug("UDP: %li bytes to tap missing", missing);
-
- *iov_base -= first_offset;
- break;
- }
- }
-
- pcapmm(tap_mmh, ret);
+ else
+ udp_tap_send_passt(c, tap_mmh, msg_i + 1);
}
/**
--
2.39.0
next prev parent reply other threads:[~2023-01-04 5:44 UTC|newest]
Thread overview: 11+ messages / expand[flat|nested] mbox.gz Atom feed top
2023-01-04 5:44 [PATCH v3 0/8] Don't use additional sockets for receiving "spliced" UDP communications David Gibson
2023-01-04 5:44 ` [PATCH v3 1/8] udp: Move sending pasta tap frames to the end of udp_sock_handler() David Gibson
2023-01-04 5:44 ` David Gibson [this message]
2023-01-04 5:44 ` [PATCH v3 3/8] udp: Split receive from preparation and send in udp_sock_handler() David Gibson
2023-01-04 5:44 ` [PATCH v3 4/8] udp: Don't handle tap receive batch size calculation within a #define David Gibson
2023-01-04 5:44 ` [PATCH v3 5/8] udp: Pre-populate msg_names with local address David Gibson
2023-01-04 5:44 ` [PATCH v3 6/8] udp: Unify udp_sock_handler_splice() with udp_sock_handler() David Gibson
2023-01-04 17:44 ` Stefano Brivio
2023-01-05 4:25 ` David Gibson
2023-01-04 5:44 ` [PATCH v3 7/8] udp: Decide whether to "splice" per datagram rather than per socket David Gibson
2023-01-04 5:44 ` [PATCH v3 8/8] udp: Don't use separate sockets to listen for spliced packets David Gibson
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20230104054426.120668-3-david@gibson.dropbear.id.au \
--to=david@gibson.dropbear.id.au \
--cc=passt-dev@passt.top \
--cc=sbrivio@redhat.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
Code repositories for project(s) associated with this public inbox
https://passt.top/passt
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for IMAP folder(s).