1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (C) 2019 Intel Corporation. 3 * All rights reserved. 4 */ 5 6 #include "spdk/stdinc.h" 7 #include "spdk/util.h" 8 9 #include "spdk_internal/mock.h" 10 11 #include "spdk_cunit.h" 12 13 #include "common/lib/test_env.c" 14 #include "sock/uring/uring.c" 15 16 DEFINE_STUB(spdk_sock_map_insert, int, (struct spdk_sock_map *map, int placement_id, 17 struct spdk_sock_group_impl *group), 0); 18 DEFINE_STUB_V(spdk_sock_map_release, (struct spdk_sock_map *map, int placement_id)); 19 DEFINE_STUB(spdk_sock_map_lookup, int, (struct spdk_sock_map *map, int placement_id, 20 struct spdk_sock_group_impl **group, struct spdk_sock_group_impl *hint), 0); 21 DEFINE_STUB(spdk_sock_map_find_free, int, (struct spdk_sock_map *map), -1); 22 DEFINE_STUB_V(spdk_sock_map_cleanup, (struct spdk_sock_map *map)); 23 24 DEFINE_STUB_V(spdk_net_impl_register, (struct spdk_net_impl *impl, int priority)); 25 DEFINE_STUB(spdk_sock_close, int, (struct spdk_sock **s), 0); 26 DEFINE_STUB(__io_uring_get_cqe, int, (struct io_uring *ring, struct io_uring_cqe **cqe_ptr, 27 unsigned submit, 28 unsigned wait_nr, sigset_t *sigmask), 0); 29 DEFINE_STUB(io_uring_submit, int, (struct io_uring *ring), 0); 30 DEFINE_STUB(io_uring_queue_init, int, (unsigned entries, struct io_uring *ring, unsigned flags), 0); 31 DEFINE_STUB_V(io_uring_queue_exit, (struct io_uring *ring)); 32 33 static void 34 _req_cb(void *cb_arg, int len) 35 { 36 *(bool *)cb_arg = true; 37 CU_ASSERT(len == 0); 38 } 39 40 static void 41 flush_client(void) 42 { 43 struct spdk_uring_sock_group_impl group = {}; 44 struct spdk_uring_sock usock = {}; 45 struct spdk_sock *sock = &usock.base; 46 struct spdk_sock_request *req1, *req2; 47 bool cb_arg1, cb_arg2; 48 int rc; 49 50 /* Set up data structures */ 51 TAILQ_INIT(&sock->queued_reqs); 52 TAILQ_INIT(&sock->pending_reqs); 53 sock->group_impl = &group.base; 54 55 req1 = calloc(1, sizeof(struct spdk_sock_request) + 3 * sizeof(struct iovec)); 56 SPDK_CU_ASSERT_FATAL(req1 != NULL); 57 SPDK_SOCK_REQUEST_IOV(req1, 0)->iov_base = (void *)100; 58 SPDK_SOCK_REQUEST_IOV(req1, 0)->iov_len = 64; 59 SPDK_SOCK_REQUEST_IOV(req1, 1)->iov_base = (void *)200; 60 SPDK_SOCK_REQUEST_IOV(req1, 1)->iov_len = 64; 61 SPDK_SOCK_REQUEST_IOV(req1, 2)->iov_base = (void *)300; 62 SPDK_SOCK_REQUEST_IOV(req1, 2)->iov_len = 64; 63 req1->iovcnt = 3; 64 req1->cb_fn = _req_cb; 65 req1->cb_arg = &cb_arg1; 66 67 req2 = calloc(1, sizeof(struct spdk_sock_request) + 2 * sizeof(struct iovec)); 68 SPDK_CU_ASSERT_FATAL(req2 != NULL); 69 SPDK_SOCK_REQUEST_IOV(req2, 0)->iov_base = (void *)100; 70 SPDK_SOCK_REQUEST_IOV(req2, 0)->iov_len = 32; 71 SPDK_SOCK_REQUEST_IOV(req2, 1)->iov_base = (void *)200; 72 SPDK_SOCK_REQUEST_IOV(req2, 1)->iov_len = 32; 73 req2->iovcnt = 2; 74 req2->cb_fn = _req_cb; 75 req2->cb_arg = &cb_arg2; 76 77 /* Simple test - a request with a 3 element iovec 78 * that gets submitted in a single sendmsg. */ 79 spdk_sock_request_queue(sock, req1); 80 MOCK_SET(sendmsg, 192); 81 cb_arg1 = false; 82 rc = _sock_flush_client(sock); 83 CU_ASSERT(rc == 0); 84 CU_ASSERT(cb_arg1 == true); 85 CU_ASSERT(TAILQ_EMPTY(&sock->queued_reqs)); 86 87 /* Two requests, where both can fully send. */ 88 spdk_sock_request_queue(sock, req1); 89 spdk_sock_request_queue(sock, req2); 90 MOCK_SET(sendmsg, 256); 91 cb_arg1 = false; 92 cb_arg2 = false; 93 rc = _sock_flush_client(sock); 94 CU_ASSERT(rc == 0); 95 CU_ASSERT(cb_arg1 == true); 96 CU_ASSERT(cb_arg2 == true); 97 CU_ASSERT(TAILQ_EMPTY(&sock->queued_reqs)); 98 99 /* Two requests. Only first one can send */ 100 spdk_sock_request_queue(sock, req1); 101 spdk_sock_request_queue(sock, req2); 102 MOCK_SET(sendmsg, 192); 103 cb_arg1 = false; 104 cb_arg2 = false; 105 rc = _sock_flush_client(sock); 106 CU_ASSERT(rc == 0); 107 CU_ASSERT(cb_arg1 == true); 108 CU_ASSERT(cb_arg2 == false); 109 CU_ASSERT(TAILQ_FIRST(&sock->queued_reqs) == req2); 110 TAILQ_REMOVE(&sock->queued_reqs, req2, internal.link); 111 CU_ASSERT(TAILQ_EMPTY(&sock->queued_reqs)); 112 113 /* One request. Partial send. */ 114 spdk_sock_request_queue(sock, req1); 115 MOCK_SET(sendmsg, 10); 116 cb_arg1 = false; 117 rc = _sock_flush_client(sock); 118 CU_ASSERT(rc == 0); 119 CU_ASSERT(cb_arg1 == false); 120 CU_ASSERT(TAILQ_FIRST(&sock->queued_reqs) == req1); 121 122 /* Do a second flush that partial sends again. */ 123 MOCK_SET(sendmsg, 52); 124 cb_arg1 = false; 125 rc = _sock_flush_client(sock); 126 CU_ASSERT(rc == 0); 127 CU_ASSERT(cb_arg1 == false); 128 CU_ASSERT(TAILQ_FIRST(&sock->queued_reqs) == req1); 129 130 /* Flush the rest of the data */ 131 MOCK_SET(sendmsg, 130); 132 cb_arg1 = false; 133 rc = _sock_flush_client(sock); 134 CU_ASSERT(rc == 0); 135 CU_ASSERT(cb_arg1 == true); 136 CU_ASSERT(TAILQ_EMPTY(&sock->queued_reqs)); 137 138 free(req1); 139 free(req2); 140 } 141 142 static void 143 flush_server(void) 144 { 145 struct spdk_uring_sock_group_impl group = {}; 146 struct spdk_uring_sock usock = {}; 147 struct spdk_sock *sock = &usock.base; 148 struct spdk_sock_request *req1, *req2; 149 bool cb_arg1, cb_arg2; 150 int rc; 151 152 /* Set up data structures */ 153 TAILQ_INIT(&sock->queued_reqs); 154 TAILQ_INIT(&sock->pending_reqs); 155 sock->group_impl = &group.base; 156 usock.write_task.sock = &usock; 157 usock.group = &group; 158 159 req1 = calloc(1, sizeof(struct spdk_sock_request) + 2 * sizeof(struct iovec)); 160 SPDK_CU_ASSERT_FATAL(req1 != NULL); 161 SPDK_SOCK_REQUEST_IOV(req1, 0)->iov_base = (void *)100; 162 SPDK_SOCK_REQUEST_IOV(req1, 0)->iov_len = 64; 163 SPDK_SOCK_REQUEST_IOV(req1, 1)->iov_base = (void *)200; 164 SPDK_SOCK_REQUEST_IOV(req1, 1)->iov_len = 64; 165 req1->iovcnt = 2; 166 req1->cb_fn = _req_cb; 167 req1->cb_arg = &cb_arg1; 168 169 req2 = calloc(1, sizeof(struct spdk_sock_request) + 2 * sizeof(struct iovec)); 170 SPDK_CU_ASSERT_FATAL(req2 != NULL); 171 SPDK_SOCK_REQUEST_IOV(req2, 0)->iov_base = (void *)100; 172 SPDK_SOCK_REQUEST_IOV(req2, 0)->iov_len = 32; 173 SPDK_SOCK_REQUEST_IOV(req2, 1)->iov_base = (void *)200; 174 SPDK_SOCK_REQUEST_IOV(req2, 1)->iov_len = 32; 175 req2->iovcnt = 2; 176 req2->cb_fn = _req_cb; 177 req2->cb_arg = &cb_arg2; 178 179 /* we should not call _sock_flush directly, since it will finally 180 * call liburing related functions */ 181 182 /* Simple test - a request with a 2 element iovec 183 * that is fully completed. */ 184 spdk_sock_request_queue(sock, req1); 185 cb_arg1 = false; 186 rc = spdk_sock_prep_reqs(sock, usock.write_task.iovs, 0, NULL, NULL); 187 CU_ASSERT(rc == 2); 188 sock_complete_write_reqs(sock, 128, 0); 189 CU_ASSERT(cb_arg1 == true); 190 CU_ASSERT(TAILQ_EMPTY(&sock->queued_reqs)); 191 192 /* Two requests, where both can be fully completed. */ 193 spdk_sock_request_queue(sock, req1); 194 spdk_sock_request_queue(sock, req2); 195 cb_arg1 = false; 196 cb_arg2 = false; 197 rc = spdk_sock_prep_reqs(sock, usock.write_task.iovs, 0, NULL, NULL); 198 CU_ASSERT(rc == 4); 199 sock_complete_write_reqs(sock, 192, 0); 200 CU_ASSERT(cb_arg1 == true); 201 CU_ASSERT(cb_arg2 == true); 202 CU_ASSERT(TAILQ_EMPTY(&sock->queued_reqs)); 203 204 205 /* One request that is partially sent. */ 206 spdk_sock_request_queue(sock, req1); 207 cb_arg1 = false; 208 rc = spdk_sock_prep_reqs(sock, usock.write_task.iovs, 0, NULL, NULL); 209 CU_ASSERT(rc == 2); 210 sock_complete_write_reqs(sock, 92, 0); 211 CU_ASSERT(rc == 2); 212 CU_ASSERT(cb_arg1 == false); 213 CU_ASSERT(TAILQ_FIRST(&sock->queued_reqs) == req1); 214 215 /* Get the second time partial sent result. */ 216 sock_complete_write_reqs(sock, 10, 0); 217 CU_ASSERT(cb_arg1 == false); 218 CU_ASSERT(TAILQ_FIRST(&sock->queued_reqs) == req1); 219 220 /* Data is finally sent. */ 221 sock_complete_write_reqs(sock, 26, 0); 222 CU_ASSERT(cb_arg1 == true); 223 CU_ASSERT(TAILQ_EMPTY(&sock->queued_reqs)); 224 225 free(req1); 226 free(req2); 227 } 228 229 int 230 main(int argc, char **argv) 231 { 232 CU_pSuite suite = NULL; 233 unsigned int num_failures; 234 235 CU_set_error_action(CUEA_ABORT); 236 CU_initialize_registry(); 237 238 suite = CU_add_suite("uring", NULL, NULL); 239 240 241 CU_ADD_TEST(suite, flush_client); 242 CU_ADD_TEST(suite, flush_server); 243 244 CU_basic_set_mode(CU_BRM_VERBOSE); 245 246 CU_basic_run_tests(); 247 248 num_failures = CU_get_number_of_failures(); 249 CU_cleanup_registry(); 250 251 return num_failures; 252 } 253