Commit 0714832c21169493a0a857237fbface612e3d5e0 | zig

author	Hiroaki Nakamura <hnakamur@gmail.com> 2021-12-01 22:24:02+09:00
committer	Andrew Kelley <andrew@ziglang.org> 2021-12-01 14:30:33-08:00
log	0714832c21169493a0a857237fbface612e3d5e0
tree	c024a0dc7dfe5d836dcec91976fb895b1a18640e
parent	70dcdcb73d42e69df50f3a4b721a7ecb30153758

Fix test for io_uring link_timeout

The old test "timeout_link_chain1" was ported from liburing test_timeout_link_chain1
https://github.com/axboe/liburing/blob/509873c4454012c5810c728695c21911c82acdc4/test/link-timeout.c#L539-L628
However it turns out that both fails with EBADF (-9) on Linux kernel 5.4.

The this new test skips properly on Linux kernel 5.4
and passes on Linux kernel 5.11.

1 files changed, 48 insertions(+), 28 deletions(-)

lib
- std
  - os
    linux
    io_uring.zig

lib/std/os/linux/io_uring.zig+48-28

 @@ -1840,42 +1840,73 @@ test "timeout_remove" {
     }, cqe_timeout_remove);
 }
-test "timeout_link_chain1" {
+test "accept/connect/recv/link_timeout" {
     if (builtin.os.tag != .linux) return error.SkipZigTest;
-    var ring = IO_Uring.init(8, 0) catch |err| switch (err) {
+    var ring = IO_Uring.init(16, 0) catch |err| switch (err) {
         error.SystemOutdated => return error.SkipZigTest,
         error.PermissionDenied => return error.SkipZigTest,
         else => return err,
     };
     defer ring.deinit();
-    var fds = try os.pipe();
+    const address = try net.Address.parseIp4("127.0.0.1", 3131);
-    defer {
+    const kernel_backlog = 1;
-        os.close(fds[0]);
+    const server = try os.socket(address.any.family, os.SOCK.STREAM | os.SOCK.CLOEXEC, 0);
-        os.close(fds[1]);
+    defer os.close(server);
+    try os.setsockopt(server, os.SOL.SOCKET, os.SO.REUSEADDR, &mem.toBytes(@as(c_int, 1)));
+    try os.bind(server, &address.any, address.getOsSockLen());
+    try os.listen(server, kernel_backlog);
+    var buffer_recv = [_]u8{ 0, 1, 0, 1, 0 };
+    var accept_addr: os.sockaddr = undefined;
+    var accept_addr_len: os.socklen_t = @sizeOf(@TypeOf(accept_addr));
+    _ = try ring.accept(0xaaaaaaaa, server, &accept_addr, &accept_addr_len, 0);
+    try testing.expectEqual(@as(u32, 1), try ring.submit());
+    const client = try os.socket(address.any.family, os.SOCK.STREAM | os.SOCK.CLOEXEC, 0);
+    defer os.close(client);
+    _ = try ring.connect(0xcccccccc, client, &address.any, address.getOsSockLen());
+    try testing.expectEqual(@as(u32, 1), try ring.submit());
+    var cqe_accept = try ring.copy_cqe();
+    if (cqe_accept.err() == .INVAL) return error.SkipZigTest;
+    var cqe_connect = try ring.copy_cqe();
+    if (cqe_connect.err() == .INVAL) return error.SkipZigTest;
+    // The accept/connect CQEs may arrive in any order, the connect CQE will sometimes come first:
+    if (cqe_accept.user_data == 0xcccccccc and cqe_connect.user_data == 0xaaaaaaaa) {
+        const a = cqe_accept;
+        const b = cqe_connect;
+        cqe_accept = b;
+        cqe_connect = a;
     }
-    var buffer = [_]u8{0} ** 128;
+    try testing.expectEqual(@as(u64, 0xaaaaaaaa), cqe_accept.user_data);
-    const iovecs = [_]os.iovec{os.iovec{ .iov_base = &buffer, .iov_len = buffer.len }};
+    if (cqe_accept.res <= 0) std.debug.print("\ncqe_accept.res={}\n", .{cqe_accept.res});
-    const sqe_readv = try ring.readv(0x11111111, fds[0], &iovecs, 0);
+    try testing.expect(cqe_accept.res > 0);
-    sqe_readv.flags |= linux.IOSQE_IO_LINK;
+    try testing.expectEqual(@as(u32, 0), cqe_accept.flags);
+    try testing.expectEqual(linux.io_uring_cqe{
+        .user_data = 0xcccccccc,
+        .res = 0,
+        .flags = 0,
+    }, cqe_connect);
+    const sqe_recv = try ring.recv(0xffffffff, cqe_accept.res, buffer_recv[0..], 0);
+    sqe_recv.flags |= linux.IOSQE_IO_LINK;
     const ts = os.linux.kernel_timespec{ .tv_sec = 0, .tv_nsec = 1000000 };
-    const seq_link_timeout = try ring.link_timeout(0x22222222, &ts, 0);
+    _ = try ring.link_timeout(0x22222222, &ts, 0);
-    seq_link_timeout.flags |= linux.IOSQE_IO_LINK;
-    _ = try ring.nop(0x33333333);
     const nr_wait = try ring.submit();
-    try testing.expectEqual(@as(u32, 3), nr_wait);
+    try testing.expectEqual(@as(u32, 2), nr_wait);
     var i: usize = 0;
     while (i < nr_wait) : (i += 1) {
         const cqe = try ring.copy_cqe();
         switch (cqe.user_data) {
-            // poll cancel really should return -ECANCEL...
+            0xffffffff => {
-            0x11111111 => {
                 if (cqe.res != -@as(i32, @enumToInt(linux.E.INTR)) and
                     cqe.res != -@as(i32, @enumToInt(linux.E.CANCELED)))
                 {
 @@ -1884,20 +1915,9 @@ test "timeout_link_chain1" {
                 }
             },
             0x22222222 => {
-                // FASTPOLL kernels can cancel successfully
                 if (cqe.res != -@as(i32, @enumToInt(linux.E.ALREADY)) and
                     cqe.res != -@as(i32, @enumToInt(linux.E.TIME)))
                 {
-                    if (cqe.res == -@as(i32, @enumToInt(linux.E.BADF))) {
-                        // https://github.com/ziglang/zig/issues/10247
-                        return error.SkipZigTest;
-                    }
-                    std.debug.print("Req 0x{x} got {d}\n", .{ cqe.user_data, cqe.res });
-                    try testing.expect(false);
-                }
-            },
-            0x33333333 => {
-                if (cqe.res != -@as(i32, @enumToInt(linux.E.CANCELED))) {
                     std.debug.print("Req 0x{x} got {d}\n", .{ cqe.user_data, cqe.res });
                     try testing.expect(false);
                 }