summaryrefslogtreecommitdiff
path: root/test/timeout-overflow.c
blob: 644522501a6d05edd779ff91d5ea5c1ce055f7a7 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
/*
 * Description: run timeout overflow test
 *
 */
#include <errno.h>
#include <stdio.h>
#include <limits.h>
#include <sys/time.h>

#include "liburing.h"

#define TIMEOUT_MSEC	200
static int not_supported;

static void msec_to_ts(struct __kernel_timespec *ts, unsigned int msec)
{
	ts->tv_sec = TIMEOUT_MSEC / 1000;
	ts->tv_nsec = (msec % 1000) * 1000000;
}

static int check_timeout_support()
{
	struct io_uring_sqe *sqe;
	struct io_uring_cqe *cqe;
	struct __kernel_timespec ts;
	struct io_uring ring;
	int ret;

	ret = io_uring_queue_init(8, &ring, 0);
	if (ret) {
		printf("ring setup failed\n");
		return 1;
	}
	sqe = io_uring_get_sqe(&ring);
	msec_to_ts(&ts, TIMEOUT_MSEC);
	io_uring_prep_timeout(sqe, &ts, 1, 0);

	ret = io_uring_submit(&ring);
	if (ret < 0) {
		printf("sqe submit failed: %d\n", ret);
		goto err;
	}

	ret = io_uring_wait_cqe(&ring, &cqe);
	if (ret < 0) {
		printf("wait completion %d\n", ret);
		goto err;
	}

	if (cqe->res == -EINVAL) {
		not_supported = 1;
		printf("Timeout not supported, ignored\n");
		return 0;
	}

	io_uring_cqe_seen(&ring, cqe);
	io_uring_queue_exit(&ring);
	return 0;
err:
	io_uring_queue_exit(&ring);
	return 1;
}

/*
 * We first setup 4 timeout requests, which require a count value of 1, 1, 2,
 * UINT_MAX, so the sequence is 1, 2, 4, 2. Before really timeout, this 4
 * requests will not lead the change of cq_cached_tail, so as sq_dropped.
 *
 * And before this patch. The order of this four requests will be req1->req2->
 * req4->req3. Actually, it should be req1->req2->req3->req4.
 *
 * Then, if there is 2 nop req. All timeout requests expect req4 will completed
 * successful after the patch. And req1/req2 will completed successful with
 * req3/req4 return -ETIME without this patch!
 */
static int test_timeout_overflow()
{
	struct io_uring_sqe *sqe;
	struct io_uring_cqe *cqe;
	struct __kernel_timespec ts;
	struct io_uring ring;
	int i, ret;

	ret = io_uring_queue_init(16, &ring, 0);
	if (ret) {
		printf("ring setup failed\n");
		return 1;
	}

	msec_to_ts(&ts, TIMEOUT_MSEC);
	for (i = 0; i < 4; i++) {
		unsigned num;
		sqe = io_uring_get_sqe(&ring);
		switch (i) {
		case 0:
		case 1:
			num = 1;
			break;
		case 2:
			num = 2;
			break;
		case 3:
			num = UINT_MAX;
			break;
		}
		io_uring_prep_timeout(sqe, &ts, num, 0);
	}

	for (i = 0; i < 2; i++) {
		sqe = io_uring_get_sqe(&ring);
		io_uring_prep_nop(sqe);
		io_uring_sqe_set_data(sqe, (void *) 1);
	}
	ret = io_uring_submit(&ring);
	if (ret < 0) {
		printf("sqe submit failed: %d\n", ret);
		goto err;
	}

	i = 0;
	while (i < 6) {
		ret = io_uring_wait_cqe(&ring, &cqe);
		if (ret < 0) {
			printf("wait completion %d\n", ret);
			goto err;
		}

		/*
		 * cqe1: first nop req
		 * cqe2: first timeout req, because of cqe1
		 * cqe3: second timeout req because of cqe1 + cqe2
		 * cqe4: second nop req
		 * cqe5~cqe6: the left three timeout req
		 */
		switch (i) {
		case 0:
		case 3:
			if (io_uring_cqe_get_data(cqe) != (void *) 1) {
				printf("nop not seen as 1 or 2\n");
				goto err;
			}
			break;
		case 1:
		case 2:
		case 4:
			if (cqe->res == -ETIME) {
				printf("expected not return -ETIME for the "
				       "%d'th timeout req\n", i - 1);
				goto err;
			}
			break;
		case 5:
			if (cqe->res != -ETIME) {
				printf("expected return -ETIME for the "
				       "%d'th timeout req\n", i - 1);
				goto err;
			}
			break;
		}
		io_uring_cqe_seen(&ring, cqe);
		i++;
	}

	return 0;
err:
	return 1;
}

int main(int argc, char *argv[])
{
	int ret;

	ret = check_timeout_support();
	if (ret) {
		printf("ring setup failed\n");
		return 1;
	}

	if (not_supported)
		return 0;

	ret = test_timeout_overflow();
	if (ret) {
		printf("test_timeout_overflow failed\n");
		return 1;
	}

	return 0;
}