uringmachine 0.15 → 0.18

data/vendor/liburing/test/timestamp.c

@@ -0,0 +1,382 @@
+#include <arpa/inet.h>
+#include <error.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <linux/errqueue.h>
+#include <linux/ipv6.h>
+#include <linux/net_tstamp.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <netinet/udp.h>
+#include <netinet/tcp.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <time.h>
+#include <unistd.h>
+#include <assert.h>
+
+#include "liburing.h"
+#include "helpers.h"
+
+/*
+ * Only sparc/hppa should have "non-standard" values for SCM_TS_OPT_ID
+ */
+#ifndef SCM_TS_OPT_ID
+#if defined(__sparc__) || defined(__sparc64__)
+#define SCM_TS_OPT_ID	0x005a
+#elif defined(__hppa__)
+#define SCM_TS_OPT_ID	0x404C
+#else
+#define SCM_TS_OPT_ID	81
+#endif
+#endif
+
+static const int cfg_payload_len = 10;
+static uint16_t dest_port = 9000;
+static uint32_t ts_opt_id = 81;
+static bool cfg_use_cmsg_opt_id = false;
+static char buffer[128];
+static const bool verbose = false;
+
+static struct sockaddr_in6 daddr6;
+
+static int saved_tskey = -1;
+static int saved_tskey_type = -1;
+
+struct ctx {
+	int family;
+	int proto;
+	int report_opt;
+	int num_pkts;
+};
+
+static int validate_key(int tskey, int tstype, struct ctx *ctx)
+{
+	int stepsize;
+
+	/* compare key for each subsequent request
+	 * must only test for one type, the first one requested
+	 */
+	if (saved_tskey == -1 || cfg_use_cmsg_opt_id)
+		saved_tskey_type = tstype;
+	else if (saved_tskey_type != tstype)
+		return 0;
+
+	stepsize = ctx->proto == SOCK_STREAM ? cfg_payload_len : 1;
+	stepsize = cfg_use_cmsg_opt_id ? 0 : stepsize;
+	if (tskey != saved_tskey + stepsize) {
+		fprintf(stderr, "ERROR: key %d, expected %d\n",
+				tskey, saved_tskey + stepsize);
+		return -EINVAL;
+	}
+
+	saved_tskey = tskey;
+	return 0;
+}
+
+static int test_prep_sock(int family, int proto, unsigned report_opt)
+{
+	int ipproto = proto == SOCK_STREAM ? IPPROTO_TCP : IPPROTO_UDP;
+	unsigned int sock_opt;
+	int fd, val = 1;
+
+	fd = socket(family, proto, ipproto);
+	if (fd < 0)
+		error(1, errno, "socket");
+
+	if (proto == SOCK_STREAM) {
+		if (setsockopt(fd, IPPROTO_TCP, TCP_NODELAY,
+			       (char*) &val, sizeof(val)))
+			error(1, 0, "setsockopt no nagle");
+
+		if (connect(fd, (void *) &daddr6, sizeof(daddr6)))
+			error(1, errno, "connect ipv6");
+	}
+
+	sock_opt = SOF_TIMESTAMPING_SOFTWARE |
+		   SOF_TIMESTAMPING_OPT_CMSG |
+		   SOF_TIMESTAMPING_OPT_ID;
+	sock_opt |= report_opt;
+	sock_opt |= SOF_TIMESTAMPING_OPT_TSONLY;
+
+	if (setsockopt(fd, SOL_SOCKET, SO_TIMESTAMPING,
+		       (char *) &sock_opt, sizeof(sock_opt)))
+		error(1, 0, "setsockopt timestamping");
+
+	return fd;
+}
+
+#define MAX_PACKETS 32
+
+struct send_req {
+	struct msghdr msg;
+	struct iovec iov;
+	char control[CMSG_SPACE(sizeof(uint32_t))];
+};
+
+static void queue_ts_cmd(struct io_uring *ring, int fd)
+{
+	struct io_uring_sqe *sqe;
+
+	sqe = io_uring_get_sqe(ring);
+	io_uring_prep_rw(IORING_OP_URING_CMD, sqe, fd, NULL, 0, 0);
+	sqe->cmd_op = SOCKET_URING_OP_TX_TIMESTAMP;
+	sqe->user_data = 43;
+}
+
+static void queue_send(struct io_uring *ring, int fd, void *buf, struct send_req *r,
+			int proto)
+{
+	struct io_uring_sqe *sqe;
+
+	r->iov.iov_base = buf;
+	r->iov.iov_len = cfg_payload_len;
+
+	memset(&r->msg, 0, sizeof(r->msg));
+	r->msg.msg_iov = &r->iov;
+	r->msg.msg_iovlen = 1;
+	if (proto == SOCK_STREAM) {
+		r->msg.msg_name = (void *)&daddr6;
+		r->msg.msg_namelen = sizeof(daddr6);
+	}
+
+	if (cfg_use_cmsg_opt_id) {
+		struct cmsghdr *cmsg;
+
+		memset(r->control, 0, sizeof(r->control));
+		r->msg.msg_control = r->control;
+		r->msg.msg_controllen = CMSG_SPACE(sizeof(uint32_t));
+
+		cmsg = CMSG_FIRSTHDR(&r->msg);
+		cmsg->cmsg_level = SOL_SOCKET;
+		cmsg->cmsg_type = SCM_TS_OPT_ID;
+		cmsg->cmsg_len = CMSG_LEN(sizeof(uint32_t));
+
+		*((uint32_t *)CMSG_DATA(cmsg)) = ts_opt_id;
+		saved_tskey = ts_opt_id;
+	}
+
+	sqe = io_uring_get_sqe(ring);
+	io_uring_prep_sendmsg(sqe, fd, &r->msg, 0);
+	sqe->user_data = 0;
+}
+
+static const char *get_tstype_name(int tstype)
+{
+	if (tstype == SCM_TSTAMP_SCHED)
+		return "ENQ";
+	if (tstype == SCM_TSTAMP_SND)
+		return "SND";
+	if (tstype == SCM_TSTAMP_ACK)
+		return "ACK";
+	return "unknown";
+}
+
+static int do_test(struct ctx *ctx)
+{
+	struct send_req reqs[MAX_PACKETS];
+	struct io_uring_cqe *cqe;
+	struct io_uring ring;
+	unsigned long head;
+	int cqes_seen = 0;
+	int i, fd, ret;
+	int ts_expected = 0, ts_got = 0;
+
+	ts_expected += !!(ctx->report_opt & SOF_TIMESTAMPING_TX_SCHED);
+	ts_expected += !!(ctx->report_opt & SOF_TIMESTAMPING_TX_SOFTWARE);
+	ts_expected += !!(ctx->report_opt & SOF_TIMESTAMPING_TX_ACK);
+
+	ret = t_create_ring(32, &ring, IORING_SETUP_CQE32);
+	if (ret == T_SETUP_SKIP)
+		return T_EXIT_SKIP;
+	else if (ret)
+		t_error(1, ret, "queue init\n");
+
+	assert(ctx->num_pkts <= MAX_PACKETS);
+
+	fd = test_prep_sock(ctx->family, ctx->proto, ctx->report_opt);
+	if (fd < 0)
+		t_error(1, fd, "can't create socket\n");
+
+	memset(buffer, 'a', cfg_payload_len);
+	saved_tskey = -1;
+
+	if (cfg_use_cmsg_opt_id)
+		saved_tskey = ts_opt_id;
+
+	for (i =  0; i < ctx->num_pkts; i++) {
+		queue_send(&ring, fd, buffer, &reqs[i], ctx->proto);
+		ret = io_uring_submit(&ring);
+		if (ret != 1)
+			t_error(1, ret, "submit failed");
+
+		ret = io_uring_wait_cqe(&ring, &cqe);
+		if (ret || cqe->res != cfg_payload_len) {
+			fprintf(stderr, "wait send cqe, %d %d, expected %d\n",
+				ret, cqe->res, cfg_payload_len);
+			return T_EXIT_FAIL;
+		}
+		io_uring_cqe_seen(&ring, cqe);
+	}
+
+	usleep(200000);
+
+	queue_ts_cmd(&ring, fd);
+	ret = io_uring_submit(&ring);
+	if (ret != 1)
+		t_error(1, ret, "submit failed");
+
+	ret = io_uring_wait_cqe(&ring, &cqe);
+	if (ret) {
+		fprintf(stderr, "wait_cqe failed %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	io_uring_for_each_cqe(&ring, head, cqe) {
+		struct io_timespec *ts;
+		int tskey, tstype;
+		bool hwts;
+
+		cqes_seen++;
+
+		if (!(cqe->flags & IORING_CQE_F_MORE)) {
+			if (cqe->res == -EINVAL || cqe->res == -EOPNOTSUPP)
+				return T_EXIT_SKIP;
+			if (cqe->res)
+				t_error(1, 0, "failed cqe %i", cqe->res);
+			break;
+		}
+
+		ts = (void *)(cqe + 1);
+		tstype = cqe->flags >> IORING_TIMESTAMP_TYPE_SHIFT;
+		tskey = cqe->res;
+		hwts = cqe->flags & IORING_CQE_F_TSTAMP_HW;
+
+		ts_got++;
+		if (verbose)
+			fprintf(stderr, "ts: key %x, type %i (%s), is hw %i, sec %lu, nsec %lu\n",
+				tskey, tstype, get_tstype_name(tstype), hwts,
+				(unsigned long)ts->tv_sec,
+				(unsigned long)ts->tv_nsec);
+
+		ret = validate_key(tskey, tstype, ctx);
+		if (ret)
+			return T_EXIT_FAIL;
+	}
+
+	if (ts_got != ts_expected) {
+		fprintf(stderr, "expected %i timestamps, got %i\n",
+			ts_expected, ts_got);
+		return -EINVAL;
+	}
+
+	close(fd);
+	io_uring_cq_advance(&ring, cqes_seen);
+	io_uring_queue_exit(&ring);
+	return T_EXIT_PASS;
+}
+
+static void resolve_hostname(const char *name, int port)
+{
+	memset(&daddr6, 0, sizeof(daddr6));
+	daddr6.sin6_family = AF_INET6;
+	daddr6.sin6_port = htons(port);
+	if (inet_pton(AF_INET6, name, &daddr6.sin6_addr) != 1)
+		t_error(1, 0, "ipv6 parse error: %s", name);
+}
+
+static void do_listen(int family, int type, void *addr, int alen)
+{
+	int fd;
+
+	fd = socket(family, type, 0);
+	if (fd == -1)
+		error(1, errno, "socket rx");
+
+	if (bind(fd, addr, alen))
+		error(1, errno, "bind rx");
+
+	if (type == SOCK_STREAM && listen(fd, 10))
+		error(1, errno, "listen rx");
+
+	/* leave fd open, will be closed on process exit.
+	 * this enables connect() to succeed and avoids icmp replies
+	 */
+}
+
+static int do_main(int family, int proto)
+{
+	struct ctx ctx;
+	int ret;
+
+	ctx.num_pkts = 1;
+	ctx.family = family;
+	ctx.proto = proto;
+
+	if (verbose)
+		fprintf(stderr, "test SND\n");
+	ctx.report_opt = SOF_TIMESTAMPING_TX_SOFTWARE;
+	ret = do_test(&ctx);
+	if (ret) {
+		if (ret == T_EXIT_SKIP)
+			fprintf(stderr, "no timestamp cmd, skip\n");
+		return ret;
+	}
+
+	if (verbose)
+		fprintf(stderr, "test ENQ\n");
+	ctx.report_opt = SOF_TIMESTAMPING_TX_SCHED;
+	ret = do_test(&ctx);
+	if (ret)
+		return T_EXIT_FAIL;
+
+	if (verbose)
+		fprintf(stderr, "test ENQ + SND\n");
+	ctx.report_opt = SOF_TIMESTAMPING_TX_SCHED | SOF_TIMESTAMPING_TX_SOFTWARE;
+	ret = do_test(&ctx);
+	if (ret)
+		return T_EXIT_FAIL;
+
+	if (proto == SOCK_STREAM) {
+		if (verbose)
+			fprintf(stderr, "test ACK\n");
+		ctx.report_opt = SOF_TIMESTAMPING_TX_ACK;
+		ret = do_test(&ctx);
+		if (ret)
+			return T_EXIT_FAIL;
+
+		if (verbose)
+			fprintf(stderr, "test SND + ACK\n");
+		ctx.report_opt = SOF_TIMESTAMPING_TX_SOFTWARE |
+				  SOF_TIMESTAMPING_TX_ACK;
+		ret = do_test(&ctx);
+		if (ret)
+			return T_EXIT_FAIL;
+
+		if (verbose)
+			fprintf(stderr, "test ENQ + SND + ACK\n");
+		ctx.report_opt = SOF_TIMESTAMPING_TX_SCHED |
+				  SOF_TIMESTAMPING_TX_SOFTWARE |
+				  SOF_TIMESTAMPING_TX_ACK;
+		ret = do_test(&ctx);
+		if (ret)
+			return T_EXIT_FAIL;
+	}
+	return 0;
+}
+
+int main(int argc, char **argv)
+{
+	const char *hostname = "::1";
+
+	if (argc > 1)
+		return T_EXIT_SKIP;
+
+	resolve_hostname(hostname, dest_port);
+	do_listen(PF_INET6, SOCK_STREAM, &daddr6, sizeof(daddr6));
+	return do_main(PF_INET6, SOCK_STREAM);
+}

data/vendor/liburing/test/zcrx.c

@@ -43,7 +43,7 @@ static char str[] = "iv5t4dl500w7wsrf14fsuq8thptto0z7i2q62z1p8dwrv5u4kaxpqhm2rb7
 static int probe_zcrx(void *area)
 {
 	struct io_uring_zcrx_area_reg area_reg = {
-		.addr = (__u64)(unsigned long)area,
+		.addr = uring_ptr_to_u64(area),
 		.len = AREA_SZ,
 		.flags = 0,
 	};
@@ -51,7 +51,7 @@ static int probe_zcrx(void *area)
 		.if_idx = ifidx,
 		.if_rxq = rxq,
 		.rq_entries = RQ_ENTRIES,
-		.area_ptr = (__u64)(unsigned long)&area_reg,
+		.area_ptr = uring_ptr_to_u64(&area_reg),
 	};
 	struct io_uring ring;
 	int ret;
@@ -99,7 +99,7 @@ static int test_invalid_if(void *area)
 {
 	int ret;
 	struct io_uring_zcrx_area_reg area_reg = {
-		.addr = (__u64)(unsigned long)area,
+		.addr = uring_ptr_to_u64(area),
 		.len = AREA_SZ,
 		.flags = 0,
 	};
@@ -107,7 +107,7 @@ static int test_invalid_if(void *area)
 		.if_idx = -1,
 		.if_rxq = rxq,
 		.rq_entries = RQ_ENTRIES,
-		.area_ptr = (__u64)(unsigned long)&area_reg,
+		.area_ptr = uring_ptr_to_u64(&area_reg),
 	};
 
 	ret = try_register_ifq(&reg);
@@ -131,7 +131,7 @@ static int test_invalid_ifq_collision(void *area)
 {
 	struct io_uring ring, ring2;
 	struct io_uring_zcrx_area_reg area_reg = {
-		.addr = (__u64)(unsigned long)area,
+		.addr = uring_ptr_to_u64(area),
 		.len = AREA_SZ,
 		.flags = 0,
 	};
@@ -139,7 +139,7 @@ static int test_invalid_ifq_collision(void *area)
 		.if_idx = ifidx,
 		.if_rxq = rxq,
 		.rq_entries = RQ_ENTRIES,
-		.area_ptr = (__u64)(unsigned long)&area_reg,
+		.area_ptr = uring_ptr_to_u64(&area_reg),
 	};
 	int ret;
 
@@ -182,7 +182,7 @@ static int test_rq_setup(void *area)
 {
 	int ret;
 	struct io_uring_zcrx_area_reg area_reg = {
-		.addr = (__u64)(unsigned long)area,
+		.addr = uring_ptr_to_u64(area),
 		.len = AREA_SZ,
 		.flags = 0,
 	};
@@ -191,7 +191,7 @@ static int test_rq_setup(void *area)
 		.if_idx = ifidx,
 		.if_rxq = rxq,
 		.rq_entries = 0,
-		.area_ptr = (__u64)(unsigned long)&area_reg,
+		.area_ptr = uring_ptr_to_u64(&area_reg),
 	};
 
 	ret = try_register_ifq(&reg);
@@ -232,7 +232,7 @@ static int test_null_area_reg_struct(void)
 		.if_idx = ifidx,
 		.if_rxq = rxq,
 		.rq_entries = RQ_ENTRIES,
-		.area_ptr = (__u64)(unsigned long)0,
+		.area_ptr = uring_ptr_to_u64(0),
 	};
 
 	ret = try_register_ifq(&reg);
@@ -244,7 +244,7 @@ static int test_null_area(void)
 	int ret;
 
 	struct io_uring_zcrx_area_reg area_reg = {
-		.addr = (__u64)(unsigned long)0,
+		.addr = uring_ptr_to_u64(0),
 		.len = AREA_SZ,
 		.flags = 0,
 	};
@@ -253,7 +253,7 @@ static int test_null_area(void)
 		.if_idx = ifidx,
 		.if_rxq = rxq,
 		.rq_entries = RQ_ENTRIES,
-		.area_ptr = (__u64)(unsigned long)&area_reg,
+		.area_ptr = uring_ptr_to_u64(&area_reg),
 	};
 
 	ret = try_register_ifq(&reg);
@@ -264,7 +264,7 @@ static int test_misaligned_area(void *area)
 {
 	int ret;
 	struct io_uring_zcrx_area_reg area_reg = {
-		.addr = (__u64)(unsigned long)(area + 1),
+		.addr = uring_ptr_to_u64(area + 1),
 		.len = AREA_SZ,
 		.flags = 0,
 	};
@@ -273,13 +273,13 @@ static int test_misaligned_area(void *area)
 		.if_idx = ifidx,
 		.if_rxq = rxq,
 		.rq_entries = RQ_ENTRIES,
-		.area_ptr = (__u64)(unsigned long)&area_reg,
+		.area_ptr = uring_ptr_to_u64(&area_reg),
 	};
 
 	if (!try_register_ifq(&reg))
 		return T_EXIT_FAIL;
 
-	area_reg.addr = (__u64)(unsigned long)area;
+	area_reg.addr = uring_ptr_to_u64(area);
 	area_reg.len = AREA_SZ - 1;
 	ret = try_register_ifq(&reg);
 	return ret ? T_EXIT_PASS : T_EXIT_FAIL;
@@ -289,7 +289,7 @@ static int test_larger_than_alloc_area(void *area)
 {
 	int ret;
 	struct io_uring_zcrx_area_reg area_reg = {
-		.addr = (__u64)(unsigned long)area,
+		.addr = uring_ptr_to_u64(area),
 		.len = AREA_SZ + 4096,
 		.flags = 0,
 	};
@@ -298,7 +298,7 @@ static int test_larger_than_alloc_area(void *area)
 		.if_idx = ifidx,
 		.if_rxq = rxq,
 		.rq_entries = RQ_ENTRIES,
-		.area_ptr = (__u64)(unsigned long)&area_reg,
+		.area_ptr = uring_ptr_to_u64(&area_reg),
 	};
 
 	ret = try_register_ifq(&reg);
@@ -315,7 +315,7 @@ static int test_area_access(void)
 		.if_idx = ifidx,
 		.if_rxq = rxq,
 		.rq_entries = RQ_ENTRIES,
-		.area_ptr = (__u64)(unsigned long)&area_reg,
+		.area_ptr = uring_ptr_to_u64(&area_reg),
 	};
 	int i, ret;
 	void *area;
@@ -331,7 +331,7 @@ static int test_area_access(void)
 			return T_EXIT_FAIL;
 		}
 
-		area_reg.addr = (__u64)(unsigned long)area;
+		area_reg.addr = uring_ptr_to_u64(area);
 
 		ret = try_register_ifq(&reg);
 		if (ret != -EFAULT) {
@@ -348,7 +348,7 @@ static int test_area_access(void)
 static int create_ring_with_ifq(struct io_uring *ring, void *area, __u32 *id)
 {
 	struct io_uring_zcrx_area_reg area_reg = {
-		.addr = (__u64)(unsigned long)area,
+		.addr = uring_ptr_to_u64(area),
 		.len = AREA_SZ,
 		.flags = 0,
 	};
@@ -356,7 +356,7 @@ static int create_ring_with_ifq(struct io_uring *ring, void *area, __u32 *id)
 		.if_idx = ifidx,
 		.if_rxq = rxq,
 		.rq_entries = RQ_ENTRIES,
-		.area_ptr = (__u64)(unsigned long)&area_reg,
+		.area_ptr = uring_ptr_to_u64(&area_reg),
 	};
 	int ret;
 
@@ -653,7 +653,7 @@ static void *recv_fn(void *data)
 	struct io_uring ring;
 	int ret, sock;
 	struct io_uring_zcrx_area_reg area_reg = {
-		.addr = (__u64)(unsigned long)rd->area,
+		.addr = uring_ptr_to_u64(rd->area),
 		.len = AREA_SZ,
 		.flags = 0,
 	};
@@ -661,7 +661,7 @@ static void *recv_fn(void *data)
 		.if_idx = ifidx,
 		.if_rxq = rxq,
 		.rq_entries = RQ_ENTRIES,
-		.area_ptr = (__u64)(unsigned long)&area_reg,
+		.area_ptr = uring_ptr_to_u64(&area_reg),
 	};
 
 	p.flags = RING_FLAGS;